FastAPI integration patterns in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI endpoint with LangChain?

Consider a FastAPI endpoint that uses LangChain to process a prompt and return a response. What will the endpoint return when called with the prompt 'Hello'?

LangChain

from fastapi import FastAPI
from langchain.llms import OpenAI

app = FastAPI()
llm = OpenAI(temperature=0)

@app.get('/generate')
async def generate(prompt: str):
    response = llm(prompt)
    return {'result': response}

# Assume llm returns 'Hello, how can I help you?' for prompt 'Hello'

A {"result": "Hello"}

B {"result": "Hello, how can I help you?"}

C {"error": "Model not found"}

D {"result": ""}

💡 Hint

Think about what the LangChain OpenAI model returns for the given prompt.

The OpenAI model in LangChain processes the prompt 'Hello' and returns a generated response. The endpoint wraps this response in a JSON with key 'result'.

❓ lifecycle

intermediate

When is the LangChain model instantiated in this FastAPI app?

Given this FastAPI app code, when is the LangChain OpenAI model created?

LangChain

from fastapi import FastAPI
from langchain.llms import OpenAI

app = FastAPI()
llm = OpenAI(temperature=0)

@app.get('/generate')
async def generate(prompt: str):
    return {'result': llm(prompt)}

A At app startup, before any requests are handled

B Every time the /generate endpoint is called

C Only when the first request to /generate is received

D When the server shuts down

💡 Hint

Look at where the llm variable is defined in the code.

The llm variable is created at the module level, so it is instantiated once when the app starts, not per request.

📝 Syntax

advanced

Which option correctly integrates LangChain with FastAPI for async calls?

You want to call a LangChain LLM asynchronously inside a FastAPI endpoint. Which code snippet correctly does this?

A

async def generate(prompt: str):
    response = llm(prompt)
    return {'result': response}

B

def generate(prompt: str):
    response = llm(prompt)
    return {'result': response}

C

def generate(prompt: str):
    response = await llm.acall(prompt)
    return {'result': response}

D

async def generate(prompt: str):
    response = await llm.acall(prompt)
    return {'result': response}

💡 Hint

Check which methods support async and how to use await properly.

LangChain LLMs provide an async method acall for asynchronous calls. The FastAPI endpoint must be async and await the acall method.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a runtime error?

This FastAPI endpoint code raises a runtime error when called. What is the cause?

LangChain

from fastapi import FastAPI
from langchain.llms import OpenAI

app = FastAPI()
llm = OpenAI(temperature=0)

@app.get('/generate')
def generate(prompt: str):
    response = await llm.acall(prompt)
    return {'result': response}

A FastAPI does not support async endpoints

B The llm object does not have an acall method

C The endpoint function is not async but uses await

D The prompt parameter is missing a default value

💡 Hint

Check the function definition and usage of await.

Using await requires the function to be async. Here, the function is defined as a normal def, so await causes a runtime error.

🧠 Conceptual

expert

What is the best pattern to share a LangChain LLM instance across multiple FastAPI endpoints?

You want to use a single LangChain LLM instance efficiently across many FastAPI endpoints without recreating it each time. Which pattern is best?

A Use FastAPI dependency injection with a singleton provider for the LLM instance

B Create a new LLM instance inside each endpoint function to ensure fresh state

C Create the LLM instance once at module level and import it in all endpoint modules

D Store the LLM instance in a global variable inside each endpoint function

💡 Hint

Consider FastAPI's recommended way to share resources safely and efficiently.

FastAPI dependency injection with a singleton provider allows controlled, efficient sharing of the LLM instance with proper lifecycle management.