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