LangChain Skill

Build production AI agents using LangChain's pre-built architecture and integrations.

Installation

pip install langchain langchain-anthropic langgraph
# For MCP support
pip install langchain-mcp-adapters

Quick Agent

from langchain.agents import create_agent
from langchain.tools import tool

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

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[get_weather],
    system_prompt="You are a helpful assistant"
)

result = agent.invoke({"messages": [{"role": "user", "content": "Weather in SF?"}]})

Tools

Define tools with @tool decorator. Type hints required, docstring becomes description:

from langchain.tools import tool, ToolRuntime
from dataclasses import dataclass

@tool
def search(query: str, limit: int = 10) -> str:
    """Search database for records."""
    return f"Found {limit} results for '{query}'"

# With runtime context access
@dataclass
class Context:
    user_id: str

@tool
def get_user_data(runtime: ToolRuntime[Context]) -> str:
    """Get current user data."""
    user_id = runtime.context.user_id
    return f"Data for {user_id}"

ToolRuntime Access

• runtime.state - Agent state (messages, custom fields)
• runtime.context - Immutable config (user_id, session)
• runtime.store - Persistent memory across conversations
• runtime.stream_writer - Stream updates during execution

Reserved Parameters

Cannot use as tool args: config, runtime

Memory

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.store.memory import InMemoryStore

# Short-term (conversation) memory
checkpointer = InMemorySaver()

# Long-term (cross-conversation) memory
store = InMemoryStore()

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[...],
    checkpointer=checkpointer,
    store=store
)

# Use thread_id for conversation continuity
config = {"configurable": {"thread_id": "conversation-1"}}
agent.invoke({"messages": [...]}, config=config)

Structured Output

from dataclasses import dataclass
from langchain.agents.structured_output import ToolStrategy

@dataclass
class Response:
    answer: str
    confidence: float | None = None

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[...],
    response_format=ToolStrategy(Response)
)
# Access: result['structured_response']

MCP Integration

Connect to MCP servers for external tools:

from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent

client = MultiServerMCPClient({
    "math": {
        "transport": "stdio",
        "command": "python",
        "args": ["/path/to/server.py"]
    },
    "api": {
        "transport": "http",
        "url": "http://localhost:8000/mcp",
        "headers": {"Authorization": "Bearer TOKEN"}
    }
})

tools = await client.get_tools()
agent = create_agent("claude-sonnet-4-5-20250929", tools)

MCP Interceptors

Modify tool calls, inject context, handle errors:

from langchain_mcp_adapters.interceptors import MCPToolCallRequest

async def auth_interceptor(request: MCPToolCallRequest, handler):
    runtime = request.runtime
    user_id = runtime.context.user_id
    modified = request.override(args={**request.args, "user_id": user_id})
    return await handler(modified)

client = MultiServerMCPClient({...}, tool_interceptors=[auth_interceptor])

Model Configuration

from langchain.chat_models import init_chat_model

model = init_chat_model(
    "claude-sonnet-4-5-20250929",  # or "gpt-4o", "gemini-1.5-pro"
    temperature=0.5,
    timeout=10,
    max_tokens=1000
)

State Updates from Tools

Return Command to update state or control flow:

from langgraph.types import Command
from langchain.messages import RemoveMessage

@tool
def clear_history() -> Command:
    """Clear conversation."""
    return Command(update={"messages": [RemoveMessage(id="__all__")]})

@tool  
def complete_task() -> Command:
    """End agent run."""
    return Command(update={"status": "done"}, goto="__end__")

Common Patterns

Full Production Agent

from dataclasses import dataclass
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.tools import tool, ToolRuntime
from langchain.agents.structured_output import ToolStrategy
from langgraph.checkpoint.memory import InMemorySaver

@dataclass
class Context:
    user_id: str

@tool
def search_orders(query: str, runtime: ToolRuntime[Context]) -> str:
    """Search user orders."""
    return f"Orders for {runtime.context.user_id}: {query}"

@dataclass
class Response:
    answer: str
    order_ids: list[str] | None = None

agent = create_agent(
    model=init_chat_model("claude-sonnet-4-5-20250929", temperature=0),
    system_prompt="You are a customer service agent.",
    tools=[search_orders],
    context_schema=Context,
    response_format=ToolStrategy(Response),
    checkpointer=InMemorySaver()
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Find my recent orders"}]},
    config={"configurable": {"thread_id": "session-1"}},
    context=Context(user_id="user123")
)

Anti-Patterns to Avoid

• Tools without type hints or docstrings — the docstring is the tool description the model sees; a missing or vague one means the agent misuses the tool
• Global state in tools — tools that read globals instead of ToolRuntime[Context] are untestable and unsafe in concurrent runs
• No checkpointer, then wondering why the agent forgets — multi-turn agents need checkpointer=InMemorySaver() (or a persistent saver) plus a stable thread_id
• Rebuilding everything as one giant system prompt — tools, structured output (ToolStrategy/with_structured_output), and retrieval exist to keep prompts small
• Letting raw tool exceptions reach the model — wrap tools, catch, and return structured error strings so the agent can recover
• Using deprecated LLMChain/SequentialChain APIs — current LangChain builds on create_agent and LangGraph; the old chains are removed from recent versions
• Stuffing whole documents into context — use the retrieval patterns in retrieval.md instead of naive full-document injection

When to Use / Not Use

Use this skill when:

• Building agents with LangChain or LangGraph (Python or TypeScript)
• Wiring tools, memory, MCP servers, or structured output into an LLM app
• Implementing RAG, multi-agent handoffs, routers, or stateful workflows

Do NOT use this skill when:

• A single stateless LLM call is all you need — the plain provider SDK is lighter
• The project standardizes on another agent framework (e.g., smolagents) — follow the project's stack
• The agent is code-first and benefits from the smaller SmolAgents execution model — see the smolagents skill

References

For detailed patterns, see:

• references/langgraph.md - LangGraph workflows, graphs, persistence
• references/multi-agent.md - Handoffs, routers, subagents
• references/retrieval.md - RAG, vector stores, embeddings

Key Links

• Docs: https://docs.langchain.com
• Python SDK: https://reference.langchain.com/python
• LangGraph: https://docs.langchain.com/oss/python/langgraph
• MCP Adapters: https://github.com/langchain-ai/langchain-mcp-adapters