langchain-development

•

6155 months ago

Expert guidance for LangChain and LangGraph development with Python, covering chain composition, agents, memory, and RAG implementations.

Quick Install

npxskills add mindrally/skills--skill langchain-development

Instructions

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

Loading…

Related Skills

skill-creator

Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.

367,360