guide

Implementation Guide: Building Agents with LangChain

Build AI agents with LangChain. Covers chains, agents, memory, and RAG implementation with Python code examples.

Overview

LangChain is a Python/JS framework for building LLM applications. It excels at:

  • Complex reasoning chains
  • Tool-using agents
  • RAG implementations
  • Custom integrations

When to Use LangChain

Good For Not Ideal For
Complex reasoning Simple prompts
Tool-using agents No-code requirements
RAG applications Quick prototypes
Custom integrations Visual workflows
Production systems Non-developers

Setup

# Install core packages
pip install langchain langchain-anthropic langchain-openai

# Optional: for RAG
pip install langchain-chroma sentence-transformers

# Optional: for agents
pip install langchain-community

Environment Setup

import os
os.environ["ANTHROPIC_API_KEY"] = "your-key"
os.environ["OPENAI_API_KEY"] = "your-key"  # for embeddings

Core Concepts

1. Chat Models

from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI

# Claude
claude = ChatAnthropic(model="claude-sonnet-4-20250514")

# GPT-4
gpt4 = ChatOpenAI(model="gpt-4o")

# Basic invocation
response = claude.invoke("What is LangChain?")
print(response.content)

2. Prompts

from langchain.prompts import ChatPromptTemplate

# Simple prompt
prompt = ChatPromptTemplate.from_template(
    "Write a {tone} email about {topic}"
)

# With system message
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a professional email writer."),
    ("human", "Write an email about {topic}")
])

# Format
formatted = prompt.format(topic="product launch", tone="professional")

3. Chains (LCEL)

from langchain.prompts import ChatPromptTemplate
from langchain_anthropic import ChatAnthropic
from langchain_core.output_parsers import StrOutputParser

# Chain with pipe operator
chain = (
    ChatPromptTemplate.from_template("Tell me about {topic}")
    | ChatAnthropic(model="claude-sonnet-4-20250514")
    | StrOutputParser()
)

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

4. Output Parsers

from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

class EmailOutput(BaseModel):
    subject: str = Field(description="Email subject line")
    body: str = Field(description="Email body")
    cta: str = Field(description="Call to action")

parser = PydanticOutputParser(pydantic_object=EmailOutput)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Generate an email. {format_instructions}"),
    ("human", "Topic: {topic}")
]).partial(format_instructions=parser.get_format_instructions())

chain = prompt | llm | parser
result = chain.invoke({"topic": "product demo"})
# result is EmailOutput object

Common Patterns

Pattern 1: Sequential Chain

from langchain_core.runnables import RunnablePassthrough

# Research β†’ Draft β†’ Edit
research_chain = research_prompt | llm | StrOutputParser()
draft_chain = draft_prompt | llm | StrOutputParser()
edit_chain = edit_prompt | llm | StrOutputParser()

full_chain = (
    {"research": research_chain, "topic": RunnablePassthrough()}
    | draft_chain
    | {"draft": RunnablePassthrough()}
    | edit_chain
)

result = full_chain.invoke("AI in healthcare")

Pattern 2: Parallel Execution

from langchain_core.runnables import RunnableParallel

# Gather data in parallel
parallel_chain = RunnableParallel(
    linkedin=linkedin_chain,
    website=website_chain,
    news=news_chain
)

# Then synthesize
synthesis_chain = (
    parallel_chain
    | synthesis_prompt
    | llm
    | StrOutputParser()
)

result = synthesis_chain.invoke({"company": "TechCorp"})

Pattern 3: Conditional Routing

from langchain_core.runnables import RunnableBranch

# Route based on classification
router = RunnableBranch(
    (lambda x: x["risk"] == "high", urgent_chain),
    (lambda x: x["risk"] == "medium", proactive_chain),
    expansion_chain  # default
)

full_chain = classifier_chain | router

RAG Implementation

Basic RAG

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import DirectoryLoader

# 1. Load documents
loader = DirectoryLoader("./docs", glob="**/*.md")
documents = loader.load()

# 2. Split into chunks
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(documents)

# 3. Create embeddings and store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Create retriever
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

# 5. Create RAG chain
from langchain.chains import RetrievalQA

