LangChain: Comprehensive Guide

Overview

LangChain is a framework for developing applications powered by language models. It enables you to build sophisticated AI applications by chaining together different components like language models, data sources, and tools.

• Website: langchain.com
• GitHub: langchain-ai/langchain
• Languages: Python, JavaScript/TypeScript
• License: MIT
• Latest: Actively maintained with regular updates

---

Key Highlights

✅ Multi-LLM Support: Works with OpenAI, Anthropic Claude, Ollama, Hugging Face, and 30+ more
✅ Flexible Chains: Compose complex workflows from simple components
✅ Memory Management: Built-in conversation history and context management
✅ Tool Integration: Seamlessly connect agents to external APIs and tools
✅ RAG Framework: Native support for retrieval-augmented generation
✅ Production Ready: Used by thousands of companies in production

---

Core Concepts

1. Language Models (LLMs)

The foundation of LangChain applications. LangChain abstracts different LLM providers behind a unified interface.

Types: - LLMs: Text-in, text-out models (e.g., OpenAI's text-davinci-003) - Chat Models: Conversation-focused models (e.g., GPT-4, Claude) - Embeddings: Convert text to numerical vectors for semantic search

2. Prompts

Structured templates for crafting LLM inputs. Instead of hardcoding strings, you use PromptTemplate for reusable, flexible prompts.

Example:

from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write an article about {topic}"
)

formatted_prompt = prompt.format(topic="AI Agents")

3. Chains

Chains are the core abstraction in LangChain. A chain is a sequence of calls to components (LLMs, tools, utilities) that work together to accomplish a task. Think of chains as a pipeline or workflow where data flows through multiple processing steps.

Key Principles: - Composability: Chain simple components into complex workflows - Reusability: Build modular, reusable chain templates - State Management: Pass data and context between steps - Error Handling: Built-in mechanisms for handling failures - Debugging: Verbose mode to trace execution

Understanding Chains Conceptually

A basic chain follows this pattern:

Input → Component 1 → Component 2 → Component 3 → ... → Output

Each component: - Takes input data - Processes it (LLM call, API request, computation, etc.) - Produces output - Passes output to next component

Types of Chains

1. LLMChain (Simple Chain)

The most basic chain type. Combines a prompt template with an LLM.

from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

# Define a prompt template
prompt_template = PromptTemplate(
    input_variables=["product_name"],
    template="""You are a creative marketing expert.
    Generate 5 innovative product slogans for: {product_name}
    Format: Return only the slogans, one per line."""
)

# Create the chain
llm = OpenAI(temperature=0.8)
chain = LLMChain(
    llm=llm,
    prompt=prompt_template,
    verbose=True  # See detailed execution
)

# Execute
result = chain.run(product_name="Smart Water Bottle")
print(result)

Flow:

product_name → PromptTemplate → formatted_prompt → LLM → slogans

2. SequentialChain (Multi-Step Chain)

Runs multiple chains in sequence, passing output from one as input to the next.

from langchain.chains import SequentialChain, LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0.7)

# Step 1: Generate product names
step1_prompt = PromptTemplate(
    input_variables=["industry"],
    template="Generate 3 innovative product names for the {industry} industry"
)
step1_chain = LLMChain(
    llm=llm,
    prompt=step1_prompt,
    output_key="product_names"  # Important: name the output
)

# Step 2: Create marketing slogans for each name
step2_prompt = PromptTemplate(
    input_variables=["product_names"],
    template="Create catchy marketing slogans for these products:\n{product_names}"
)
step2_chain = LLMChain(
    llm=llm,
    prompt=step2_prompt,
    output_key="slogans"
)

# Step 3: Create a pricing strategy
step3_prompt = PromptTemplate(
    input_variables=["product_names", "slogans"],
    template="""Based on these products and slogans:
    Products: {product_names}
    Slogans: {slogans}

    Create a pricing strategy for each product."""
)
step3_chain = LLMChain(
    llm=llm,
    prompt=step3_prompt,
    output_key="pricing_strategy"
)

