Build LLM Apps with LangChain Agents & Chains

Guides building sophisticated LLM applications with the LangChain framework - agents, chains, memory, tool integration, and document processing - covering both quick-start patterns and production-hardening practices.

Use this skill for building autonomous AI agents with tool access, implementing complex multi-step LLM workflows, managing conversation memory and state, integrating LLMs with external data sources and APIs, creating modular reusable LLM components, implementing document processing pipelines, or building production-grade LLM applications. Do not use it for tasks unrelated to LangChain architecture, or when a different domain or tool is actually needed.

Five core concepts: Agents (ReAct, OpenAI Functions, Structured Chat, Conversational, Self-Ask with Search) autonomously decide which actions to take; Chains (LLMChain, SequentialChain, RouterChain, TransformChain, MapReduceChain) sequence calls to LLMs or utilities; Memory (ConversationBufferMemory, ConversationSummaryMemory, ConversationBufferWindowMemory, EntityMemory, VectorStoreMemory) maintains context across turns; Document Processing (loaders, text splitters, vector stores, retrievers, indexes) prepares content for retrieval; and Callbacks hook into logging, token tracking, latency monitoring, and error handling.

A quick-start example wires an LLM, loaded tools (serpapi, llm-math), conversation memory, and an agent together:

agent = initialize_agent(
    tools, llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory, verbose=True
)
result = agent.run("What's the weather in SF? Then calculate 25 * 4")

Three architecture patterns are shown in full: RAG (load documents, split into chunks, embed into a Chroma vector store, wrap in a RetrievalQA chain); a custom agent with @tool-decorated functions (e.g. search_database, send_email) wired into AgentType.ZERO_SHOT_REACT_DESCRIPTION; and a multi-step SequentialChain that extracts entities, analyzes them, then summarizes across three LLMChain steps.

Memory selection guidance maps conversation shape to memory type: ConversationBufferMemory for short conversations, ConversationSummaryMemory for long ones needing compression, ConversationBufferWindowMemory for a sliding window of the last N messages, ConversationEntityMemory for entity tracking, and VectorStoreRetrieverMemory for semantic retrieval of relevant history.

The callback system is demonstrated via a custom BaseCallbackHandler subclass hooking on_llm_start/on_llm_end/on_llm_error/on_chain_start/on_agent_action. Testing strategies mock the LLM to verify tool selection and check memory persistence across turns.

Performance optimization covers InMemoryCache for repeated LLM calls, parallel document processing via ThreadPoolExecutor, and streaming responses via StreamingStdOutCallbackHandler.

Five common pitfalls: memory overflow from unmanaged conversation history, tool selection errors from poor tool descriptions, exceeding the LLM's context window, missing error handling around agent failures, and inefficient vector store retrieval.

A ten-item production checklist: error handling, request/response logging, token usage/cost monitoring, execution timeouts, rate limiting, input validation, edge-case testing, observability via callbacks, fallback strategies, and version-controlled prompts/configs.

Built on the LangChain Python framework - agents, chains, langchain.memory, langchain.callbacks, langchain.vectorstores (Chroma), langchain.embeddings (OpenAI), and langchain.cache - with deeper references in references/agents.md, references/memory.md, references/chains.md, references/document-processing.md, and references/callbacks.md, plus ready templates in assets/agent-template.py and assets/chain-example.py.

Developers building LangChain-based LLM applications - agents with tool access, RAG pipelines, multi-step chains, or conversation memory - who need concrete architecture patterns and a production-readiness checklist rather than assembling LangChain components from scratch.