LangChain Cheat Sheet

1Install & importspip / keys

pip install langchain langchain-openai★
langchain (v1 agent API) pulls in langchain-core. Add one provider package per backend: langchain-anthropic, langchain-google-genai, etc.
export OPENAI_API_KEY="sk-..." # or ANTHROPIC_API_KEY, ...
Provider packages read their own *_API_KEY env var. Python 3.10–3.14 supported.
from langchain.agents import create_agent from langchain.tools import tool from langchain.messages import HumanMessage, AIMessage★
The v1 surface is small & flat: langchain.agents, langchain.tools, langchain.messages, langchain.chat_models.
pip install "langchain[anthropic]"
Extras install a matching provider package in one shot — handy for the model string "anthropic:...".

2create_agent — the corethe whole loop

agent = create_agent( model="openai:gpt-4o", tools=[get_weather], system_prompt="You are a helpful assistant.")★
The standard way to build an agent in v1: a model + tools + instructions. Replaces the old AgentExecutor and langgraph.prebuilt.create_react_agent.
result = agent.invoke( {"messages": [{"role":"user", "content":"Weather in NYC?"}]})★
State is a dict with a messages list. The agent runs the model→tool loop until the model stops calling tools.
result["messages"][-1].content
Final answer is the last message. The full trajectory (tool calls + results) is in result["messages"].
create_agent(model, tools, system_prompt, middleware=[...], response_format=..., checkpointer=...)
Key params: middleware (customize the loop), response_format (structured output), checkpointer (memory), context_schema (typed runtime context).

3init_chat_model & providersswap by string

from langchain.chat_models import init_chat_model model = init_chat_model("anthropic:claude-sonnet-4-5")★
One factory for every provider. The "provider:model" string is also what create_agent(model=...) accepts directly.
init_chat_model("gpt-4o", model_provider="openai", temperature=0)
Split provider out explicitly, and pass model kwargs (temperature, max_tokens, timeout, max_retries).
resp = model.invoke("Hello") # -> AIMessage resp = model.invoke([HumanMessage("Hi")])★
A model is a Runnable: .invoke / .batch / .stream and async .ainvoke / .abatch / .astream.
model.bind_tools([get_weather]) · init_chat_model(..., configurable_fields="any")
bind_tools attaches tools to a bare model; configurable models let you switch model at call time via config.

4Messages & content_blocksunified I/O

from langchain.messages import ( SystemMessage, HumanMessage, AIMessage, ToolMessage)★
Dict form {"role":"user","content":"..."} works too and is auto-coerced. role values: system, user, assistant, tool.
for block in resp.content_blocks: if block["type"] == "text": print(block["text"])★v1
Standard, provider-agnostic view of output: text, reasoning, tool_call, image, citation blocks — no more per-provider parsing.
HumanMessage(content=[ {"type":"text","text":"describe"}, {"type":"image","url":"https://..."}])
Multimodal input as a list of content parts for vision-capable models.
resp.tool_calls # [{'name','args','id'}] resp.usage_metadata # input/output tokens
Convenience accessors on AIMessage. ToolMessage(content=..., tool_call_id=...) carries a tool result back.

5Tools with @toolgive it hands

from langchain.tools import tool @tool def get_weather(city: str) -> str: """Get the weather for a city.""" return f"Sunny in {city}"★
The docstring becomes the tool description; type hints become the args schema. Name defaults to the function name.
@tool("search", description="Web search") def s(q: str) -> str: ...
Override name/description, or pass args_schema= a Pydantic model for richer validation of arguments.
from langchain.tools import InjectedState, ToolRuntime
Inject agent state or runtime into a tool signature (not shown to the model) — e.g. read the message history or user context inside the tool.
return Command(update={"messages":[...]})
A tool may return a Command to update agent state or hand off control — the basis for multi-agent handoffs.
# tools without a docstring / hints = poor tool-callingtip
The model only sees name + description + schema. Vague descriptions are the #1 cause of an agent picking the wrong tool.

6Structured outputtyped answers