# Combine all chains
sequential_chain = SequentialChain(
    chains=[step1_chain, step2_chain, step3_chain],
    input_variables=["industry"],
    output_variables=["product_names", "slogans", "pricing_strategy"],
    verbose=True
)

# Execute
result = sequential_chain({
    "industry": "Sustainable Technology"
})

print("Products:", result["product_names"])
print("Slogans:", result["slogans"])
print("Pricing:", result["pricing_strategy"])

Flow:

industry → Chain1 → product_names → Chain2 → slogans → Chain3 → pricing_strategy

Important Notes: - Each chain must have an output_key to identify its output - Output keys become available as input variables for subsequent chains - output_variables specifies which outputs to return from the sequential chain

3. RouterChain (Conditional Chain)

Routes input to different chains based on conditions or classification.

from langchain.chains import LLMChain, RouterChain, MultiPromptChain
from langchain.chains.router import MultiPromptChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0)

# Define specialized chains for different topics
physics_template = """You are a physics expert. Answer this question:
Question: {input}
Answer:"""

history_template = """You are a history expert. Answer this question:
Question: {input}
Answer:"""

math_template = """You are a math expert. Answer this question:
Question: {input}
Answer:"""

# Create chains for each topic
chains = {
    "physics": LLMChain(
        llm=llm,
        prompt=PromptTemplate(
            template=physics_template,
            input_variables=["input"]
        )
    ),
    "history": LLMChain(
        llm=llm,
        prompt=PromptTemplate(
            template=history_template,
            input_variables=["input"]
        )
    ),
    "math": LLMChain(
        llm=llm,
        prompt=PromptTemplate(
            template=math_template,
            input_variables=["input"]
        )
    ),
}

# Define the router prompt (classifies which expert to use)
router_template = """Given a question, classify it as physics, history, or math.

Classification:"""

router_prompt = PromptTemplate(
    input_variables=["input"],
    template=router_template
)

# Create the router chain
router_chain = RouterChain.from_llm_and_prompts(
    llm=llm,
    prompts={
        "physics": PromptTemplate(
            template=physics_template,
            input_variables=["input"]
        ),
        "history": PromptTemplate(
            template=history_template,
            input_variables=["input"]
        ),
        "math": PromptTemplate(
            template=math_template,
            input_variables=["input"]
        ),
    }
)

# Alternative: Use MultiPromptChain
multi_prompt_chain = MultiPromptChain.from_prompts(
    llm=llm,
    prompt_infos=[
        {
            "name": "physics",
            "description": "Good for physics questions",
            "prompt_template": physics_template
        },
        {
            "name": "history",
            "description": "Good for history questions",
            "prompt_template": history_template
        },
        {
            "name": "math",
            "description": "Good for math questions",
            "prompt_template": math_template
        },
    ],
    default_chain=chains["physics"],  # Fallback chain
)

# Use it
result = multi_prompt_chain.run(
    input="What is Newton's first law of motion?"
)
print(result)

Flow:

question → Router (classify) → Select appropriate chain → Expert chain → answer

4. MapReduceChain (Parallel Processing)

Processes multiple documents in parallel (map), then combines results (reduce).

Best for: Summarizing large document sets, analyzing multiple texts, aggregating information

from langchain.chains import MapReduceChain
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import TextLoader
from langchain.llms import OpenAI

# Load and prepare documents
loader = TextLoader("large_document.txt")
documents = loader.load()

# Split into chunks
splitter = CharacterTextSplitter(
    chunk_size=4000,
    chunk_overlap=0
)
docs = splitter.split_documents(documents)

llm = OpenAI(temperature=0)

# Create map-reduce chain
chain = load_summarize_chain(
    llm=llm,
    chain_type="map_reduce",
    # Other options: "stuff", "refine"
    verbose=True
)

# Execute
summary = chain.run(docs)
print("Summary:", summary)

Flow:

[Doc1] → Map → Summary1
[Doc2] → Map → Summary2    → Reduce → Final Summary
[Doc3] → Map → Summary3

Chain types for summarization: - stuff: Combine all docs into single prompt (fast but token-limited) - map_reduce: Map over docs, reduce results (handles large docs) - refine: Iteratively refine summary (best quality, slower)

