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
)
Hybrid Search
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])
Related Documents
- Pattern: Agent Chaining & Orchestration - Chaining concepts
- Implementation Guide: RAG Systems - Detailed RAG guide
- Implementation Guide: Building Agents with n8n - No-code alternative
- ENT-RAG - RAG concepts