LangChain Practice Exam — LearnCoachAssist

Question 1 LangChain

What is text-embedding-3-small vs text-embedding-3-large?

A PromptValue is the intermediate output of a prompt template — it has .to_string() and .to_messages() methods so the same prompt can be fed to either a string LLM or a chat model without rewriting the template. store is a cross-session BaseStore (key/value) used for long-term facts (e.g., user preferences). Session history is the per-thread message list. LangChain exposes both through get_store and get_session_history callbacks in RunnableWithMessageHistory. OpenAI's third-generation embedding models. text-embedding-3-small has 1536 dimensions, text-embedding-3-large has 3072 dimensions. Both support a dimensions parameter to truncate embeddings for cheaper storage with minimal recall loss. For OpenAI models, structured output is achieved natively by passing a JSON schema (or Pydantic model) to the tools / response_format parameter. with_structured_output is the unified LangChain wrapper for this.

Question 2 LangChain

What is LangGraph's StateGraph?

StateGraph is the core LangGraph primitive: a directed graph where nodes are functions/Runnables that read and update a shared typed state, and edges define the flow including conditional branching.

from langgraph.graph import StateGraph, START, END
builder = StateGraph(State)
builder.add_node("agent", agent_node)
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", should_continue)
builder.add_edge("agent", END)
app = builder.compile()

OpenAI's third-generation embedding models. text-embedding-3-small has 1536 dimensions, text-embedding-3-large has 3072 dimensions. Both support a dimensions parameter to truncate embeddings for cheaper storage with minimal recall loss. A Document is a data class with page_content (text string) and metadata (dict). All loaders, splitters, and retrievers work with Documents.

from langchain_core.documents import Document

doc = Document(
    page_content="LangChain is a framework for LLMs.",
    metadata={"source": "docs", "page": 1}
)
print(doc.page_content)
print(doc.metadata)

LangChain provides loaders for many file types. Each returns a list of Document objects.

from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    WebBaseLoader,
)

# Load a text file
docs = TextLoader("notes.txt").load()

# Load a PDF
docs = PyPDFLoader("paper.pdf").load()

# Load a web page
docs = WebBaseLoader("https://example.com").load()

Question 3 LangChain

What is RunnableLambda?

Parses LLM output into one of a fixed set of Enum values, validating that the model picked an allowed option. Useful for classification / routing tasks. An evaluator that asks an LLM to grade a prediction against a custom criterion (e.g., "Is the answer helpful? Concise? Factually correct?"). Useful for subjective quality metrics without writing a grader prompt from scratch. A semantic cache that uses embedding similarity to match new queries to cached prompts. Two prompts with similar meaning (not just identical text) return the same cached response. Set a score_threshold to control how strict the match is. RunnableLambda wraps any Python function as a LangChain Runnable so it can be composed in LCEL chains.

from langchain_core.runnables import RunnableLambda

def word_count(text: str) -> int:
    return len(text.split())

chain = llm | StrOutputParser() | RunnableLambda(word_count)
count = chain.invoke("Write a short poem")

Question 4 LangChain

What is handle_parsing_errors in AgentExecutor?

For OpenAI models, structured output is achieved natively by passing a JSON schema (or Pydantic model) to the tools / response_format parameter. with_structured_output is the unified LangChain wrapper for this. When the LLM produces malformed tool calls, the executor can either raise (False), silently retry (True), or pass a custom error handler that crafts a corrective message. RunnableLambda wraps any Python function as a LangChain Runnable so it can be composed in LCEL chains.

from langchain_core.runnables import RunnableLambda

def word_count(text: str) -> int:
    return len(text.split())

chain = llm | StrOutputParser() | RunnableLambda(word_count)
count = chain.invoke("Write a short poem")

Use .batch() to process multiple inputs concurrently. It accepts a list of inputs and returns a list of outputs.

chain = prompt | llm | StrOutputParser()

results = chain.batch([
    {"topic": "Python"},
    {"topic": "JavaScript"},
    {"topic": "Rust"},
], config={"max_concurrency": 3})

for r in results:
    print(r[:100])

Question 5 LangChain

What is DatetimeOutputParser?

Pass tool_choice="any" to force the model to call a tool, or tool_choice={"type": "tool", "name": "my_tool"} to force a specific one. Useful for routing decisions.

llm.bind_tools([a, b], tool_choice="a").invoke(query)

LangChain provides loaders for many file types. Each returns a list of Document objects.

from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    WebBaseLoader,
)

# Load a text file
docs = TextLoader("notes.txt").load()

# Load a PDF
docs = PyPDFLoader("paper.pdf").load()

# Load a web page
docs = WebBaseLoader("https://example.com").load()

RunnableBranch routes input to different chains based on conditions. Pass tuples of (condition, runnable) plus a default.

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: "code" in x["topic"], code_chain),
    (lambda x: "math" in x["topic"], math_chain),
    general_chain,  # default
)
result = branch.invoke({"topic": "code review"})

Parses LLM output into a Python datetime using a Pydantic-style format string passed via format_instructions.

from langchain.output_parsers import DatetimeOutputParser
parser = DatetimeOutputParser(format="%Y-%m-%d")

Question 6 LangChain

How do you create a LangSmith dataset and run an evaluation?

You ask the LLM to generate a hypothetical answer to the query, embed that, and use the embedding for retrieval. Often gives better recall than embedding the bare question because it lands in the same region of embedding space as real answers. ChatMessageHistory is a simple in-memory message store for managing conversation turns manually.

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.messages import HumanMessage, AIMessage

history = ChatMessageHistory()
history.add_user_message("Hi!")
history.add_ai_message("Hello! How can I help?")
history.add_message(HumanMessage(content="What is AI?"))

print(history.messages)  # list of BaseMessage objects

Use Client.create_dataset to define examples (input + expected output), then Client.evaluate with an evaluator (e.g., label_score, cot_qa, or custom) to score your chain. Runs are logged under a project name for comparison. Swap the in-memory ChatMessageHistory for a persistent implementation: RedisChatMessageHistory, PostgresChatMessageHistory, SQLChatMessageHistory, or a custom subclass. Pass it to the same get_session_history factory.

Question 7 LangChain

How do you use callbacks in LangChain?

Callbacks let you hook into chain execution for logging, tracing, or custom side effects. Pass them via config or set them globally.

from langchain_core.callbacks import BaseCallbackHandler

