The Complete LangChain Guide: Build AI Applications from Scratch

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
import requests
# Define custom tools
@tool
def get_weather(city: str) -> str:
"""Get the current weather for a city."""
# In production, use a real weather API
return f"The weather in {city} is 72°F and sunny."
@tool
def search_web(query: str) -> str:
"""Search the web for information."""
# In production, use a real search API
return f"Search results for '{query}': [Example results...]"
@tool
def calculate(expression: str) -> str:
"""Evaluate a mathematical expression."""
try:
result = eval(expression)  # Use a safe eval in production!
return str(result)
except:
return "Could not evaluate expression"
# Create the agent
tools = [get_weather, search_web, calculate]
llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_react_agent(llm, tools)
# Run the agent
result = agent.invoke({
"messages": [{"role": "user", "content": "What's the weather in Tokyo?"}]
})
print(result["messages"][-1].content)

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchRun
from langgraph.prebuilt import create_react_agent
# Real web search tool
search = DuckDuckGoSearchRun()
@tool
def web_search(query: str) -> str:
"""Search the web for current information."""
return search.run(query)
@tool
def save_note(content: str) -> str:
"""Save a research note to a file."""
with open("research_notes.txt", "a") as f:
f.write(content + "\n\n")
return "Note saved successfully."
@tool
def read_notes() -> str:
"""Read all saved research notes."""
try:
with open("research_notes.txt", "r") as f:
return f.read()
except FileNotFoundError:
return "No notes saved yet."
# Create research agent
tools = [web_search, save_note, read_notes]
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = create_react_agent(
llm,
tools,
state_modifier="""You are a research assistant. When given a topic:
1. Search for relevant information
2. Save important findings as notes
3. Synthesize your findings into a summary
Be thorough but concise."""</span>

)
# Example: Research a topic
result = agent.invoke({
"messages": [{
"role": "user",
"content": "Research the latest developments in quantum computing in 2024"
}]
})

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
llm = ChatOpenAI(model="gpt-4o-mini", streaming=True)
prompt = ChatPromptTemplate.from_template("Tell me a story about {topic}")
chain = prompt | llm
# Stream the response
for chunk in chain.stream({"topic": "a robot learning to paint"}):
print(chunk.content, end="", flush=True)

from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnableConfig
# Configure retries and timeouts
llm = ChatOpenAI(
model="gpt-4o-mini",
max_retries=3,
timeout=30,
request_timeout=60
)
# Add fallback model
fallback_llm = ChatOpenAI(model="gpt-3.5-turbo")
robust_llm = llm.with_fallbacks([fallback_llm])
# Use with rate limiting
from langchain_core.rate_limiters import InMemoryRateLimiter
rate_limiter = InMemoryRateLimiter(
requests_per_second=1,
check_every_n_seconds=0.1,
max_bucket_size=10
)
llm_rate_limited = ChatOpenAI(
model="gpt-4o-mini",
rate_limiter=rate_limiter
)

LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=your-langsmith-api-key
LANGCHAIN_PROJECT=my-production-app

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, AIMessage
from langgraph.prebuilt import create_react_agent
from pydantic import BaseModel, Field
from typing import Optional
import json
# Initialize components
llm = ChatOpenAI(model="gpt-4o", temperature=0)
embeddings = OpenAIEmbeddings()
# Load knowledge base (your FAQ/documentation)
vectorstore = Chroma(
persist_directory="./support_kb",
embedding_function=embeddings
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# Define tools
@tool
def search_knowledge_base(query: str) -> str:
"""Search the knowledge base for relevant information."""
docs = retriever.invoke(query)
return "\n\n".join([doc.page_content for doc in docs])
@tool
def check_order_status(order_id: str) -> str:
"""Check the status of an order by order ID."""
# In production, query your database
return json.dumps({
"order_id": order_id,
"status": "shipped",
"estimated_delivery": "2024-01-15"
})
@tool
def create_support_ticket(
subject: str,
description: str,
priority: str = "medium"
) -> str:
"""Create a support ticket for issues that need human attention."""
# In production, create in your ticketing system
ticket_id = "TKT-12345"
return f"Created ticket {ticket_id}: {subject}"
# Create the support agent
tools = [search_knowledge_base, check_order_status, create_support_ticket]
system_prompt = """You are a helpful customer support agent for TechCo.
Guidelines:

Always be polite and empathetic
Search the knowledge base before saying you don't know
For order issues, always check the order status first
Create a support ticket if you cannot resolve the issue
Never make up information - if unsure, escalate to human support

Company info:

Return policy: 30 days, no questions asked
Support hours: 24/7 for chat, phone support 9am-5pm EST
Shipping: Free over $50, otherwise $5.99"""

agent = create_react_agent(llm, tools, state_modifier=system_prompt)
# Conversation handler with memory
class SupportBot:
def init(self):
self.history = []
<span class="text-purple-400">def</span> <span class="text-yellow-400">chat</span>(self, user_message: str) -> str:
    self.history.append({<span class="text-green-400">"role"</span>: <span class="text-green-400">"user"</span>, <span class="text-green-400">"content"</span>: user_message})

    result = agent.invoke({<span class="text-green-400">"messages"</span>: self.history})

    assistant_message = result[<span class="text-green-400">"messages"</span>][-1].content
    self.history.append({<span class="text-green-400">"role"</span>: <span class="text-green-400">"assistant"</span>, <span class="text-green-400">"content"</span>: assistant_message})

    <span class="text-purple-400">return</span> assistant_message

# Usage
bot = SupportBot()
print(bot.chat("Hi, I need help with my order #12345"))
print(bot.chat("When will it arrive?"))