from pydantic import BaseModel class Weather(BaseModel): temperature: float condition: str★
Define the shape you want with Pydantic (or a TypedDict / JSON schema).
agent = create_agent(model, tools, response_format=Weather) r = agent.invoke({...}) r["structured_response"] # -> Weather★v1
The agent returns a validated object under structured_response alongside the messages.
from langchain.agents.structured_output import ToolStrategy, ProviderStrategy response_format=ToolStrategy(Weather)
ToolStrategy emits structured output via an artificial tool call (works anywhere); ProviderStrategy uses native provider structured-output where available.
model.with_structured_output(Weather).invoke("...")
On a bare model (no agent), with_structured_output returns the parsed object directly.

7Middleware & hookscontrol the loop

from langchain.agents.middleware import AgentMiddlewarev1
Subclass and override the hooks you need; pass instances via create_agent(..., middleware=[...]). They run in order around each step.
class M(AgentMiddleware): def before_model(self, state, runtime): ... def after_model(self, state, runtime): ...★
Lifecycle hooks: before_agent, before_model, after_model, after_agent. Return a state update dict to modify messages/state.
def wrap_model_call(self, request, handler): return handler(request) # intercept the LLM call
wrap_model_call / wrap_tool_call wrap the actual call — retry, rewrite the request, cache, or post-process the response.
from langchain.agents.middleware import dynamic_prompt @dynamic_prompt def p(request): return f"System... {request.state}"
Decorator shortcuts (e.g. @dynamic_prompt, @before_model) build a one-hook middleware from a plain function.

8Prebuilt middlewarebatteries included

from langchain.agents.middleware import SummarizationMiddleware SummarizationMiddleware(model, max_tokens_before_summary=4000)★
Auto-condenses old messages when history grows, keeping the agent under the context window.
from langchain.agents.middleware import HumanInTheLoopMiddleware★
Pauses for human approval before sensitive tool calls — the agent interrupts, you resume with an accept/edit/reject decision.
from langchain.agents.middleware import PIIMiddleware
Detects & redacts PII (emails, cards, etc.) flowing through the agent.
from langchain.agents.middleware import ModelFallbackMiddleware
Also available: model fallback, tool-call limits, tool-retry, context-editing. Compose several in the middleware=[...] list.

9Runtime & contexttyped injection

from dataclasses import dataclass @dataclass class Ctx: user_id: str
Define a context schema, then create_agent(..., context_schema=Ctx). Static, per-run data (not part of the message state).
agent.invoke({"messages":[...]}, context=Ctx(user_id="u1"))★
Pass runtime context per call. Reach it in tools/middleware via runtime.context.
from langgraph.runtime import Runtime def tool(x, runtime: Runtime[Ctx]): runtime.context.user_id
The Runtime object exposes context, store, and stream writers — the bridge to the LangGraph engine underneath.

10Invoke & streamsync / async

for chunk in agent.stream( {"messages":[...]}, stream_mode="values"): print(chunk["messages"][-1])★
"values" = full state after each step; "updates" = only the delta per node; "messages" = token-by-token LLM output; "custom" = your own writes.
agent.stream(..., stream_mode=["updates", "messages"])
Pass a list to multiplex modes; each yield is (mode, chunk).
r = await agent.ainvoke({...}) async for c in agent.astream({...}): ...★
Every agent/Runnable has full async twins: ainvoke, astream, abatch, astream_events.
async for ev in agent.astream_events({...}, version="v2"): ...
Fine-grained event stream (model start/stream/end, tool start/end) for building rich UIs.

11Memory & checkpointerthreads

from langgraph.checkpoint.memory import InMemorySaver agent = create_agent(model, tools, checkpointer=InMemorySaver())★
A checkpointer persists state between turns. InMemorySaver for dev; langgraph-checkpoint-postgres / -sqlite for production.
cfg = {"configurable": {"thread_id": "user-42"}} agent.invoke({"messages":[...]}, config=cfg)★
The thread_id is the conversation key — reuse it and history is loaded automatically; no need to resend past messages.
agent.get_state(cfg).values["messages"]
Inspect or rewind a thread. Time-travel & resume-after-interrupt come from the same checkpointing.
from langgraph.store.memory import InMemoryStore create_agent(..., store=InMemoryStore())
Long-term memory across threads: a store holds durable key–value facts (vs. the per-thread checkpointer).