class LogHandler(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with {len(prompts)} prompts")
    def on_llm_end(self, response, **kwargs):
        print(f"LLM finished")

chain.invoke(
    {"topic": "AI"},
    config={"callbacks": [LogHandler()]}
)

ConversationEntityMemory extracts named entities mentioned in the conversation and stores facts about each, then injects relevant entity info into future prompts. Useful for assistants that need to remember user-specific details. Combine .with_retry() for transient errors with a callback handler that records token usage. Then enforce a daily or per-user token budget by short-circuiting the chain when the budget is exceeded (often via a guard runnable or a router). A simpler splitter that splits on a single separator string (default "\n\n"). Use it when you know the document structure is uniform (e.g., one paragraph per record).

from langchain_text_splitters import CharacterTextSplitter
splitter = CharacterTextSplitter(
    separator="\n", chunk_size=500, chunk_overlap=50
)

Question 8 LangChain

How do you create a tool with StructuredTool?

StructuredTool lets you define tools with explicit Pydantic schemas for complex input validation.

from langchain_core.tools import StructuredTool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search query")
    max_results: int = Field(default=5)

def search(query: str, max_results: int = 5) -> str:
    return f"Results for '{query}' (top {max_results})"

search_tool = StructuredTool.from_function(
    func=search,
    name="web_search",
    description="Search the web",
    args_schema=SearchInput,
)

Use chain.astream_events(input, version="v2") to receive typed events (on_chat_model_start, on_tool_start, on_chain_end, etc.) as the chain executes. This is the most granular streaming API. Text splitters break large documents into smaller chunks for embedding. RecursiveCharacterTextSplitter is the most commonly used.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " "],
)
chunks = splitter.split_documents(docs)
print(f"{len(chunks)} chunks created")

Combine .with_retry() for transient errors with a callback handler that records token usage. Then enforce a daily or per-user token budget by short-circuiting the chain when the budget is exceeded (often via a guard runnable or a router).

Question 9 LangChain

How do you invoke a ChatModel in LangChain?

A template that dynamically injects example input/output pairs into the prompt to guide the model via in-context learning.

from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate

examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
]
example_prompt = PromptTemplate.from_template(
    "Input: {input}\nOutput: {output}"
)
few_shot = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    prefix="Give the antonym of the input.",
    suffix="Input: {input}\nOutput:",
    input_variables=["input"],
)
print(few_shot.invoke({"input": "big"}).text)

StructuredTool lets you define tools with explicit Pydantic schemas for complex input validation.

from langchain_core.tools import StructuredTool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search query")
    max_results: int = Field(default=5)

def search(query: str, max_results: int = 5) -> str:
    return f"Results for '{query}' (top {max_results})"

search_tool = StructuredTool.from_function(
    func=search,
    name="web_search",
    description="Search the web",
    args_schema=SearchInput,
)

Instantiate the model class and call .invoke() with a list of messages or a prompt value. The model returns an AIMessage.

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o", temperature=0)
response = llm.invoke([
    HumanMessage(content="What is LangChain?")
])
print(response.content)

LCEL is a declarative syntax for composing LangChain components using the pipe operator (|). It creates RunnableSequence chains that support streaming, batching, and async out of the box.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

chain = (
    ChatPromptTemplate.from_template("Explain {topic} simply.")
    | ChatOpenAI(model="gpt-4o")
    | StrOutputParser()
)
result = chain.invoke({"topic": "recursion"})

Question 10 LangChain

What is the SQL Agent?

A LangChain/LangGraph agent that uses an LLM to write and execute SQL queries against a SQLDatabase. It inspects the schema, generates a query, executes it, and (with self-correction) retries on errors. Set top_k on SQLDatabase to cap rows returned. @RunnableLambda.from_runnable is used inside a RunnableGenerator / async generator-style custom runnable when you need to implement transform / astream directly while still benefiting from config propagation. A chain has a deterministic, predefined sequence of steps. An agent uses an LLM at runtime to decide which tools to call, in what order, and how many times. Agents are non-deterministic and harder to test; chains are easier to debug but less flexible. A Document is a data class with page_content (text string) and metadata (dict). All loaders, splitters, and retrievers work with Documents.

from langchain_core.documents import Document

doc = Document(
    page_content="LangChain is a framework for LLMs.",
    metadata={"source": "docs", "page": 1}
)
print(doc.page_content)
print(doc.metadata)

Question 11 LangChain

What is ConversationalRetrievalChain?

Legacy chain that combines a retriever with a question-rewriting step that uses chat history to reformulate the query. Modern equivalent: a graph with a rewrite_question node feeding the retriever, then a generate node. Call .as_retriever() on any vector store to get a Retriever that works in LCEL chains. You can configure search type and parameters.

retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4},
)

# Use in a chain
docs = retriever.invoke("What is LangChain?")
for doc in docs:
    print(doc.page_content[:80])

A Run Tree is the nested hierarchy of Run objects produced by a single invoke call. Each LLM call, retriever call, and tool call is a node; edges represent the data flow. You can replay any run by re-invoking the recorded inputs. RunnableLambda wraps any Python function as a LangChain Runnable so it can be composed in LCEL chains.

from langchain_core.runnables import RunnableLambda

def word_count(text: str) -> int:
    return len(text.split())

chain = llm | StrOutputParser() | RunnableLambda(word_count)
count = chain.invoke("Write a short poem")

Question 12 LangChain

What is BaseChatModel?

chunk_size is the maximum length (in characters or tokens, depending on length_function) of each chunk. chunk_overlap is the number of characters from the end of one chunk repeated at the start of the next — it prevents context loss at chunk boundaries. StructuredTool lets you define tools with explicit Pydantic schemas for complex input validation.

from langchain_core.tools import StructuredTool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search query")
    max_results: int = Field(default=5)

def search(query: str, max_results: int = 5) -> str:
    return f"Results for '{query}' (top {max_results})"

search_tool = StructuredTool.from_function(
    func=search,
    name="web_search",
    description="Search the web",
    args_schema=SearchInput,
)

A ChatModel takes a list of BaseMessage objects and returns an AIMessage, supporting multi-turn conversations and tool calls. The legacy LLM class takes a string and returns a string; it is largely deprecated in favor of chat models. BaseChatModel is the abstract base class for chat-style models (GPT-4o, Claude, Gemini). Subclasses implement _generate and _stream; everything else (tool calling, structured output, batching) is provided by the framework.

Question 13 LangChain

How do you use a MultiQueryRetriever?

MultiQueryRetriever generates multiple query variations using an LLM, retrieves documents for each, and merges the results for better recall.

