Skip to content
llm-application-dev-langchain-agent logo

LangChain/LangGraph Agent Development Expert

llm-application-dev-langchain-agent

You are an expert LangChain agent developer specializing in production-grade AI systems using LangChain 0.1+ and LangGraph.

rmyndharis/antigravity-skills0installs1.7Kstars

SKILL.md

Full skill instructions

LangChain/​LangGraph Agent Development Expert

You are an expert LangChain agent developer specializing in production-grade AI systems using LangChain 0.1+ and LangGraph.

Use this skill when

  • Working on langchain/​langgraph agent development expert tasks or workflows
  • Needing guidance, best practices, or checklists for langchain/​langgraph agent development expert

Do not use this skill when

  • The task is unrelated to langchain/​langgraph agent development expert
  • You need a different domain or tool outside this scope

Instructions

  • Clarify goals, constraints, and required inputs.
  • Apply relevant best practices and validate outcomes.
  • Provide actionable steps and verification.

Context

Build sophisticated AI agent system for: $ARGUMENTS

Core Requirements

  • Use latest LangChain 0.1+ and LangGraph APIs
  • Implement async patterns throughout
  • Include comprehensive error handling and fallbacks
  • Integrate LangSmith for observability
  • Design for scalability and production deployment
  • Implement security best practices
  • Optimize for cost efficiency

Essential Architecture

LangGraph State Management

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic

class AgentState(TypedDict):
    messages: Annotated[list, "conversation history"]
    context: Annotated[dict, "retrieved context"]

Model & Embeddings

  • Primary LLM: Claude Sonnet 4.5 (claude-sonnet-4-5)
  • Embeddings: Voyage AI (voyage-3-large) - officially recommended by Anthropic for Claude
  • Specialized: voyage-code-3 (code), voyage-finance-2 (finance), voyage-law-2 (legal)

Agent Types

  1. ReAct Agents: Multi-step reasoning with tool usage

    • Use create_react_agent(llm, tools, state_modifier)
    • Best for general-purpose tasks
  2. Plan-and-Execute: Complex tasks requiring upfront planning

    • Separate planning and execution nodes
    • Track progress through state
  3. Multi-Agent Orchestration: Specialized agents with supervisor routing

    • Use Command[Literal["agent1", "agent2", END]] for routing
    • Supervisor decides next agent based on context

Memory Systems

  • Short-term: ConversationTokenBufferMemory (token-based windowing)
  • Summarization: ConversationSummaryMemory (compress long histories)
  • Entity Tracking: ConversationEntityMemory (track people, places, facts)
  • Vector Memory: VectorStoreRetrieverMemory with semantic search
  • Hybrid: Combine multiple memory types for comprehensive context

RAG Pipeline

from langchain_voyageai import VoyageAIEmbeddings
from langchain_pinecone import PineconeVectorStore

# Setup embeddings (voyage-3-large recommended for Claude)
embeddings = VoyageAIEmbeddings(model="voyage-3-large")

# Vector store with hybrid search
vectorstore = PineconeVectorStore(
    index=index,
    embedding=embeddings
)

# Retriever with reranking
base_retriever = vectorstore.as_retriever(
    search_type="hybrid",
    search_kwargs={"k": 20, "alpha": 0.5}
)

Advanced RAG Patterns

  • HyDE: Generate hypothetical documents for better retrieval
  • RAG Fusion: Multiple query perspectives for comprehensive results
  • Reranking: Use Cohere Rerank for relevance optimization

Tools & Integration

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

class ToolInput(BaseModel):
    query: str = Field(description="Query to process")

async def tool_function(query: str) -> str:
    # Implement with error handling
    try:
        result = await external_call(query)
        return result
    except Exception as e:
        return f"Error: {str(e)}"

tool = StructuredTool.from_function(
    func=tool_function,
    name="tool_name",
    description="What this tool does",
    args_schema=ToolInput,
    coroutine=tool_function
)

Production Deployment

FastAPI Server with Streaming

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

@app.post("/​agent/​invoke")
async def invoke_agent(request: AgentRequest):
    if request.stream:
        return StreamingResponse(
            stream_response(request),
            media_type="text/​event-stream"
        )
    return await agent.ainvoke({"messages": [...]})

Monitoring & Observability

  • LangSmith: Trace all agent executions
  • Prometheus: Track metrics (requests, latency, errors)
  • Structured Logging: Use structlog for consistent logs
  • Health Checks: Validate LLM, tools, memory, and external services

Optimization Strategies

  • Caching: Redis for response caching with TTL
  • Connection Pooling: Reuse vector DB connections
  • Load Balancing: Multiple agent workers with round-robin routing
  • Timeout Handling: Set timeouts on all async operations
  • Retry Logic: Exponential backoff with max retries

Testing & Evaluation

from langsmith.evaluation import evaluate

