LangChain Tutorial 2026: Build AI Applications with Chains and Agents

# Core LangChain packages (modular in v0.2+)
pip install langchain langchain-openai langchain-anthropic langchain-community
pip install langchain-chroma  # Vector store
pip install langgraph          # For agents
pip install langsmith           # Observability (optional)

import os
os.environ["OPENAI_API_KEY"] = "your-key"
# Or use python-dotenv: from dotenv import load_dotenv; load_dotenv()

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Components
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
output_parser = StrOutputParser()

# Simple chain: prompt | llm | parser
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an expert in {domain}."),
    ("human", "{question}")
])

chain = prompt | llm | output_parser

# Invoke
result = chain.invoke({
    "domain": "Python",
    "question": "What are the best practices for error handling?"
})
print(result)

# Stream
for chunk in chain.stream({"domain": "machine learning", "question": "Explain overfitting"}):
    print(chunk, end="", flush=True)

# Batch (parallel execution)
results = chain.batch([
    {"domain": "Python", "question": "What is a generator?"},
    {"domain": "SQL", "question": "When should I use indexes?"},
    {"domain": "Docker", "question": "What is a multi-stage build?"},
])

from langchain_core.prompts import (
    ChatPromptTemplate,
    FewShotChatMessagePromptTemplate,
    MessagesPlaceholder
)

# Few-shot prompting
examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
    {"input": "energetic", "output": "lethargic"},
]

example_prompt = ChatPromptTemplate.from_messages([
    ("human", "{input}"),
    ("ai", "{output}"),
])

few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
)

final_prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an antonyms generator."),
    few_shot_prompt,
    ("human", "{input}"),
])

chain = final_prompt | llm | output_parser
print(chain.invoke({"input": "big"}))  # "small"

# Dynamic prompts with message history
with_history_prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),  # Inject message history
    ("human", "{input}"),
])

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Session-based chat history
store = {}

def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])

chain = prompt | llm | output_parser

# Wrap with message history
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

# Invoke with session tracking
config = {"configurable": {"session_id": "user-123"}}

print(chain_with_history.invoke({"input": "Hi, my name is Alice."}, config=config))
print(chain_with_history.invoke({"input": "What's my name?"}, config=config))
# Output: "Your name is Alice, as you told me!"

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain_community.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.runnables import RunnablePassthrough

# 1. Load and index documents
loader = WebBaseLoader("https://example.com/docs")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = splitter.split_documents(docs)

vectorstore = Chroma.from_documents(splits, OpenAIEmbeddings())
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 2. RAG prompt
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", """Answer the question using only the provided context.
If the answer isn't in the context, say "I don't have that information."

Context: {context}"""),
    ("human", "{question}")
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# 3. RAG chain with LCEL
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | output_parser
)

answer = rag_chain.invoke("What are the main features?")
print(answer)

# With sources
from langchain_core.runnables import RunnableParallel

rag_chain_with_sources = RunnableParallel(
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
).assign(answer=rag_prompt | llm | output_parser)

result = rag_chain_with_sources.invoke("What are the main features?")
print(f"Answer: {result['answer']}")

from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

# Define tools
@tool
def search_web(query: str) -> str:
    """Search the web for current information."""
    # In practice: integrate with SerpAPI, Tavily, etc.
    return f"Search results for: {query}"

@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"Error: {e}"

@tool
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    # In practice: call a weather API
    return f"Weather in {city}: 72°F, partly cloudy"

tools = [search_web, calculate, get_weather]

# Create agent with LangGraph (modern approach)
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
agent = create_react_agent(model, tools)

# Run the agent
response = agent.invoke({
    "messages": [("human", "What is the square root of 144, and what's the weather like in Paris?")]
})

for message in response["messages"]:
    print(f"{message.type}: {message.content}")

from pydantic import BaseModel, Field
from typing import List

class MovieReview(BaseModel):
    title: str = Field(description="Movie title")
    rating: float = Field(description="Rating from 1-10")
    pros: List[str] = Field(description="Positive aspects")
    cons: List[str] = Field(description="Negative aspects")
    summary: str = Field(description="One-sentence summary")

# Structured output with Pydantic
structured_llm = llm.with_structured_output(MovieReview)

review = structured_llm.invoke(
    "Review the movie 'Inception' by Christopher Nolan"
)

print(f"Title: {review.title}")
print(f"Rating: {review.rating}/10")
print(f"Pros: {review.pros}")
print(f"Summary: {review.summary}")

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-langsmith-key"
os.environ["LANGCHAIN_PROJECT"] = "my-chatbot"

# All LangChain calls are now traced to LangSmith dashboard
# View: latency, token usage, inputs/outputs, errors
# No code changes needed beyond setting environment variables

chain = prompt | llm | output_parser
result = chain.invoke({"question": "What is machine learning?"})
# This call appears in your LangSmith project dashboard