SkillAgentSearch skills...

llm-application-dev-langchain-agent

Build production-grade AI agents with LangChain and LangGraph

Install / Use

npx skills add rmyndharis/antigravity-skills --skill llm-application-dev-langchain-agent

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

85/100

Category

Automation

Supported Platforms

Universal

Our assessment of llm-application-dev-langchain-agent

llm-application-dev-langchain-agent scores 85/100 on our quality scale, 1947th of 2,790 Automation skills we index.

Its SKILL.md is 7.5 KB long, well organised into 29 sections with 8 code examples: a thorough specification that gives an agent plenty to work with.

With 1,621 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
12/15
Adoption
14/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-10-04 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-03. Automated pattern scan on 2026-10-03. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

llm-application-dev-langchain-agent compared with similar skills

All 4 of these similar skills score higher than llm-application-dev-langchain-agent; compare them before choosing.

SkillScoreStarsUpdatedFormat
llm-application-dev-langchain-agent (this skill)by rmyndharis851.6k4mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md

Frequently asked questions

How do I install llm-application-dev-langchain-agent?
Run npx skills add rmyndharis/antigravity-skills --skill llm-application-dev-langchain-agent. The install tabs above show the steps for each supported agent.
Which AI agents does llm-application-dev-langchain-agent work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is llm-application-dev-langchain-agent safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is llm-application-dev-langchain-agent still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: llm-application-dev-langchain-agent description: "You are an expert LangChain agent developer specializing in production-grade AI systems using LangChain 0.1+ and LangGraph."

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.

Related Skills

View on GitHub
GitHub Stars1.6k
CategoryAutomation
Updated3mo ago
Forks268

Languages

JavaScript

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info
llm-application-dev-langchain-agent — Universal Skill: Install & Safety Check | SkillAgent