5. StuffDocumentsChain

Combines multiple documents into a single prompt and processes together.

from langchain.chains import StuffDocumentsChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

# Prompt that handles multiple documents
prompt_template = """Given these documents:
{context}

Answer this question: {question}"""

prompt = PromptTemplate(
    input_variables=["context", "question"],
    template=prompt_template
)

# Create chain
llm = OpenAI()
llm_chain = LLMChain(llm=llm, prompt=prompt)

chain = StuffDocumentsChain(
    llm_chain=llm_chain,
    document_variable_name="context"
)

# Use with documents
from langchain.schema import Document

docs = [
    Document(page_content="Paris is the capital of France"),
    Document(page_content="France has a population of 67 million"),
]

result = chain.run(
    input_documents=docs,
    question="What is the capital of France and its population?"
)

6. RefineDocumentsChain

Iteratively processes documents, refining the answer with each document.

Best for: Building comprehensive answers that require multiple sources

from langchain.chains import RefineDocumentsChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

llm = OpenAI()

# Initial prompt for first document
initial_prompt = PromptTemplate(
    input_variables=["context"],
    template="Summarize: {context}"
)

# Refine prompt for subsequent documents
refine_prompt = PromptTemplate(
    input_variables=["existing_answer", "context"],
    template="""You have this summary: {existing_answer}

    Add information from this new document: {context}

    Updated summary:"""
)

initial_llm_chain = LLMChain(llm=llm, prompt=initial_prompt)
refine_llm_chain = LLMChain(llm=llm, prompt=refine_prompt)

chain = RefineDocumentsChain(
    initial_llm_chain=initial_llm_chain,
    refine_llm_chain=refine_llm_chain,
    document_variable_name="context"
)

---

Modern Approach: LCEL (LangChain Expression Language)

LCEL is the new way to build chains in LangChain. It's more flexible and composable than legacy chains.

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.output_parsers import StrOutputParser

# Components
prompt = PromptTemplate(
    input_variables=["topic"],
    template="Explain {topic} in simple terms"
)

llm = OpenAI(temperature=0.7)
output_parser = StrOutputParser()

# Chain with pipe operator (|)
chain = prompt | llm | output_parser

# Execute
result = chain.invoke({"topic": "Quantum Computing"})
print(result)

Benefits: - ✅ Clean, readable syntax - ✅ Supports streaming - ✅ Parallel execution - ✅ Async support - ✅ Better error handling

LCEL with multiple outputs:

from langchain.schema.runnable import RunnablePassthrough

chain = (
    {"topic": RunnablePassthrough()}
    | prompt
    | llm
    | output_parser
)

---

Common Chain Patterns

Pattern 1: Question → Answer with Reasoning

qa_prompt = PromptTemplate(
    input_variables=["question"],
    template="""Question: {question}

Let me think through this step by step:
1. [First step]
2. [Second step]
3. [Conclusion]

Answer:"""
)

qa_chain = qa_prompt | llm | StrOutputParser()

Pattern 2: Transform Input → Process → Transform Output

from langchain.schema.runnable import RunnablePassthrough, RunnableLambda

def uppercase(text):
    return text.upper()

chain = (
    RunnableLambda(uppercase)  # Transform input
    | prompt
    | llm
    | output_parser
)

Pattern 3: Parallel Processing with .map()

# Process multiple inputs in parallel
questions = ["What is AI?", "What is ML?", "What is DL?"]

results = chain.map().invoke([{"question": q} for q in questions])

---

Debugging Chains

# 1. Verbose mode
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True  # See detailed logs
)

# 2. Using LangSmith for detailed debugging
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = "my-project"

# 3. Custom callback for debugging
from langchain.callbacks import BaseCallbackHandler