from langchain.retrievers.multi_query import MultiQueryRetriever

retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(),
    llm=ChatOpenAI(model="gpt-4o-mini"),
)
docs = retriever.invoke("How does memory work in LangChain?")

Use Language enum with RecursiveCharacterTextSplitter.from_language() to split code respecting function and class boundaries.

from langchain_text_splitters import (
    RecursiveCharacterTextSplitter,
    Language,
)

python_splitter = RecursiveCharacterTextSplitter.from_language(
    language=Language.PYTHON,
    chunk_size=1000,
    chunk_overlap=100,
)
chunks = python_splitter.split_documents(code_docs)

SelfQueryRetriever uses an LLM to translate a natural-language query into a structured query (semantic + metadata filters). The vector store must support metadata filtering.

from langchain.retrievers.self_query.base import SelfQueryRetriever
retriever = SelfQueryRetriever.from_llm(
    llm=llm,
    vectorstore=vectorstore,
    document_content_description="AI/ML papers",
    metadata_field_info=[...],
)

invoke returns the final output after the entire chain finishes. stream returns an iterator that yields intermediate chunks (often just the final parser's tokens). For a model | parser chain, the chunks are the model's text deltas.

Question 14 LangChain

What is a conditional edge in LangGraph?

An agent type that uses OpenAI's native function-calling API to decide tool invocations instead of parsing a ReAct text trace. It is more reliable than ReAct on OpenAI models and is the default for create_openai_functions_agent. Combine a retriever, prompt, and LLM using LCEL. RunnablePassthrough forwards the question alongside retrieved context.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    "Answer based on context:\n{context}\n\nQuestion: {question}"
)

def format_docs(docs):
    return "\n\n".join(d.page_content for d in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
answer = rag_chain.invoke("What is LangChain?")

A conditional edge routes to different nodes based on a function that inspects the current state. The routing function returns a node name (or list of names for parallel fan-out).

def should_continue(state):
    return "tools" if state["messages"][-1].tool_calls else END
builder.add_conditional_edges("agent", should_continue)

.pick("key") returns a runnable that pulls one key out of a dict (or one index out of a tuple). It short-circuits upstream computation by skipping unselected branches.

full = RunnableParallel(
    summary=summary_chain,
    keywords=keyword_chain,
    sentiment=sentiment_chain,
)
just_summary = full.pick("summary")

Question 15 LangChain

How do you load environment variables for LangChain API keys?

Use dotenv or set environment variables directly. LangChain reads OPENAI_API_KEY and other keys automatically.

from dotenv import load_dotenv
import os

load_dotenv()  # reads .env file

# Or set directly
os.environ["OPENAI_API_KEY"] = "sk-..."

# LangChain auto-detects the key
from langchain_openai import ChatOpenAI
llm = ChatOpenAI()  # uses OPENAI_API_KEY

OpenAI's third-generation embedding models. text-embedding-3-small has 1536 dimensions, text-embedding-3-large has 3072 dimensions. Both support a dimensions parameter to truncate embeddings for cheaper storage with minimal recall loss. RunnablePassthrough passes its input through unchanged. Commonly used in RAG chains to forward the original question alongside retrieved context.

from langchain_core.runnables import RunnablePassthrough

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
answer = chain.invoke("What is LangChain?")

You ask the LLM to generate a hypothetical answer to the query, embed that, and use the embedding for retrieval. Often gives better recall than embedding the bare question because it lands in the same region of embedding space as real answers.

Question 16 LangChain

What is create_stuff_documents_chain?

A simpler splitter that splits on a single separator string (default "\n\n"). Use it when you know the document structure is uniform (e.g., one paragraph per record).

from langchain_text_splitters import CharacterTextSplitter
splitter = CharacterTextSplitter(
    separator="\n", chunk_size=500, chunk_overlap=50
)

A chain that takes a list of Documents, stuffs them all into a single prompt (as {context}), and generates an answer. The "stuff" strategy is the simplest RAG approach — works only when total context fits the window.

from langchain.chains.combine_documents import create_stuff_documents_chain
chain = create_stuff_documents_chain(llm, prompt)

chunk_size is the maximum length (in characters or tokens, depending on length_function) of each chunk. chunk_overlap is the number of characters from the end of one chunk repeated at the start of the next — it prevents context loss at chunk boundaries. A RunnableSequence chains runnables so the output of one becomes the input of the next. Created automatically when you use the | pipe operator in LCEL.

from langchain_core.runnables import RunnableSequence

# These are equivalent:
chain = prompt | llm | parser
chain = RunnableSequence(first=prompt, middle=[llm], last=parser)

result = chain.invoke({"topic": "AI"})

Question 17 LangChain

How do you create a custom Retriever in LangChain?

Call runnable.get_input_schema() and get_output_schema() (Pydantic models). get_graph() returns a drawable graph; get_prompts() lists prompts nested in the chain — useful for LangSmith inspection. Subclass BaseRetriever and implement _get_relevant_documents (and optionally _aget_relevant_documents for async). Set the class attribute model_config = ConfigDict(arbitrary_types_allowed=True) and the lc_namespace for serialization. Define your runnable, then in a FastAPI app use add_routes(app, runnable, path="/mychain"). Provide a RunnableConfig factory with configurable keys (model, prompts) for runtime overrides.

from langserve import add_routes
add_routes(app, chain, path="/rag")

A chain that takes a list of Documents, stuffs them all into a single prompt (as {context}), and generates an answer. The "stuff" strategy is the simplest RAG approach — works only when total context fits the window.

from langchain.chains.combine_documents import create_stuff_documents_chain
chain = create_stuff_documents_chain(llm, prompt)

Question 18 LangChain

What is RetryWithErrorOutputParser?

Callbacks let you hook into chain execution for logging, tracing, or custom side effects. Pass them via config or set them globally.

from langchain_core.callbacks import BaseCallbackHandler

class LogHandler(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with {len(prompts)} prompts")
    def on_llm_end(self, response, **kwargs):
        print(f"LLM finished")

chain.invoke(
    {"topic": "AI"},
    config={"callbacks": [LogHandler()]}
)

Wrap any base parser with OutputFixingParser.from_llm(parser, llm). If the LLM output fails to parse, the wrapped parser uses the LLM to fix the error and re-parse, avoiding total chain failure.

from langchain.output_parsers import OutputFixingParser
parser = OutputFixingParser.from_llm(
    PydanticOutputParser(pydantic_object=Person), llm
)

Like OutputFixingParser, but it re-prompts the LLM with both the original output and the parser's error message, giving the model explicit feedback on what went wrong. Better for structurally complex schemas. An evaluator that asks an LLM to grade a prediction against a custom criterion (e.g., "Is the answer helpful? Concise? Factually correct?"). Useful for subjective quality metrics without writing a grader prompt from scratch.

Question 19 LangChain

What is MarkdownTextSplitter?

MarkdownTextSplitter splits Markdown by its syntax structure — headers, code blocks, lists — preserving the formatting context as metadata. ExperimentalMarkdownSyntaxTextSplitter adds richer metadata (code language, header paths). Wrap any base parser with OutputFixingParser.from_llm(parser, llm). If the LLM output fails to parse, the wrapped parser uses the LLM to fix the error and re-parse, avoiding total chain failure.

from langchain.output_parsers import OutputFixingParser
parser = OutputFixingParser.from_llm(
    PydanticOutputParser(pydantic_object=Person), llm
)

All embedding models implement embed_documents(texts: List[str]) -> List[List[float]] and embed_query(text: str) -> List[float]. The asymmetric design lets providers cache document embeddings while recomputing queries. RunnableLambda wraps any Python function as a LangChain Runnable so it can be composed in LCEL chains.

from langchain_core.runnables import RunnableLambda

def word_count(text: str) -> int:
    return len(text.split())

chain = llm | StrOutputParser() | RunnableLambda(word_count)
count = chain.invoke("Write a short poem")

Question 20 LangChain

What is MessagesPlaceholder?

MessagesPlaceholder inserts a dynamic list of messages (e.g., chat history) into a ChatPromptTemplate.

from langchain_core.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder("chat_history"),
    ("human", "{input}"),
])

