Langchain Development

LangChain Development

You are an expert in LangChain, LangGraph, and building LLM-powered applications with Python.

Key Principles

• Write concise, technical responses with accurate Python examples
• Use functional, declarative programming; avoid classes where possible
• Prefer iteration and modularization over code duplication
• Use descriptive variable names with auxiliary verbs (e.g., is_active, has_context)
• Follow PEP 8 style guidelines strictly

Code Organization

Directory Structure

Organize code into logical modules based on functionality:

project/
├── chains/           # LangChain chain definitions
├── agents/           # Agent configurations and tools
├── tools/            # Custom tool implementations
├── memory/           # Memory and state management
├── prompts/          # Prompt templates and management
├── retrievers/       # RAG and retrieval components
├── callbacks/        # Custom callback handlers
├── utils/            # Utility functions
├── tests/            # Test files
└── config/           # Configuration files

Naming Conventions

• Use snake_case for files, functions, and variables
• Use PascalCase for classes
• Prefix private functions with underscore
• Use descriptive names that indicate purpose (e.g., create_retrieval_chain, build_agent_executor)

LangChain Expression Language (LCEL)

Chain Composition

• Use LCEL for composing chains with the pipe operator (|)
• Prefer RunnableSequence and RunnableParallel for complex workflows
• Implement proper error handling with RunnableLambda

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

chain = (
    RunnableParallel(
        context=retriever,
        question=RunnablePassthrough()
    )
    | prompt
    | llm
    | output_parser
)

Best Practices

• Always use invoke() for single inputs, batch() for multiple inputs
• Use stream() for real-time token streaming
• Implement with_config() for runtime configuration
• Use bind() to attach tools or functions to runnables

Agents and Tools

Tool Development

• Define tools using the @tool decorator with clear docstrings
• Include type hints for all tool parameters
• Implement proper input validation
• Return structured outputs when possible

from langchain_core.tools import tool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search query string")

@tool(args_schema=SearchInput)
def search_database(query: str) -> str:
    """Search the database for relevant information."""
    # Implementation
    return results

Agent Configuration

• Use create_react_agent or create_tool_calling_agent based on model capabilities
• Implement proper agent executors with max iterations
• Add callbacks for monitoring and debugging
• Use structured chat agents for complex tool interactions

Memory and State Management

Conversation Memory

• Use ConversationBufferMemory for short conversations
• Implement ConversationSummaryMemory for long conversations
• Consider ConversationBufferWindowMemory for fixed-length history
• Use persistent storage backends for production (Redis, PostgreSQL)

LangGraph State

• Define explicit state schemas using TypedDict
• Implement proper state reducers for complex state updates
• Use checkpointing for resumable workflows
• Handle state persistence across sessions

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph
from operator import add

class AgentState(TypedDict):
    messages: Annotated[list, add]
    context: str
    next_step: str

graph = StateGraph(AgentState)

RAG (Retrieval-Augmented Generation)

Document Processing

• Use appropriate text splitters (RecursiveCharacterTextSplitter, MarkdownTextSplitter)
• Implement proper chunk sizing with overlap
• Preserve metadata during splitting
• Use document loaders appropriate for file types

Vector Stores

• Choose vector stores based on scale requirements
• Implement proper embedding caching
• Use hybrid search when available (dense + sparse)
• Configure appropriate similarity metrics

Retrieval Strategies

• Implement multi-query retrieval for complex questions
• Use contextual compression to reduce noise
• Consider parent document retrieval for better context
• Implement re-ranking for improved relevance

LangSmith Integration

Monitoring

• Enable tracing with LANGCHAIN_TRACING_V2=true
• Add run names for easy identification
• Implement custom metadata for filtering
• Use tags for categorization

Debugging

• Review traces for performance bottlenecks
• Analyze token usage patterns
• Monitor latency across chain components
• Set up alerts for error rates

Error Handling

• Implement retry logic with exponential backoff
• Handle rate limits from LLM providers gracefully
• Use fallback chains for critical paths
• Log errors with sufficient context

from langchain_core.runnables import RunnableWithFallbacks

chain_with_fallback = primary_chain.with_fallbacks(
    [fallback_chain],
    exceptions_to_handle=(RateLimitError, TimeoutError)
)

Performance Optimization

• Use async methods (ainvoke, abatch) for I/O-bound operations
• Implement caching for expensive operations
• Batch requests when possible
• Use streaming for better user experience

Testing

• Write unit tests for individual chain components
• Implement integration tests for full chains
• Use mocking for LLM calls in unit tests
• Test edge cases and error conditions

Dependencies

• langchain
• langchain-core
• langchain-community
• langgraph
• langsmith
• python-dotenv
• pydantic