class DebugCallback(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM Input:\n{prompts[0]}\n")

    def on_llm_end(self, response, **kwargs):
        print(f"LLM Output:\n{response.generations[0][0].text}\n")

chain = LLMChain(
    llm=llm,
    prompt=prompt,
    callbacks=[DebugCallback()]
)

# 4. Test individual components
formatted_prompt = prompt.format(input="test")
print("Formatted Prompt:", formatted_prompt)

output = llm(formatted_prompt)
print("LLM Output:", output)

---

Performance Tips

Tip	How	Why
Batch requests	Use .batch() instead of .invoke() loop	Process multiple items efficiently
Async execution	Use .ainvoke() for async chains	Non-blocking I/O, better concurrency
Stream output	Use .stream() for streaming responses	Better UX, see results faster
Cache embeddings	Use embedding cache layers	Avoid recalculating same embeddings
Token optimization	Use max_tokens limit in prompts	Reduce costs and latency
Parallel chains	Use LCEL parallel syntax	Reduce total execution time

# Async example
async def run_chain():
    result = await chain.ainvoke({"topic": "AI"})
    return result

# Batch processing
results = chain.batch([
    {"topic": "AI"},
    {"topic": "ML"},
    {"topic": "DL"}
])

# Streaming
for chunk in chain.stream({"topic": "AI"}):
    print(chunk, end="", flush=True)

4. Memory

Stores conversation history and context to enable multi-turn interactions.

Types: - ConversationBufferMemory: Stores all messages - ConversationBufferWindowMemory: Keeps last N messages - ConversationSummaryMemory: Summarizes conversation - EntityMemory: Remembers facts about entities

5. Agents

Autonomous systems that decide which tools to use and how to use them. Agents can reason through multi-step problems.

Architecture: - Agent receives input - Decides which tool to use - Executes tool - Observes result - Repeats until goal is achieved

6. Tools/Toolkits

Integrations with external APIs and services.

Examples: - Web search (Google, DuckDuckGo) - Calculators - Code execution - Database queries - Wikipedia - Weather APIs

7. Retrieval (RAG)

Augments LLM responses with external knowledge from documents or databases.

Components: - Document Loaders: Read files (PDF, TXT, MD, etc.) - Text Splitters: Break documents into chunks - Embeddings: Convert text to vectors - Vector Stores: Store and retrieve embeddings - Retrievers: Fetch relevant documents

---

Installation & Setup

Python Installation

# Basic installation
pip install langchain

# With OpenAI support
pip install langchain openai

# With multiple LLM providers
pip install langchain anthropic huggingface-hub ollama

# With additional features
pip install langchain-community  # Community integrations
pip install langchain-experimental  # Experimental features

# Development
pip install langchain[dev]  # Include dev dependencies

JavaScript/TypeScript Installation

npm install langchain
npm install --save-dev typescript

# With specific integrations
npm install @langchain/openai
npm install @langchain/anthropic

Environment Configuration

# .env file
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=claude-...
HUGGINGFACEHUB_API_TOKEN=hf_...

---

Core Components in Detail

1. Working with Language Models

OpenAI Example

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI

# Text completion model
llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0.7)
response = llm("What is quantum computing?")
print(response)

# Chat model (recommended)
chat = ChatOpenAI(model_name="gpt-4", temperature=0)
response = chat.invoke([
    ("system", "You are a helpful assistant"),
    ("human", "Explain photosynthesis")
])

Using Local Models (Ollama)

from langchain.llms import Ollama

llm = Ollama(model="llama2", temperature=0.7)
response = llm("Write a Python function to sort a list")

Anthropic Claude

from langchain_anthropic import ChatAnthropic

chat = ChatAnthropic(model="claude-3-sonnet-20240229")
response = chat.invoke([
    ("human", "What is machine learning?")
])

2. Prompt Templates

from langchain.prompts import PromptTemplate, ChatPromptTemplate
from langchain.prompts.few_shot import FewShotPromptTemplate

# Simple template
template = """Question: {question}
Answer:"""

prompt = PromptTemplate(template=template, input_variables=["question"])

# Chat template (for chat models)
chat_template = ChatPromptTemplate.from_messages([
    ("system", "You are an expert in {field}"),
    ("human", "{user_query}")
])

# Few-shot example template
examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
]

example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}"
)

few_shot_prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    suffix="Input: {adjective}\nOutput:",
    input_variables=["adjective"]
)

3. Chains

LLMChain (Simple)

from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
    input_variables=["product"],
    template="What are 5 potential product names for {product}?"
)

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run("a colorful sock brand")
print(result)