A Checkpoint is a snapshot of the graph's state at a point in time. The MemorySaver (in-memory) and SqliteSaver / PostgresSaver (persistent) checkpointers let you pause, resume, rewind, and branch conversations. .with_structured_output() binds a Pydantic model or JSON schema to the LLM so it returns validated structured data directly.

from langchain_openai import ChatOpenAI
from pydantic import BaseModel

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str

llm = ChatOpenAI(model="gpt-4o")
structured_llm = llm.with_structured_output(MovieReview)

review = structured_llm.invoke("Review The Matrix")
print(review.title, review.rating)

Generates an answer for each retrieved document independently, then summarizes all answers. Better than "stuff" for large corpora but slower (N+1 LLM calls) and loses cross-document reasoning.

Question 21 LangChain

What is a Runnable in LangChain?

RunnableBranch routes input to different chains based on conditions. Pass tuples of (condition, runnable) plus a default.

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: "code" in x["topic"], code_chain),
    (lambda x: "math" in x["topic"], math_chain),
    general_chain,  # default
)
result = branch.invoke({"topic": "code review"})

PGVector is the Postgres extension for vector search. langchain-postgres exposes PGVector — useful when you already have a Postgres database and want to avoid a second data store. A Runnable is the base interface for any component that can be invoked, streamed, batched, and composed in LCEL. All chat models, prompts, retrievers, output parsers, and even Python functions (via RunnableLambda) implement it.

class Runnable(Generic[Input, Output]):
    def invoke(self, input, config=None) -> Output: ...
    async def ainvoke(self, input, config=None) -> Output: ...
    def stream(self, input, config=None) -> Iterator[Output]: ...
    def batch(self, inputs, config=None) -> List[Output]: ...

.assign() on a RunnableParallel adds a new key to the output dict while preserving the original input. It enables map-step-style data flow inside a chain.

chain = (
    RunnablePassthrough.assign(
        context=lambda x: retriever.invoke(x["question"])
    )
    | prompt | llm | parser
)

Question 22 LangChain

What is BaseTool and how does it differ from @tool?

BaseTool is the abstract class underlying every tool — _run, _arun, args_schema, name, description. The @tool decorator is a shortcut for the common case of wrapping a function; subclassing gives you full control (validation, async-only, dynamic schema). RunnableParallel runs multiple runnables concurrently and returns a dict of results. Useful for branching logic.

from langchain_core.runnables import RunnableParallel

chain = RunnableParallel(
    summary=summary_chain,
    translation=translate_chain,
    keywords=keyword_chain,
)
results = chain.invoke({"text": "LangChain is..."})
# results = {"summary": ..., "translation": ..., "keywords": ...}

A chain has a deterministic, predefined sequence of steps. An agent uses an LLM at runtime to decide which tools to call, in what order, and how many times. Agents are non-deterministic and harder to test; chains are easier to debug but less flexible. Combine .with_retry() for transient errors with a callback handler that records token usage. Then enforce a daily or per-user token budget by short-circuiting the chain when the budget is exceeded (often via a guard runnable or a router).

Question 23 LangChain

How do you create and query a vector store?

Chroma is an open-source embedding database that supports persistent local storage.

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

# Create and persist
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=OpenAIEmbeddings(),
    persist_directory="./chroma_db",
)

# Load existing
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=OpenAIEmbeddings(),
)
results = vectorstore.similarity_search("LangChain", k=3)

Vector stores index document embeddings for similarity search. FAISS is a popular local option.

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

# Create from documents
vectorstore = FAISS.from_documents(
    documents=chunks,
    embedding=OpenAIEmbeddings(),
)

# Similarity search
results = vectorstore.similarity_search(
    "How does LangChain work?", k=3
)
for doc in results:
    print(doc.page_content[:100])

Every Runnable supports invoke, ainvoke, stream, astream, batch, abatch, astream_log, and transform. This uniform interface is what makes LCEL composition work across any component type. BaseTool is the abstract class underlying every tool — _run, _arun, args_schema, name, description. The @tool decorator is a shortcut for the common case of wrapping a function; subclassing gives you full control (validation, async-only, dynamic schema).

Question 24 LangChain

What is the difference between an agent and a chain?

Pass tool_choice="any" to force the model to call a tool, or tool_choice={"type": "tool", "name": "my_tool"} to force a specific one. Useful for routing decisions.

llm.bind_tools([a, b], tool_choice="a").invoke(query)

ParentDocumentRetriever indexes small chunks (for precise retrieval) but returns the larger parent document they came from, so the LLM sees more context. It stores parent-child IDs in a Docstore. A chain has a deterministic, predefined sequence of steps. An agent uses an LLM at runtime to decide which tools to call, in what order, and how many times. Agents are non-deterministic and harder to test; chains are easier to debug but less flexible. PydanticOutputParser parses LLM output directly into a Pydantic model instance with validation and error messages.