12LCEL, Runnables & promptscompose

from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages([ ("system","You are {role}"), ("user","{q}")])
Prompt templates still live in langchain_core.prompts. {var} placeholders fill from the invoke input.
chain = prompt | model | StrOutputParser() chain.invoke({"role":"tutor", "q":"Explain X"})★
LCEL: the | pipe composes Runnables. Great for deterministic prompt→model→parse chains where you don't need an agent loop.
from langchain_core.runnables import RunnableParallel, RunnableLambda
RunnableParallel fans out, RunnableLambda wraps a function, RunnablePassthrough threads input through — all with .invoke/.batch/.stream.
chain.with_config(...) · .with_retry() · .with_fallbacks([...])
Cross-cutting behavior attaches to any Runnable — retries, fallbacks, config, and tags/metadata for tracing.

13Retrieval / RAGground it

from langchain_openai import OpenAIEmbeddings from langchain_core.vectorstores import InMemoryVectorStore vs = InMemoryVectorStore(OpenAIEmbeddings())★
Or init_embeddings("openai:text-embedding-3-small"). Real backends: langchain-chroma, -pinecone, -pgvector, etc.
vs.add_texts(["..."]) · retriever = vs.as_retriever(k=4)
A retriever is a Runnable: retriever.invoke("query") returns the top-k Documents.
@tool def search_docs(q: str) -> str: return "\n".join(d.page_content for d in retriever.invoke(q))★
Agentic RAG: wrap the retriever as a tool and let create_agent decide when to search — the idiomatic v1 pattern.
from langchain_text_splitters import RecursiveCharacterTextSplitter
Chunk documents before embedding. Loaders/splitters live in langchain-text-splitters and the community loader packages.

14LangGraph & LangSmiththe stack

# LangChain (high-level) --runs on--> LangGraph (runtime)★
LangGraph is the low-level durable execution engine; LangChain's create_agent is a high-level API on top. Drop to LangGraph for custom multi-node graphs.
from langgraph.graph import StateGraph, START, END
Build arbitrary agent graphs by hand when the single-agent loop isn't enough (branching, multi-agent, cycles).
export LANGSMITH_TRACING=true export LANGSMITH_API_KEY="..."★
LangSmith traces every run automatically once these are set — no code change. Debug, eval, and monitor agents.
langgraph dev # LangGraph Platform / Studio
Deploy agents as APIs and inspect them visually in Studio via the LangGraph CLI.

15v1 migration & classic0.x → 1.x

# AgentExecutor / create_react_agent -> create_agentchanged
The old AgentExecutor and initialize_agent are gone from the core namespace. Rebuild agents with create_agent.
pip install langchain-classic from langchain_classic.chains import LLMChainlegacy
Legacy chains (LLMChain, ConversationChain, RetrievalQA), the hub, and older retrievers moved to langchain-classic. Import from there to keep old code running.
# langchain.chat_models / .messages / .tools are the new home
The langchain namespace was slimmed to the agent essentials. Prefer these flat imports over deep langchain_core paths where a re-export exists.
# content_blocks replaces per-provider content parsingv1
If you parsed provider-specific response shapes in 0.x, switch to msg.content_blocks for a stable schema across models.
# pin your deps: langchain>=1,<2tip
1.x follows semver; provider packages version independently. Pin majors and read each integration's changelog before upgrading.

LangChain cheat sheet

Outline

Getting started

Models & messages

Tools & output

Middleware & runtime

Streaming / memory / compose

Ecosystem

Getting Started

Models & Messages

Tools & Structured Output

Middleware & Runtime

Streaming, Memory & Composition

Ecosystem & Migration

Worth memorizing