Sequential Chain

from langchain.chains import SequentialChain

# First chain: Generate names
name_prompt = PromptTemplate(
    input_variables=["business"],
    template="Generate 3 business names for {business}"
)
name_chain = LLMChain(llm=llm, prompt=name_prompt)

# Second chain: Evaluate names
eval_prompt = PromptTemplate(
    input_variables=["names"],
    template="Evaluate these business names: {names}"
)
eval_chain = LLMChain(llm=llm, prompt=eval_prompt)

# Combine chains
overall_chain = SequentialChain(
    chains=[name_chain, eval_chain],
    input_variables=["business"],
    output_variables=["output"]
)

4. Memory

Conversation Buffer Memory

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.llms import OpenAI

memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=OpenAI(temperature=0.0),
    memory=memory,
    verbose=True
)

# Multiple turns automatically use memory
conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")  # Knows you're Alice

print(memory.buffer)  # See full conversation

Window Memory (Keep Last N Messages)

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=2)  # Keep last 2 messages

Summary Memory

from langchain.memory import ConversationSummaryMemory

memory = ConversationSummaryMemory(
    llm=OpenAI(),
    buffer=""
)

5. Agents

ReAct Agent (Reasoning + Acting)

from langchain import hub
from langchain.agents import AgentExecutor, create_react_agent
from langchain.llms import OpenAI
from langchain.tools import Tool

# Define tools
def calculator(expression):
    return str(eval(expression))

def search_web(query):
    # Simulate web search
    return f"Search results for: {query}"

tools = [
    Tool(name="Calculator", func=calculator, 
         description="Useful for math"),
    Tool(name="WebSearch", func=search_web,
         description="Search the web")
]

# Load default prompt
prompt = hub.pull("hwchase17/react-chat")

# Create agent
agent = create_react_agent(
    llm=OpenAI(),
    tools=tools,
    prompt=prompt
)

# Execute
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = executor.invoke({
    "input": "What is 5 + 3 times 2?"
})

Tool Calling Agent (Modern Approach)

from langchain.agents import tool, AgentExecutor
from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
from langchain.chat_models import ChatOpenAI
from langchain.schema import SystemMessage

@tool
def get_weather(location: str) -> str:
    """Get weather for a location"""
    return f"Weather in {location}: Sunny, 72°F"

@tool
def calculate(expression: str) -> str:
    """Calculate math expressions"""
    return str(eval(expression))

tools = [get_weather, calculate]

llm = ChatOpenAI(model="gpt-4")

system_message = SystemMessage(
    content="You are a helpful assistant"
)

agent = OpenAIFunctionsAgent.from_llm_and_tools(
    llm=llm,
    tools=tools,
    system_message=system_message,
)

executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "What's the weather in New York and what's 10 + 5?"
})

6. Retrieval Augmented Generation (RAG)

Basic RAG Pipeline

from langchain.document_loaders import PDFLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. Load documents
loader = PDFLoader("document.pdf")
documents = loader.load()

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

# 3. Create embeddings
embeddings = OpenAIEmbeddings()

# 4. Store in vector database
vector_store = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 5. Create retriever
retriever = vector_store.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 3}
)

# 6. Create QA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# 7. Query
result = qa_chain({"query": "What is the main topic?"})
print(result["result"])
print(result["source_documents"])

With Multiple Document Loaders

from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.document_loaders.csv_loader import CSVLoader

# Load multiple files
loader = DirectoryLoader(
    "./documents/",
    glob="*.md",
    loader_cls=TextLoader
)
documents = loader.load()

# Or load specific formats
csv_loader = CSVLoader(file_path="data.csv")
csv_docs = csv_loader.load()

---

Advanced Features

1. Output Parsing

from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

response_schemas = [
    ResponseSchema(name="name", description="Person's name"),
    ResponseSchema(name="age", description="Person's age"),
    ResponseSchema(name="job", description="Person's job")
]

output_parser = StructuredOutputParser.from_response_schemas(
    response_schemas
)

format_instructions = output_parser.get_format_instructions()