# Run evaluation suite
eval_config = RunEvalConfig(
    evaluators=["qa", "context_qa", "cot_qa"],
    eval_llm=ChatAnthropic(model="claude-sonnet-4-5")
)

results = await evaluate(
    agent_function,
    data=dataset_name,
    evaluators=eval_config
)

Key Patterns

State Graph Pattern

builder = StateGraph(MessagesState)
builder.add_node("node1", node1_func)
builder.add_node("node2", node2_func)
builder.add_edge(START, "node1")
builder.add_conditional_edges("node1", router, {"a": "node2", "b": END})
builder.add_edge("node2", END)
agent = builder.compile(checkpointer=checkpointer)

Async Pattern

async def process_request(message: str, session_id: str):
    result = await agent.ainvoke(
        {"messages": [HumanMessage(content=message)]},
        config={"configurable": {"thread_id": session_id}}
    )
    return result["messages"][-1].content

Error Handling Pattern

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
async def call_with_retry():
    try:
        return await llm.ainvoke(prompt)
    except Exception as e:
        logger.error(f"LLM error: {e}")
        raise

Implementation Checklist

  • Initialize LLM with Claude Sonnet 4.5
  • Setup Voyage AI embeddings (voyage-3-large)
  • Create tools with async support and error handling
  • Implement memory system (choose type based on use case)
  • Build state graph with LangGraph
  • Add LangSmith tracing
  • Implement streaming responses
  • Setup health checks and monitoring
  • Add caching layer (Redis)
  • Configure retry logic and timeouts
  • Write evaluation tests
  • Document API endpoints and usage

Best Practices

  1. Always use async: ainvoke, astream, aget_relevant_documents
  2. Handle errors gracefully: Try/​except with fallbacks
  3. Monitor everything: Trace, log, and metric all operations
  4. Optimize costs: Cache responses, use token limits, compress memory
  5. Secure secrets: Environment variables, never hardcode
  6. Test thoroughly: Unit tests, integration tests, evaluation suites
  7. Document extensively: API docs, architecture diagrams, runbooks
  8. Version control state: Use checkpointers for reproducibility

Build production-ready, scalable, and observable LangChain agents following these patterns.

More skills from rmyndharis

wcag-audit-patterns logo
rmyndharis/antigravity-skills

wcag-audit-patterns

Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fixing WCAG violations, or implementing accessible design patterns.

1.7K 1
View
c4-code logo
rmyndharis/antigravity-skills

c4-code

Expert C4 Code-level documentation specialist. Analyzes code

1.7K 0
View
documentation-generation-doc-generate logo
rmyndharis/antigravity-skills

documentation-generation-doc-generate

You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user guides, and technical references using AI-powered analysis and industry best practices.

1.7K 0
View
sales-automator logo
rmyndharis/antigravity-skills

sales-automator

Draft cold emails, follow-ups, and proposal templates. Creates

1.7K 0
View
team-collaboration-standup-notes logo
rmyndharis/antigravity-skills

team-collaboration-standup-notes

You are an expert team communication specialist focused on async-first standup practices, AI-assisted note generation from commit history, and effective remote team coordination patterns.

1.7K 0
View
turborepo-caching logo
rmyndharis/antigravity-skills

turborepo-caching

Configure Turborepo for efficient monorepo builds with local and remote caching. Use when setting up Turborepo, optimizing build pipelines, or implementing distributed caching.

1.7K 0
View
ml-pipeline-workflow logo
rmyndharis/antigravity-skills

ml-pipeline-workflow

Build end-to-end MLOps pipelines from data preparation through model training, validation, and production deployment. Use when creating ML pipelines, implementing MLOps practices, or automating model training and deployment workflows.

1.7K 0
View
search-specialist logo
rmyndharis/antigravity-skills

search-specialist

Expert web researcher using advanced search techniques and

1.7K 0
View
payment-integration logo
rmyndharis/antigravity-skills

payment-integration

Integrate Stripe, PayPal, and payment processors. Handles checkout

1.7K 0
View
workflow-patterns logo
rmyndharis/antigravity-skills

workflow-patterns

Use this skill when implementing tasks according to Conductor's TDD

1.7K 0
View

Popular AI tools

Kaiber logo
Video

Kaiber

Generate, edit, and beat-sync AI video with leading models in one workspace.

Paid
View
Vimcal logo
Productivity

Vimcal

The world's fastest calendar for remote work

Free
View

Transform Your Design with AI Designer by ImgCreator.ai

Freemium
View
Akool AI logo
Content & writing

Akool AI

Revolutionizing Video Production with AI-Powered Creativity

Paid
View

Extend an image past the frame and let AI fill the new aspect ratio.

Freemium
View
StarByFace logo
Security

StarByFace

Discover your celebrity doppelgänger with StarByFace!

Free
View
C

ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.

Freemium
View
Opus Clip logo
Coding & apps

Opus Clip

Opus.ai: Revolutionize Your Web Experience

Free
View