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