prompt = PromptTemplate(
    template="Extract information:\n{format_instructions}\n{query}",
    input_variables=["query"],
    partial_variables={"format_instructions": format_instructions}
)

chain = prompt | OpenAI() | output_parser
result = chain.invoke({"query": "John is 30 and works as a software engineer"})
print(result)  # {"name": "John", "age": 30, "job": "software engineer"}

2. Callbacks & Logging

from langchain.callbacks import StdOutCallbackHandler, FileCallbackHandler
from langchain.llms import OpenAI

# Log to stdout
callback_handler = StdOutCallbackHandler()

# Log to file
logfile = FileCallbackHandler("agent.log")

llm = OpenAI(
    callbacks=[callback_handler, logfile],
    verbose=True
)

llm("What is AI?")

3. Custom Tools

from langchain.tools import StructuredTool
from pydantic import BaseModel, Field

class CalculatorInput(BaseModel):
    expression: str = Field(description="Math expression to calculate")

def calculator_tool(expression: str) -> str:
    """Calculate mathematical expressions"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Error: {e}"

tool = StructuredTool.from_function(
    func=calculator_tool,
    name="Calculator",
    description="Useful for calculating math expressions",
    args_schema=CalculatorInput,
)

4. Custom Chains

from langchain.chains.base import Chain
from pydantic import BaseModel

class CustomChain(Chain):
    """Custom chain implementation"""

    @property
    def input_keys(self) -> list:
        return ["input"]

    @property
    def output_keys(self) -> list:
        return ["output"]

    def _call(self, inputs):
        # Custom logic here
        result = inputs["input"].upper()
        return {"output": result}

chain = CustomChain()
result = chain({"input": "hello"})

---

Best Practices

✅ Do's

1. Use environment variables for API keys (never commit them)
2. Implement error handling for API failures
3. Set appropriate temperature for different use cases
4. Cache embeddings to reduce costs
5. Monitor token usage to control costs
6. Use streaming for better UX in chat applications
7. Implement rate limiting for API calls
8. Version control prompts as they evolve
9. Test chains thoroughly before production
10. Use memory wisely to avoid token bloat

❌ Don'ts

1. ❌ Commit API keys to repositories
2. ❌ Use always-high temperature for consistency-required tasks
3. ❌ Ignore token limits and context windows
4. ❌ Create agents without clear tool definitions
5. ❌ Use production without fallbacks
6. ❌ Neglect prompt engineering
7. ❌ Ignore error handling in chains
8. ❌ Store sensitive data in memory
9. ❌ Over-engineer simple tasks
10. ❌ Skip testing and monitoring

---

Common Use Cases

1. Question Answering over Documents

Use RAG pipeline with document loaders and retrievers.

2. Conversational Chatbots

Combine LLMs with memory for multi-turn conversations.

3. Agents with Tool Access

Build autonomous agents that can search web, calculate, query databases.

4. Data Analysis

Create chains that analyze data and generate insights.

5. Content Generation

Generate blog posts, emails, code, marketing copy.

6. Code Generation & Review

Build tools for programming assistance.

7. Information Extraction

Extract structured data from unstructured text.

8. Summarization

Summarize long documents or conversations.

---

Comparison with Alternatives

Feature	LangChain	LlamaIndex	Haystack
Focus	General LLM apps	Document indexing/RAG	Search & QA
Learning Curve	Moderate	Moderate	Steep
Community	Very large	Growing	Smaller
Flexibility	Very high	Medium	Medium
Production Ready	Yes	Yes	Yes
Multi-agent	Yes	Limited	Limited

---

Resources

• Official Docs: python.langchain.com
• GitHub: github.com/langchain-ai/langchain
• API Reference: api.python.langchain.com
• LangSmith: Debugging and monitoring tool
• Templates: github.com/langchain-ai/langchain-template

---

Next Steps

1. Explore LangChain Hub for community-built chains and agents
2. Try LangSmith for debugging and monitoring
3. Build a RAG application with your own documents
4. Create a custom agent with your tools
5. Deploy to production using FastAPI or similar

---

Related Notes

• 00 Readme
• 02 Llamaindex
• 00 Readme