rag_chain = RetrievalQA.from_chain_type(
    llm=claude,
    retriever=retriever,
    return_source_documents=True
)

result = rag_chain.invoke("What is our refund policy?")

Advanced RAG with Reranking

from langchain.retrievers import ContextualCompressionRetriever
from langchain_cohere import CohereRerank

# Base retriever gets more docs
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 20})

# Reranker filters to best
reranker = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=base_retriever
)

# Use in chain
rag_chain = RetrievalQA.from_chain_type(
    llm=claude,
    retriever=compression_retriever,
    return_source_documents=True
)
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

# BM25 for keyword matching
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 10

# Vector for semantic
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Combine
ensemble = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.4, 0.6]
)

Memory

Conversation Memory

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(
    k=10,  # Keep last 10 exchanges
    return_messages=True
)

# Use in chain
chain = ConversationChain(
    llm=claude,
    memory=memory
)

chain.invoke("Hello!")
chain.invoke("What did I just say?")  # Has context

Entity Memory

from langchain.memory import ConversationEntityMemory

memory = ConversationEntityMemory(llm=claude)

# After conversation, access entities
print(memory.entity_store.store)
# {"Sarah": {"role": "VP Engineering", "company": "TechCorp"}}

Persistent Memory (Redis)

from langchain.memory import RedisChatMessageHistory

history = RedisChatMessageHistory(
    session_id="user_123",
    url="redis://localhost:6379"
)

memory = ConversationBufferMemory(
    chat_memory=history,
    return_messages=True
)

Tool-Using Agents

Define Tools

from langchain.tools import tool

@tool
def search_crm(query: str) -> str:
    """Search CRM for account information."""
    # Your CRM integration here
    return crm_client.search(query)

@tool
def send_slack_message(channel: str, message: str) -> str:
    """Send a message to a Slack channel."""
    slack_client.post_message(channel, message)
    return "Message sent"

tools = [search_crm, send_slack_message]

Create Agent

from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to CRM and Slack."),
    ("placeholder", "{chat_history}"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(claude, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "Find TechCorp in CRM and send their health score to #cs-alerts"
})

Example: Prospect Research Agent

from langchain_anthropic import ChatAnthropic
from langchain.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel
from langchain_core.output_parsers import StrOutputParser

llm = ChatAnthropic(model="claude-sonnet-4-20250514")

# Data gathering chains
linkedin_prompt = ChatPromptTemplate.from_template(
    "Summarize this LinkedIn profile: {linkedin_data}"
)
linkedin_chain = linkedin_prompt | llm | StrOutputParser()

website_prompt = ChatPromptTemplate.from_template(
    "Summarize this company website: {website_data}"
)
website_chain = website_prompt | llm | StrOutputParser()

# Parallel gathering
gather_chain = RunnableParallel(
    linkedin=linkedin_chain,
    website=website_chain
)

# Synthesis
synthesis_prompt = ChatPromptTemplate.from_template("""
You are a sales research assistant.

LinkedIn Summary: {linkedin}
Website Summary: {website}

Create a 200-word prospect briefing covering:
1. Company snapshot
2. Contact context
3. Conversation starters
4. Potential pain points
""")

full_chain = (
    gather_chain
    | synthesis_prompt
    | llm
    | StrOutputParser()
)

# Use
result = full_chain.invoke({
    "linkedin_data": "...",
    "website_data": "..."
})

Production Considerations

Async Operations

import asyncio

async def process_batch(items):
    tasks = [chain.ainvoke(item) for item in items]
    results = await asyncio.gather(*tasks)
    return results

# Run
results = asyncio.run(process_batch(my_items))

Streaming

async for chunk in chain.astream({"topic": "AI"}):
    print(chunk, end="", flush=True)

Callbacks for Logging

from langchain.callbacks import FileCallbackHandler

handler = FileCallbackHandler("langchain.log")
result = chain.invoke({"topic": "AI"}, config={"callbacks": [handler]})

Error Handling

from langchain_core.runnables import RunnableWithFallbacks

# Chain with fallback
safe_chain = chain.with_fallbacks([fallback_chain])