LangChain Cheat Sheet

Updated 2026-07-18

🎯Take a practice test on this topic7 practice tests · 207 questions→

🧠Study flashcards on this topic145 cards · spaced repetition→

LangChain is a comprehensive framework for building applications powered by large language models (LLMs), transforming simple prompts into production-ready AI agents. With the v1.0 release in October 2025, it has been streamlined around three pillars: create_agent (the new standard agent builder), middleware (composable hooks for customization), and standard content blocks (provider-agnostic message content). LangChain abstracts the complexity of chaining LLM calls, managing memory, integrating tools, and orchestrating retrieval-augmented generation (RAG) pipelines, while LangGraph (stateful graph workflows) and LangSmith (observability) complete the ecosystem. A critical mental model: every component implements the Runnable interface (invoke, stream, batch), and legacy functionality now lives in the separate langchain-classic package.

What This Cheat Sheet Covers

This topic spans 22 focused tables and 169 indexed concepts, 145 flashcards, 7 practice tests with 207 questions. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Core ComponentsTable 2: LCEL (LangChain Expression Language)Table 3: Memory TypesTable 4: Agent TypesTable 5: Agent Middleware (v1.0)Table 6: Tools and Tool CallingTable 7: Retrieval (RAG Components)Table 8: Advanced RAG PatternsTable 9: Chains (Composing Operations)Table 10: LangGraph (Stateful Workflows)Table 11: Callbacks and ObservabilityTable 12: Streaming and AsyncTable 13: Error Handling and RetriesTable 14: CachingTable 15: Prompt EngineeringTable 16: Document TransformersTable 17: IntegrationsTable 18: Structured OutputTable 19: Advanced Agent PatternsTable 20: Testing and EvaluationTable 21: Production Best PracticesTable 22: Debugging and Troubleshooting

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Core Components

These are the building blocks you assemble into any LangChain app — chat models, prompts, output parsers, embeddings, vector stores, and the loaders and splitters that prep your data. The unifying idea is that nearly every one of them implements the same Runnable interface, so once you know how one works, you know how to invoke, stream, and batch them all.

Component	Example	Description
Chat Models	`ChatOpenAI(model="gpt-4o")` `ChatAnthropic(model="claude-3-5-sonnet")`	• Unified wrappers for conversational LLMs from OpenAI, Anthropic, Google, and more • returns structured `AIMessage` objects with metadata
init_chat_model	`from langchain.chat_models import init_chat_model` `llm = init_chat_model("openai:gpt-4o")` `llm = init_chat_model("anthropic:claude-3-5-sonnet")`	• Unified model initialization via `provider:model` string — no provider-specific import needed • supports fully configurable runtime model selection via `config["configurable"]` • recommended v1.0 pattern for provider-agnostic code
Embeddings	`OpenAIEmbeddings()` `HuggingFaceEmbeddings()`	• Convert text to vectors for semantic search • used with vector stores; supports batch processing for efficiency
Prompts	`PromptTemplate(template="Answer: {question}")` `ChatPromptTemplate.from_messages([...])`	• Templating system for dynamic prompt construction • supports f-string syntax, Jinja2, and chat message formatting
Output Parsers	`JsonOutputParser()` `PydanticOutputParser(pydantic_object=MyModel)`	• Extract structured data from LLM text responses • handles JSON, Pydantic models, lists, and custom formats with validation
Runnable Interface	`chain.invoke(input)` `chain.stream(input)` `chain.batch([inputs])`	• Unified execution protocol for all LangChain components • enables invoke (single), stream (tokens), batch (multiple), and async variants
content_blocks	`message.content_blocks` `# → [ThinkingBlock(...), TextBlock(...), ToolUseBlock(...)]`	• Provider-agnostic message content added in LangChain v1.0 • unified access to reasoning traces, citations, tool calls across providers • existing `message.content` unchanged for backward compatibility
Document Loaders	`PyPDFLoader("file.pdf")` `CSVLoader("data.csv")` `WebBaseLoader("https://...")`	• Ingest data from PDFs, CSVs, HTML, Markdown, APIs, databases • returns `Document` objects with `page_content` and `metadata`
Text Splitters	`RecursiveCharacterTextSplitter(chunk_size=1000)` `HTMLHeaderTextSplitter()`	• Chunk documents into smaller pieces for embedding/retrieval • preserves semantic structure; critical for RAG quality
Vector Stores	`Chroma.from_documents(docs, embeddings)` `Pinecone.from_existing_index()`	• Store and search embeddings using similarity metrics • integrates with 60+ vector databases; supports metadata filtering
Retrievers	`vectorstore.as_retriever(search_type="mmr")` `MultiQueryRetriever.from_llm()`	• Fetch relevant documents from vector stores • supports similarity search, MMR, hybrid search, and contextual compression
LLMs (Text Completion)	`OpenAI(model="gpt-3.5-turbo-instruct")`	• Legacy text-completion models (non-chat); takes string, returns string • mostly superseded by chat models; in `langchain-classic` in v1.0

Table 2: LCEL (LangChain Expression Language)

LCEL is the glue that wires components together, and the pipe operator is its signature move — prompt | llm | parser reads almost like a sentence. The rest of the rows are the primitives you slot into those pipelines: run things in parallel, pass inputs straight through, wrap arbitrary Python, or branch on a condition. Get comfortable here and complex chains stop feeling like plumbing.

Pattern	Example	Description
Pipe Operator	`chain = prompt \| llm \| parser`	• Compose runnables using the `\|` operator • output of left becomes input of right; creates `RunnableSequence` under the hood

The rest of this section is part of the full cheat sheet