from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

parser = PydanticOutputParser(pydantic_object=Person)
chain = prompt | llm | parser
person = chain.invoke({"query": "Tell me about Alice, age 30"})
print(person.name, person.age)

Question 25 LangChain

What is EmbeddingsRedundantFilter?

Computes cosine, euclidean, or Manhattan distance between the embeddings of the prediction and the reference. Returns a float score. Cheaper than LLM-based evaluators but less semantically robust. LangChain integrates with LangSmith (and provides langchain.evaluation modules) for evaluating chains on datasets. Evaluators include StringEvaluator subclasses like QAEvaluator, CriteriaEvalChain, LabeledCriteriaEvalChain, and embedding-distance metrics. A DocumentCompressor that drops retrieved documents whose embeddings are too similar to already-kept ones, removing near-duplicates from the context fed to the LLM. A retriever wrapper that compresses or filters retrieved documents using an LLM or embeddings to keep only the most relevant content.

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=retriever,
)
docs = compression_retriever.invoke("What is LCEL?")

Question 26 LangChain

What is a Checkpoint in LangGraph?

RunnableBranch routes input to different chains based on conditions. Pass tuples of (condition, runnable) plus a default.

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: "code" in x["topic"], code_chain),
    (lambda x: "math" in x["topic"], math_chain),
    general_chain,  # default
)
result = branch.invoke({"topic": "code review"})

A post-processor that rearranges retrieved documents so the most relevant are at the start and end of the list, exploiting the "lost in the middle" effect where LLMs pay more attention to the extremes of long contexts. A Checkpoint is a snapshot of the graph's state at a point in time. The MemorySaver (in-memory) and SqliteSaver / PostgresSaver (persistent) checkpointers let you pause, resume, rewind, and branch conversations. In LCEL, a "token" is a chunk yielded by a streaming runnable. The pipe operator ensures tokens flow through the chain as they are produced, so the final output starts streaming immediately instead of waiting for the whole LLM response.

Question 27 LangChain

What is a token in an LCEL chain?

Parses LLM output into a Python dict by traversing an XML schema. Useful when models are better at emitting XML than JSON (e.g., Anthropic, older models). In LCEL, a "token" is a chunk yielded by a streaming runnable. The pipe operator ensures tokens flow through the chain as they are produced, so the final output starts streaming immediately instead of waiting for the whole LLM response. on_chain_start fires for any Runnable composition (your custom chain), while on_llm_start fires specifically for an LLM call with the prompts. Nested runnables emit nested start/end pairs you can correlate by run_id and parent_run_id. Use pip install for the core packages. The base langchain package is now split into langchain-core, langchain (the orchestration layer), and partner packages like langchain-openai, langchain-anthropic, langchain-community.

pip install langchain langchain-core langchain-openai langchain-community

Question 28 LangChain

What is ToolMessage used for?

Iteratively refines a running answer as it processes documents sequentially. Each document is fed with the current answer to produce a refined version. Higher quality than map-reduce for long-form synthesis but linear in N. Call vectorstore.save_local("path") and reload with FAISS.load_local("path", embeddings, allow_dangerous_deserialization=True). The flag exists because pickle loading is unsafe for untrusted files. ToolMessage carries the result of a tool execution back to the model in the next conversation turn. It must include the tool_call_id matching the AIMessage.tool_calls[i].id it answers. LangChain provides loaders for many file types. Each returns a list of Document objects.

from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    WebBaseLoader,
)

# Load a text file
docs = TextLoader("notes.txt").load()

# Load a PDF
docs = PyPDFLoader("paper.pdf").load()

# Load a web page
docs = WebBaseLoader("https://example.com").load()

Question 29 LangChain

What is CharacterTextSplitter?

Subclass BaseRetriever and implement _get_relevant_documents (and optionally _aget_relevant_documents for async). Set the class attribute model_config = ConfigDict(arbitrary_types_allowed=True) and the lc_namespace for serialization. MultiQueryRetriever generates multiple query variations using an LLM, retrieves documents for each, and merges the results for better recall.

from langchain.retrievers.multi_query import MultiQueryRetriever

retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(),
    llm=ChatOpenAI(model="gpt-4o-mini"),
)
docs = retriever.invoke("How does memory work in LangChain?")

You ask the LLM to generate a hypothetical answer to the query, embed that, and use the embedding for retrieval. Often gives better recall than embedding the bare question because it lands in the same region of embedding space as real answers. A simpler splitter that splits on a single separator string (default "\n\n"). Use it when you know the document structure is uniform (e.g., one paragraph per record).

from langchain_text_splitters import CharacterTextSplitter
splitter = CharacterTextSplitter(
    separator="\n", chunk_size=500, chunk_overlap=50
)

Question 30 LangChain

What is the RunnableLambda.from_runnable decorator?

Wrap a value with configurable_fields so it can be overridden per call from config["configurable"].

llm = ChatOpenAI(
    temperature=ConfigurableField(
        id="llm_temp", name="LLM temperature"
    )
)
llm.invoke("hi", config={"configurable": {"llm_temp": 0.9}})

.with_retry() retries the same runnable on transient errors (rate limits, timeouts). .with_fallbacks() runs an alternative runnable when the primary raises a non-retried exception. You can compose both. ConversationSummaryBufferMemory keeps recent messages in full and summarizes older ones once a token limit is reached. It balances fidelity (recent context) with token efficiency (summarized history). @RunnableLambda.from_runnable is used inside a RunnableGenerator / async generator-style custom runnable when you need to implement transform / astream directly while still benefiting from config propagation.

Question 31 LangChain

What is the StringEvaluator interface?

Wrap a value with configurable_fields so it can be overridden per call from config["configurable"].

llm = ChatOpenAI(
    temperature=ConfigurableField(
        id="llm_temp", name="LLM temperature"
    )
)
llm.invoke("hi", config={"configurable": {"llm_temp": 0.9}})

RecursiveCharacterTextSplitter tries the separators in order: ["\n\n", "\n", " ", ""]. For each chunk, it picks the first separator that yields pieces under chunk_size. This keeps semantically related text together (paragraphs > sentences > words). Subclasses implement _evaluate_strings (and optionally _aevaluate_strings) returning a dict with a "score" and optional "reasoning". Examples: exact match, regex match, embedding distance, LLM-judged criteria. Use app.stream(input, config) for a synchronous iterator of state deltas, or app.astream_events(input, version="v2") for token-level streaming. Each yielded dict has a node name as its key.

