LangServe for API deployment in LangChain - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the LangServe class from langchain.servers.

LangChain

from langchain.servers import [1]

Drag options to blanks, or click blank then click option'

ALangServe

BLangChain

CServerAPI

DLangServer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'LangChain' instead of 'LangServe'.

Using 'LangServer' which is incorrect.

The LangServe class is imported from langchain.servers to create API servers.

2fill in blank

medium

Complete the code to create a LangServe instance with a given chain named 'my_chain'.

LangChain

server = LangServe(chain=[1])

Drag options to blanks, or click blank then click option'

Aserver

Bmy_chain

Cchain

Dapi

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the string 'chain' instead of the variable.

Using 'server' which is the LangServe instance itself.

The LangServe instance requires the chain object to be passed as the 'chain' argument. Here, the chain is named 'my_chain'.

3fill in blank

hard

Fix the error in the code to start the LangServe API server.

LangChain

server.[1]()

Drag options to blanks, or click blank then click option'

Astart

Brun

Claunch

Dserve

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'run' or 'start' which are common but incorrect here.

The correct method to start the LangServe server is 'serve()'.

4fill in blank

hard

Fill both blanks to define a simple LangServe API with a chain and start it.

LangChain

from langchain.servers import [1]
server = [2](chain=my_chain)
server.serve()

Drag options to blanks, or click blank then click option'

ALangServe

BLangChain

CServerAPI

DLangServer

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing import and instance names.

Using 'LangChain' or 'LangServer' instead.

Both blanks require 'LangServe' to import the class and create its instance.

5fill in blank

hard

Fill all three blanks to create a LangServe server with a chain, specify a port, and start the server.

LangChain

from langchain.servers import [1]
server = [2](chain=my_chain, port=[3])
server.serve()

Drag options to blanks, or click blank then click option'

ALangServe

BLangChain

C8080

D5000

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong class names.

Choosing port 8080 which is valid but not the expected answer here.

Import and instantiate LangServe, then specify port 5000 to run the server on that port.

Practice

1. What is the main purpose of LangServe in LangChain?

easy

A. To quickly turn language models into web APIs

B. To train new language models from scratch

C. To visualize language model outputs in charts

D. To store large datasets for language models

Solution

1. Step 1: Understand LangServe's role

   LangServe is designed to make language models accessible as web APIs easily.

2. Step 2: Compare options with LangServe's function

   Only To quickly turn language models into web APIs matches this purpose; others describe unrelated tasks.

3. Final Answer:

   To quickly turn language models into web APIs -> Option A

4. Quick Check:

   LangServe = API deployment [OK]

Hint: LangServe = language model + web API [OK]

Common Mistakes:

• Confusing LangServe with model training tools
• Thinking LangServe is for data storage
• Assuming LangServe creates visualizations

2. Which of the following is the correct minimal structure for a LangServe class?

easy

A. def MyAPI(input):
return input.upper()

B. class MyAPI:
def __call__(self, input):
return input.upper()

C. class MyAPI:
def call(self, input):
return input.upper()

D. class MyAPI:
def __init__(self, input):
return input.upper()

Solution

1. Step 1: Identify required method for LangServe

   LangServe requires a class with a __call__ method to handle requests.

2. Step 2: Check each option's method name and structure

   Only class MyAPI: def __call__(self, input): return input.upper() uses __call__ correctly; others use wrong method names or invalid return in __init__.

3. Final Answer:

   class with __call__ method -> Option B

4. Quick Check:

   __call__ method = correct structure [OK]

Hint: LangServe needs __call__, not call or __init__ [OK]

Common Mistakes:

• Using call instead of __call__
• Returning values from __init__ method
• Defining a function instead of a class

3. Given this LangServe class:

class EchoAPI:
    def __call__(self, input):
        return f"Echo: {input}"

What will be the output when calling EchoAPI()('hello')?

medium

A. "hello"

B. TypeError: 'EchoAPI' object is not callable

C. "Echo: hello"

D. "EchoAPI: hello"

Solution

1. Step 1: Understand __call__ method behavior

   The __call__ method formats the input by prefixing 'Echo: ' to it.

2. Step 2: Evaluate the call EchoAPI()('hello')

   Creating EchoAPI instance and calling it with 'hello' returns 'Echo: hello'.

3. Final Answer:

   "Echo: hello" -> Option C

4. Quick Check:

   __call__ returns formatted string [OK]

Hint: Calling instance runs __call__ method [OK]

Common Mistakes:

• Expecting raw input without prefix
• Thinking instance is not callable
• Confusing class name with output

4. What is wrong with this LangServe class?

class BadAPI:
    def call(self, input):
        return input[::-1]

medium

A. The return statement should convert input to uppercase

B. The input slicing syntax is incorrect

C. The class must inherit from a base LangServe class

D. The method should be named __call__, not call

Solution

1. Step 1: Check method name required by LangServe

   LangServe expects a __call__ method to make the class callable.

2. Step 2: Analyze method name in BadAPI

   BadAPI uses call instead of __call__, so it won't work as expected.

3. Final Answer:

   The method should be named __call__, not call -> Option D

4. Quick Check:

   __call__ method required [OK]

Hint: Method must be __call__, not call [OK]

Common Mistakes:

• Using call instead of __call__
• Assuming inheritance is mandatory
• Thinking input slicing is invalid

5. You want to deploy a LangServe API that reverses input text but only if the input is a non-empty string. Which class correctly implements this?

hard

A. class ReverseAPI:
def __call__(self, input):
if input is None or input == "":
return "Empty input"
return input[::-1]

B. class ReverseAPI:
def __call__(self, input):
return input[::-1] if input != None else "Empty input"

C. class ReverseAPI:
def __call__(self, input):
if input == "":
return "Empty input"
else:
return input[::-1]

D. class ReverseAPI:
def __call__(self, input):
if input != "":
return input[::-1]
return "Empty input"

Solution

1. Step 1: Identify conditions for input validation

   We must check if input is None or empty string to handle empty input properly.

2. Step 2: Evaluate each option's condition

   class ReverseAPI: def __call__(self, input): if input is None or input == "": return "Empty input" return input[::-1] checks both None and empty string correctly before reversing input.

3. Final Answer:

   Checks both None and empty string before reversing -> Option A

4. Quick Check:

   Check None and empty string before processing [OK]

Hint: Check None and empty string explicitly [OK]

Common Mistakes:

• Only checking for empty string, missing None
• Using != None instead of is None
• Not handling empty input cases