langchain-development

SKILL.md

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