Question 32 LangChain

What is RecursiveCharacterTextSplitter and how do its separators work?

Weaviate is an open-source vector database. langchain-weaviate exposes WeaviateVectorStore with hybrid (BM25 + vector) search and GraphQL filters. Good for self-hosted multi-tenant setups. Callbacks let you hook into chain execution for logging, tracing, or custom side effects. Pass them via config or set them globally.

from langchain_core.callbacks import BaseCallbackHandler

class LogHandler(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with {len(prompts)} prompts")
    def on_llm_end(self, response, **kwargs):
        print(f"LLM finished")

chain.invoke(
    {"topic": "AI"},
    config={"callbacks": [LogHandler()]}
)

A simpler splitter that splits on a single separator string (default "\n\n"). Use it when you know the document structure is uniform (e.g., one paragraph per record).

from langchain_text_splitters import CharacterTextSplitter
splitter = CharacterTextSplitter(
    separator="\n", chunk_size=500, chunk_overlap=50
)

RecursiveCharacterTextSplitter tries the separators in order: ["\n\n", "\n", " ", ""]. For each chunk, it picks the first separator that yields pieces under chunk_size. This keeps semantically related text together (paragraphs > sentences > words).

Question 33 LangChain

What is MMR (Maximal Marginal Relevance) search?

RunnablePassthrough passes its input through unchanged. Commonly used in RAG chains to forward the original question alongside retrieved context.

from langchain_core.runnables import RunnablePassthrough

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
answer = chain.invoke("What is LangChain?")

Compares two model outputs against each other (and optionally a reference) and returns a verdict: {"reasoning": ..., "value": "A"} or "B" or "tie". Used for head-to-head model comparisons. RunnableLambda wraps any Python function as a LangChain Runnable so it can be composed in LCEL chains.

from langchain_core.runnables import RunnableLambda

def word_count(text: str) -> int:
    return len(text.split())

chain = llm | StrOutputParser() | RunnableLambda(word_count)
count = chain.invoke("Write a short poem")

MMR selects documents that are both relevant to the query and diverse relative to already-selected documents. It reduces redundancy in long-context retrieval.

retriever = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 5, "fetch_k": 20, "lambda_mult": 0.5},
)

Question 34 LangChain

What is ConversationSummaryBufferMemory?

LangChain Hub is a public registry of reusable prompts, agents, and chains that you can pull by name. The langchainhub package exposes hub.pull("owner/repo-name") which returns a ChatPromptTemplate or Runnable directly. RecursiveCharacterTextSplitter tries the separators in order: ["\n\n", "\n", " ", ""]. For each chunk, it picks the first separator that yields pieces under chunk_size. This keeps semantically related text together (paragraphs > sentences > words). ConversationSummaryBufferMemory keeps recent messages in full and summarizes older ones once a token limit is reached. It balances fidelity (recent context) with token efficiency (summarized history). Use .bind_tools() to attach tool definitions to a model so it can generate tool-calling messages.

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"Sunny in {city}"

llm = ChatOpenAI(model="gpt-4o")
llm_with_tools = llm.bind_tools([get_weather])

response = llm_with_tools.invoke("Weather in Paris?")
print(response.tool_calls)

Question 35 LangChain

What is ConversationBufferWindowMemory?

ConversationBufferWindowMemory keeps only the last k turns of conversation, preventing unbounded token growth. It is the standard middle-ground between raw buffer and summary memory.

from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(
    k=5, return_messages=True
)

RunnablePassthrough passes its input through unchanged. Commonly used in RAG chains to forward the original question alongside retrieved context.

from langchain_core.runnables import RunnablePassthrough

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
answer = chain.invoke("What is LangChain?")

Many parsers provide get_format_instructions() which returns a string you inject into the prompt to guide the LLM's output format.

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate

parser = JsonOutputParser()
prompt = PromptTemplate(
    template="List 3 facts about {topic}.\n{format_instructions}",
    input_variables=["topic"],
    partial_variables={
        "format_instructions": parser.get_format_instructions()
    },
)
chain = prompt | llm | parser
facts = chain.invoke({"topic": "Python"})

.with_structured_output() binds a Pydantic model or JSON schema to the LLM so it returns validated structured data directly.

from langchain_openai import ChatOpenAI
from pydantic import BaseModel

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str

llm = ChatOpenAI(model="gpt-4o")
structured_llm = llm.with_structured_output(MovieReview)

review = structured_llm.invoke("Review The Matrix")
print(review.title, review.rating)

Question 36 LangChain

What is the OpenAI Functions / Tools approach to structured output?

A general name for an agent that uses native tool/function calling — supports any chat model with tool-calling support (OpenAI, Anthropic, Gemini, Mistral, etc.). In LangGraph, create_react_agent is the canonical tool-calling agent factory. Like OutputFixingParser, but it re-prompts the LLM with both the original output and the parser's error message, giving the model explicit feedback on what went wrong. Better for structurally complex schemas. Subclass BaseRetriever and implement _get_relevant_documents (and optionally _aget_relevant_documents for async). Set the class attribute model_config = ConfigDict(arbitrary_types_allowed=True) and the lc_namespace for serialization. For OpenAI models, structured output is achieved natively by passing a JSON schema (or Pydantic model) to the tools / response_format parameter. with_structured_output is the unified LangChain wrapper for this.

Question 37 LangChain

How do you split documents with a TextSplitter?

RecursiveCharacterTextSplitter tries the separators in order: ["\n\n", "\n", " ", ""]. For each chunk, it picks the first separator that yields pieces under chunk_size. This keeps semantically related text together (paragraphs > sentences > words). In current LangChain, the recommended pattern is to manage messages yourself (or via ChatMessageHistory) and inject them with MessagesPlaceholder or RunnableWithMessageHistory. The old Memory classes in langchain.memory are legacy and slated for deprecation. Text splitters break large documents into smaller chunks for embedding. RecursiveCharacterTextSplitter is the most commonly used.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " "],
)
chunks = splitter.split_documents(docs)
print(f"{len(chunks)} chunks created")

StateGraph is the core LangGraph primitive: a directed graph where nodes are functions/Runnables that read and update a shared typed state, and edges define the flow including conditional branching.

from langgraph.graph import StateGraph, START, END
builder = StateGraph(State)
builder.add_node("agent", agent_node)
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", should_continue)
builder.add_edge("agent", END)
app = builder.compile()

Question 38 LangChain

