llm-application-dev-langchain-agent

rmyndharis/antigravity-skillsCoding AgentsAudit pendingSnapshot ac092550f90e

Summary

This source did not publish a separate summary. Review SKILL.md before using the skill.

SKILL.md

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: (code), (finance), (legal)

voyage-code-3

voyage-finance-2

voyage-law-2

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}
)

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
)

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": [...]})

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
)

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 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

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

llm-application-dev-langchain-agent

Summary

SKILL.md

LangChain/LangGraph Agent Development Expert

Use this skill when

Do not use this skill when

Instructions

Context

Core Requirements

Essential Architecture

LangGraph State Management

Model & Embeddings

Agent Types

Memory Systems

RAG Pipeline

Advanced RAG Patterns

Tools & Integration

Production Deployment

FastAPI Server with Streaming

Monitoring & Observability

Optimization Strategies

Testing & Evaluation

Key Patterns

State Graph Pattern

Async Pattern

Error Handling Pattern

Implementation Checklist

Best Practices

Related skills