Table 3: Memory Types

How an app remembers earlier turns of a conversation, and the trade-off in every choice is context richness versus token cost. Buffer memory keeps everything but grows unbounded; windowed and token-limited variants cap it; summary memory compresses old turns with an LLM; and vector or entity memory retrieve only what's relevant. Note that most of these now live in langchain-classic (v1.0), with RunnableWithMessageHistory or LangGraph the recommended path for new apps.

Type	Example	Description
ConversationBufferMemory	`ConversationBufferMemory()`	• Stores entire conversation verbatim • simplest memory type; grows unbounded, unsuitable for long conversations • now in `langchain-classic` (v1.0); use `RunnableWithMessageHistory` for new apps

The rest of this section is part of the full cheat sheet

Table 4: Agent Types

The history of how LangChain builds agents, condensed into one place. In v1.0 the answer is simply create_agent, built on LangGraph and supporting middleware and structured output, but you'll still meet the older constructors (ReAct, OpenAI functions, structured chat, plan-and-execute, AgentExecutor) in existing codebases. Each row tells you what a type was for and whether it's now superseded, so you know what to reach for and what to migrate away from.

Type	Example	Description
create_agent	`from langchain.agents import create_agent` `agent = create_agent("openai:gpt-4o", tools=[search_tool], system_prompt="Help the user.")` `result = agent.invoke({"role": "user", "content": "..."})`	• LangChain v1.0 standard for building agents, built on LangGraph • replaces deprecated `langgraph.prebuilt.create_react_agent` • supports middleware, structured output via `ToolStrategy`/`ProviderStrategy`, and runtime context injection

The rest of this section is part of the full cheat sheet

Table 1: Core Components

Component	Example	Description
Chat Models	`ChatOpenAI(model="gpt-4o")` `ChatAnthropic(model="claude-3-5-sonnet")`	• Unified wrappers for conversational LLMs from OpenAI, Anthropic, Google, and more • returns structured `AIMessage` objects with metadata
init_chat_model	`from langchain.chat_models import init_chat_model` `llm = init_chat_model("openai:gpt-4o")` `llm = init_chat_model("anthropic:claude-3-5-sonnet")`	• Unified model initialization via `provider:model` string — no provider-specific import needed • supports fully configurable runtime model selection via `config["configurable"]` • recommended v1.0 pattern for provider-agnostic code
Embeddings	`OpenAIEmbeddings()` `HuggingFaceEmbeddings()`	• Convert text to vectors for semantic search • used with vector stores; supports batch processing for efficiency
Prompts	`PromptTemplate(template="Answer: {question}")` `ChatPromptTemplate.from_messages([...])`	• Templating system for dynamic prompt construction • supports f-string syntax, Jinja2, and chat message formatting
Output Parsers	`JsonOutputParser()` `PydanticOutputParser(pydantic_object=MyModel)`	• Extract structured data from LLM text responses • handles JSON, Pydantic models, lists, and custom formats with validation
Runnable Interface	`chain.invoke(input)` `chain.stream(input)` `chain.batch([inputs])`	• Unified execution protocol for all LangChain components • enables invoke (single), stream (tokens), batch (multiple), and async variants
content_blocks	`message.content_blocks` `# → [ThinkingBlock(...), TextBlock(...), ToolUseBlock(...)]`	• Provider-agnostic message content added in LangChain v1.0 • unified access to reasoning traces, citations, tool calls across providers • existing `message.content` unchanged for backward compatibility
Document Loaders	`PyPDFLoader("file.pdf")` `CSVLoader("data.csv")` `WebBaseLoader("https://...")`	• Ingest data from PDFs, CSVs, HTML, Markdown, APIs, databases • returns `Document` objects with `page_content` and `metadata`
Text Splitters	`RecursiveCharacterTextSplitter(chunk_size=1000)` `HTMLHeaderTextSplitter()`	• Chunk documents into smaller pieces for embedding/retrieval • preserves semantic structure; critical for RAG quality
Vector Stores	`Chroma.from_documents(docs, embeddings)` `Pinecone.from_existing_index()`	• Store and search embeddings using similarity metrics • integrates with 60+ vector databases; supports metadata filtering
Retrievers	`vectorstore.as_retriever(search_type="mmr")` `MultiQueryRetriever.from_llm()`	• Fetch relevant documents from vector stores • supports similarity search, MMR, hybrid search, and contextual compression
LLMs (Text Completion)	`OpenAI(model="gpt-3.5-turbo-instruct")`	• Legacy text-completion models (non-chat); takes string, returns string • mostly superseded by chat models; in `langchain-classic` in v1.0

Table 2: LCEL (LangChain Expression Language)

Pattern	Example	Description
Pipe Operator	`chain = prompt \| llm \| parser`	• Compose runnables using the `\|` operator • output of left becomes input of right; creates `RunnableSequence` under the hood

Table 3: Memory Types

Type	Example	Description
ConversationBufferMemory	`ConversationBufferMemory()`	• Stores entire conversation verbatim • simplest memory type; grows unbounded, unsuitable for long conversations • now in `langchain-classic` (v1.0); use `RunnableWithMessageHistory` for new apps

Table 4: Agent Types

Type	Example	Description
create_agent	`from langchain.agents import create_agent` `agent = create_agent("openai:gpt-4o", tools=[search_tool], system_prompt="Help the user.")` `result = agent.invoke({"role": "user", "content": "..."})`	• LangChain v1.0 standard for building agents, built on LangGraph • replaces deprecated `langgraph.prebuilt.create_react_agent` • supports middleware, structured output via `ToolStrategy`/`ProviderStrategy`, and runtime context injection