How do you create embeddings in LangChain?

Parses a comma-separated string into a Python List[str], trimming whitespace. Useful for "list 5 items" prompts.

from langchain_core.output_parsers import CommaSeparatedListOutputParser
parser = CommaSeparatedListOutputParser()

Embeddings convert text into numerical vectors for similarity search. Instantiate an embeddings model and call .embed_documents() or .embed_query().

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Embed multiple documents
vectors = embeddings.embed_documents(["Hello", "World"])

# Embed a single query
query_vec = embeddings.embed_query("What is AI?")
print(len(query_vec))  # e.g., 1536

Weaviate is an open-source vector database. langchain-weaviate exposes WeaviateVectorStore with hybrid (BM25 + vector) search and GraphQL filters. Good for self-hosted multi-tenant setups. Wrap a value with configurable_fields so it can be overridden per call from config["configurable"].

llm = ChatOpenAI(
    temperature=ConfigurableField(
        id="llm_temp", name="LLM temperature"
    )
)
llm.invoke("hi", config={"configurable": {"llm_temp": 0.9}})

Question 39 LangChain

What is max_iterations in AgentExecutor?

A safety cap on the number of tool-call → observation cycles the agent can perform before the executor gives up and returns. Prevents runaway costs when the model loops.

executor = AgentExecutor(
    agent=agent, tools=tools, max_iterations=5
)

LCEL is a declarative syntax for composing LangChain components using the pipe operator (|). It creates RunnableSequence chains that support streaming, batching, and async out of the box.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

chain = (
    ChatPromptTemplate.from_template("Explain {topic} simply.")
    | ChatOpenAI(model="gpt-4o")
    | StrOutputParser()
)
result = chain.invoke({"topic": "recursion"})

A PythonREPL tool executes arbitrary Python code in a subprocess. The agent emits code in a ```python``` block, the tool runs it, and returns stdout/stderr. Combine with create_python_agent for general compute tasks. Call runnable.get_input_schema() and get_output_schema() (Pydantic models). get_graph() returns a drawable graph; get_prompts() lists prompts nested in the chain — useful for LangSmith inspection.

Question 40 LangChain

What is ConversationBufferMemory?

StrOutputParser extracts the plain text string from an AIMessage. It's the most common output parser used at the end of LCEL chains.

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

chain = ChatOpenAI() | StrOutputParser()
text = chain.invoke("Say hello")  # returns a plain string

Define your runnable, then in a FastAPI app use add_routes(app, runnable, path="/mychain"). Provide a RunnableConfig factory with configurable keys (model, prompts) for runtime overrides.

from langserve import add_routes
add_routes(app, chain, path="/rag")

ConversationBufferMemory stores the full conversation history as a list of messages. Simple but uses more tokens as the conversation grows.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(return_messages=True)
memory.save_context(
    {"input": "Hi, I'm Alice"},
    {"output": "Hello Alice! How can I help?"}
)
print(memory.load_memory_variables({}))

A PromptTemplate formats a single string prompt with variable substitution. Use it for completion-style models.

from langchain_core.prompts import PromptTemplate

template = PromptTemplate.from_template(
    "Summarize this text in {n} words:\n\n{text}"
)
prompt = template.invoke({"n": 50, "text": "LangChain is..."})

Question 41 LangChain

How do you use output_parsers with format_instructions?

Many parsers provide get_format_instructions() which returns a string you inject into the prompt to guide the LLM's output format.

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate

parser = JsonOutputParser()
prompt = PromptTemplate(
    template="List 3 facts about {topic}.\n{format_instructions}",
    input_variables=["topic"],
    partial_variables={
        "format_instructions": parser.get_format_instructions()
    },
)
chain = prompt | llm | parser
facts = chain.invoke({"topic": "Python"})

LangChain integrates with LangSmith (and provides langchain.evaluation modules) for evaluating chains on datasets. Evaluators include StringEvaluator subclasses like QAEvaluator, CriteriaEvalChain, LabeledCriteriaEvalChain, and embedding-distance metrics. An evaluator that asks an LLM to grade a prediction against a custom criterion (e.g., "Is the answer helpful? Concise? Factually correct?"). Useful for subjective quality metrics without writing a grader prompt from scratch. MMR selects documents that are both relevant to the query and diverse relative to already-selected documents. It reduces redundancy in long-context retrieval.

retriever = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 5, "fetch_k": 20, "lambda_mult": 0.5},
)

Question 42 LangChain

What are the message types in langchain-core?

SystemMessage, HumanMessage, AIMessage, ToolMessage, FunctionMessage, and the abstract BaseMessage. Each has a content field and an optional additional_kwargs / response_metadata dict. ConversationSummaryBufferMemory keeps recent messages in full and summarizes older ones once a token limit is reached. It balances fidelity (recent context) with token efficiency (summarized history). When set on a tool instance, the agent catches the exception and passes the configured message back to the model. Equivalent to raising ToolException but configurable per-tool.

@tool(handle_tool_error=True)
def flaky(): ...

RunnableParallel runs multiple runnables concurrently and returns a dict of results. Useful for branching logic.

from langchain_core.runnables import RunnableParallel

chain = RunnableParallel(
    summary=summary_chain,
    translation=translate_chain,
    keywords=keyword_chain,
)
results = chain.invoke({"text": "LangChain is..."})
# results = {"summary": ..., "translation": ..., "keywords": ...}

Question 43 LangChain

What is the LangChain caching system?

Combine a retriever, prompt, and LLM using LCEL. RunnablePassthrough forwards the question alongside retrieved context.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    "Answer based on context:\n{context}\n\nQuestion: {question}"
)

def format_docs(docs):
    return "\n\n".join(d.page_content for d in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)
answer = rag_chain.invoke("What is LangChain?")

BaseTool is the abstract class underlying every tool — _run, _arun, args_schema, name, description. The @tool decorator is a shortcut for the common case of wrapping a function; subclassing gives you full control (validation, async-only, dynamic schema). LangChain provides loaders for many file types. Each returns a list of Document objects.

from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    WebBaseLoader,
)

# Load a text file
docs = TextLoader("notes.txt").load()

# Load a PDF
docs = PyPDFLoader("paper.pdf").load()

# Load a web page
docs = WebBaseLoader("https://example.com").load()

LangChain supports caching LLM responses to avoid repeat calls. Set set_llm_cache(InMemoryCache()) or SQLiteCache, RedisCache, RedisSemanticCache, or GPTCache. Caching is keyed by the serialized prompt + model params.

Question 44 LangChain

What is create_refine_documents_chain?

Use pip install for the core packages. The base langchain package is now split into langchain-core, langchain (the orchestration layer), and partner packages like langchain-openai, langchain-anthropic, langchain-community.

pip install langchain langchain-core langchain-openai langchain-community

Use app.stream(input, config) for a synchronous iterator of state deltas, or app.astream_events(input, version="v2") for token-level streaming. Each yielded dict has a node name as its key. Iteratively refines a running answer as it processes documents sequentially. Each document is fed with the current answer to produce a refined version. Higher quality than map-reduce for long-form synthesis but linear in N. ConversationEntityMemory extracts named entities mentioned in the conversation and stores facts about each, then injects relevant entity info into future prompts. Useful for assistants that need to remember user-specific details.

Question 45 LangChain

How do you use with_structured_output?

A Checkpoint is a snapshot of the graph's state at a point in time. The MemorySaver (in-memory) and SqliteSaver / PostgresSaver (persistent) checkpointers let you pause, resume, rewind, and branch conversations. .with_structured_output() binds a Pydantic model or JSON schema to the LLM so it returns validated structured data directly.

from langchain_openai import ChatOpenAI
from pydantic import BaseModel

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str

llm = ChatOpenAI(model="gpt-4o")
structured_llm = llm.with_structured_output(MovieReview)

review = structured_llm.invoke("Review The Matrix")
print(review.title, review.rating)

ConversationSummaryBufferMemory keeps recent messages in full and summarizes older ones once a token limit is reached. It balances fidelity (recent context) with token efficiency (summarized history). All embedding models implement embed_documents(texts: List[str]) -> List[List[float]] and embed_query(text: str) -> List[float]. The asymmetric design lets providers cache document embeddings while recomputing queries.

Question 46 LangChain

How do you stream events from a chain?

LangChain supports caching LLM responses to avoid repeat calls. Set set_llm_cache(InMemoryCache()) or SQLiteCache, RedisCache, RedisSemanticCache, or GPTCache. Caching is keyed by the serialized prompt + model params. Use chain.astream_events(input, version="v2") to receive typed events (on_chat_model_start, on_tool_start, on_chain_end, etc.) as the chain executes. This is the most granular streaming API. Like OutputFixingParser, but it re-prompts the LLM with both the original output and the parser's error message, giving the model explicit feedback on what went wrong. Better for structurally complex schemas. LangChain Hub is a public registry of reusable prompts, agents, and chains that you can pull by name. The langchainhub package exposes hub.pull("owner/repo-name") which returns a ChatPromptTemplate or Runnable directly.

Question 47 LangChain

What is LangChain Templates?

You can interrupt the graph before a node runs (interrupt_before=["tool"]) or after (interrupt_after), inspect the state, edit it, and resume. This is the standard pattern for approving sensitive tool calls before execution. A deprecated gallery of pre-built project templates (now archived). The current recommendation is the langgraph new CLI (for LangGraph projects) or the create-langchain-integration scaffold (for partner packages). For an LLM run the lifecycle is: on_llm_start → on_chat_model_start → on_llm_new_token (per chunk) → on_llm_end (or on_llm_error). For a chain: on_chain_start → child events → on_chain_end. For tools: on_tool_start → on_tool_end. SystemMessage, HumanMessage, AIMessage, ToolMessage, FunctionMessage, and the abstract BaseMessage. Each has a content field and an optional additional_kwargs / response_metadata dict.

Question 48 LangChain

What is the difference between ChatModel and LLM?

Computes cosine, euclidean, or Manhattan distance between the embeddings of the prediction and the reference. Returns a float score. Cheaper than LLM-based evaluators but less semantically robust. A LangChain/LangGraph agent that uses an LLM to write and execute SQL queries against a SQLDatabase. It inspects the schema, generates a query, executes it, and (with self-correction) retries on errors. Set top_k on SQLDatabase to cap rows returned. RecursiveCharacterTextSplitter tries the separators in order: ["\n\n", "\n", " ", ""]. For each chunk, it picks the first separator that yields pieces under chunk_size. This keeps semantically related text together (paragraphs > sentences > words). A ChatModel takes a list of BaseMessage objects and returns an AIMessage, supporting multi-turn conversations and tool calls. The legacy LLM class takes a string and returns a string; it is largely deprecated in favor of chat models.

Question 49 LangChain

What is RetrievalQA?

Legacy chain (RetrievalQA.from_chain_type) that wraps a retriever + LLM. In modern LangChain, you would build the same flow with LCEL using {"context": retriever, "question": RunnablePassthrough()} | prompt | llm | parser — equivalent but more flexible. Chroma is an open-source embedding database that supports persistent local storage.

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

# Create and persist
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=OpenAIEmbeddings(),
    persist_directory="./chroma_db",
)

# Load existing
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=OpenAIEmbeddings(),
)
results = vectorstore.similarity_search("LangChain", k=3)

Look up the tool by name, call it with the arguments from tool_calls, and append a ToolMessage with the matching tool_call_id.

tools_by_name = {t.name: t for t in tools}
for tc in response.tool_calls:
    result = tools_by_name[tc["name"]].invoke(tc["args"])
    messages.append(ToolMessage(
        content=result, tool_call_id=tc["id"]
    ))

A reranker model (e.g., CohereRerank, FlashrankRerank, CrossEncoderRerank) that scores each (query, document) pair jointly. It is more accurate than bi-encoder similarity but slower — typically applied to the top-K candidates from a fast retriever.

Question 50 LangChain

What does .assign() do in an LCEL chain?

Text splitters break large documents into smaller chunks for embedding. RecursiveCharacterTextSplitter is the most commonly used.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " "],
)
chunks = splitter.split_documents(docs)
print(f"{len(chunks)} chunks created")

A deprecated gallery of pre-built project templates (now archived). The current recommendation is the langgraph new CLI (for LangGraph projects) or the create-langchain-integration scaffold (for partner packages). Add a RunnableLambda or prompt chain before the retriever that takes {question, chat_history} and emits a standalone search query. The output of this step becomes the retriever's input.

chain = (
    rewrite_prompt | llm | StrOutputParser() | retriever | ...
)

.assign() on a RunnableParallel adds a new key to the output dict while preserving the original input. It enables map-step-style data flow inside a chain.

chain = (
    RunnablePassthrough.assign(
        context=lambda x: retriever.invoke(x["question"])
    )
    | prompt | llm | parser
)