PaperclipOrg
Claude Agent Skill · by Sickn33

Langgraph

Install Langgraph skill for Claude Code from sickn33/antigravity-awesome-skills.

Install
Terminal · npx
$npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill langgraph
Works with Paperclip

How Langgraph fits into a Paperclip company.

Langgraph drops into any Paperclip agent that handles this kind of work. Assign it to a specialist inside a pre-configured PaperclipOrg company and the skill becomes available on every heartbeat — no prompt engineering, no tool wiring.

S
SaaS FactoryPaired

Pre-configured AI company — 18 agents, 18 skills, one-time purchase.

$27$59
Explore pack
Source file
SKILL.md505 lines
Expand
---name: langgraphdescription: Expert in LangGraph - the production-grade framework for building  stateful, multi-actor AI applications. Covers graph construction, state  management, cycles and branches, persistence with checkpointers,  human-in-the-loop patterns, and the ReAct agent pattern.risk: unknownsource: vibeship-spawner-skills (Apache 2.0)date_added: 2026-02-27--- # LangGraph Expert in LangGraph - the production-grade framework for building stateful, multi-actorAI applications. Covers graph construction, state management, cycles and branches,persistence with checkpointers, human-in-the-loop patterns, and the ReAct agent pattern.Used in production at LinkedIn, Uber, and 400+ companies. This is LangChain's recommendedapproach for building agents. **Role**: LangGraph Agent Architect You are an expert in building production-grade AI agents with LangGraph. Youunderstand that agents need explicit structure - graphs make the flow visibleand debuggable. You design state carefully, use reducers appropriately, andalways consider persistence for production. You know when cycles are neededand how to prevent infinite loops. ### Expertise - Graph topology design- State schema patterns- Conditional branching- Persistence strategies- Human-in-the-loop- Tool integration- Error handling and recovery ## Capabilities - Graph construction (StateGraph)- State management and reducers- Node and edge definitions- Conditional routing- Checkpointers and persistence- Human-in-the-loop patterns- Tool integration- Streaming and async execution ## Prerequisites - 0: Python proficiency- 1: LLM API basics- 2: Async programming concepts- 3: Graph theory fundamentals- Required skills: Python 3.9+, langgraph package, LLM API access (OpenAI, Anthropic, etc.), Understanding of graph concepts ## Scope - 0: Python-only (TypeScript in early stages)- 1: Learning curve for graph concepts- 2: State management complexity- 3: Debugging can be challenging ## Ecosystem ### Primary - LangGraph- LangChain- LangSmith (observability) ### Common_integrations - OpenAI / Anthropic / Google- Tavily (search)- SQLite / PostgreSQL (persistence)- Redis (state store) ### Platforms - Python applications- FastAPI / Flask backends- Cloud deployments ## Patterns ### Basic Agent Graph Simple ReAct-style agent with tools **When to use**: Single agent with tool calling from typing import Annotated, TypedDictfrom langgraph.graph import StateGraph, START, ENDfrom langgraph.graph.message import add_messagesfrom langgraph.prebuilt import ToolNodefrom langchain_openai import ChatOpenAIfrom langchain_core.tools import tool # 1. Define Stateclass AgentState(TypedDict):    messages: Annotated[list, add_messages]    # add_messages reducer appends, doesn't overwrite # 2. Define Tools@tooldef search(query: str) -> str:    """Search the web for information."""    # Implementation here    return f"Results for: {query}" @tooldef calculator(expression: str) -> str:    """Evaluate a math expression."""    return str(eval(expression)) tools = [search, calculator] # 3. Create LLM with toolsllm = ChatOpenAI(model="gpt-4o").bind_tools(tools) # 4. Define Nodesdef agent(state: AgentState) -> dict:    """The agent node - calls LLM."""    response = llm.invoke(state["messages"])    return {"messages": [response]} # Tool node handles tool executiontool_node = ToolNode(tools) # 5. Define Routingdef should_continue(state: AgentState) -> str:    """Route based on whether tools were called."""    last_message = state["messages"][-1]    if last_message.tool_calls:        return "tools"    return END # 6. Build Graphgraph = StateGraph(AgentState) # Add nodesgraph.add_node("agent", agent)graph.add_node("tools", tool_node) # Add edgesgraph.add_edge(START, "agent")graph.add_conditional_edges("agent", should_continue, ["tools", END])graph.add_edge("tools", "agent")  # Loop back # Compileapp = graph.compile() # 7. Runresult = app.invoke({    "messages": [("user", "What is 25 * 4?")]}) ### State with Reducers Complex state management with custom reducers **When to use**: Multiple agents updating shared state from typing import Annotated, TypedDictfrom operator import addfrom langgraph.graph import StateGraph # Custom reducer for merging dictionariesdef merge_dicts(left: dict, right: dict) -> dict:    return {**left, **right} # State with multiple reducersclass ResearchState(TypedDict):    # Messages append (don't overwrite)    messages: Annotated[list, add_messages]     # Research findings merge    findings: Annotated[dict, merge_dicts]     # Sources accumulate    sources: Annotated[list[str], add]     # Current step (overwrites - no reducer)    current_step: str     # Error count (custom reducer)    errors: Annotated[int, lambda a, b: a + b] # Nodes return partial state updatesdef researcher(state: ResearchState) -> dict:    # Only return fields being updated    return {        "findings": {"topic_a": "New finding"},        "sources": ["source1.com"],        "current_step": "researching"    } def writer(state: ResearchState) -> dict:    # Access accumulated state    all_findings = state["findings"]    all_sources = state["sources"]     return {        "messages": [("assistant", f"Report based on {len(all_sources)} sources")],        "current_step": "writing"    } # Build graphgraph = StateGraph(ResearchState)graph.add_node("researcher", researcher)graph.add_node("writer", writer)# ... add edges ### Conditional Branching Route to different paths based on state **When to use**: Multiple possible workflows from langgraph.graph import StateGraph, START, END class RouterState(TypedDict):    query: str    query_type: str    result: str def classifier(state: RouterState) -> dict:    """Classify the query type."""    query = state["query"].lower()    if "code" in query or "program" in query:        return {"query_type": "coding"}    elif "search" in query or "find" in query:        return {"query_type": "search"}    else:        return {"query_type": "chat"} def coding_agent(state: RouterState) -> dict:    return {"result": "Here's your code..."} def search_agent(state: RouterState) -> dict:    return {"result": "Search results..."} def chat_agent(state: RouterState) -> dict:    return {"result": "Let me help..."} # Routing functiondef route_query(state: RouterState) -> str:    """Route to appropriate agent."""    query_type = state["query_type"]    return query_type  # Returns node name # Build graphgraph = StateGraph(RouterState) graph.add_node("classifier", classifier)graph.add_node("coding", coding_agent)graph.add_node("search", search_agent)graph.add_node("chat", chat_agent) graph.add_edge(START, "classifier") # Conditional edges from classifiergraph.add_conditional_edges(    "classifier",    route_query,    {        "coding": "coding",        "search": "search",        "chat": "chat"    }) # All agents lead to ENDgraph.add_edge("coding", END)graph.add_edge("search", END)graph.add_edge("chat", END) app = graph.compile() ### Persistence with Checkpointer Save and resume agent state **When to use**: Multi-turn conversations, long-running agents from langgraph.graph import StateGraphfrom langgraph.checkpoint.sqlite import SqliteSaverfrom langgraph.checkpoint.postgres import PostgresSaver # SQLite for developmentmemory = SqliteSaver.from_conn_string(":memory:")# Or persistent filememory = SqliteSaver.from_conn_string("agent_state.db") # PostgreSQL for production# memory = PostgresSaver.from_conn_string(DATABASE_URL) # Compile with checkpointerapp = graph.compile(checkpointer=memory) # Run with thread_id for conversation continuityconfig = {"configurable": {"thread_id": "user-123-session-1"}} # First messageresult1 = app.invoke(    {"messages": [("user", "My name is Alice")]},    config=config) # Second message - agent remembers contextresult2 = app.invoke(    {"messages": [("user", "What's my name?")]},    config=config)# Agent knows name is Alice! # Get conversation historystate = app.get_state(config)print(state.values["messages"]) # List all checkpointsfor checkpoint in app.get_state_history(config):    print(checkpoint.config, checkpoint.values) ### Human-in-the-Loop Pause for human approval before actions **When to use**: Sensitive operations, review before execution from langgraph.graph import StateGraph, START, END class ApprovalState(TypedDict):    messages: Annotated[list, add_messages]    pending_action: dict | None    approved: bool def agent(state: ApprovalState) -> dict:    # Agent decides on action    action = {"type": "send_email", "to": "user@example.com"}    return {        "pending_action": action,        "messages": [("assistant", f"I want to: {action}")]    } def execute_action(state: ApprovalState) -> dict:    action = state["pending_action"]    # Execute the approved action    result = f"Executed: {action['type']}"    return {        "messages": [("assistant", result)],        "pending_action": None    } def should_execute(state: ApprovalState) -> str:    if state.get("approved"):        return "execute"    return END  # Wait for approval # Build graphgraph = StateGraph(ApprovalState)graph.add_node("agent", agent)graph.add_node("execute", execute_action) graph.add_edge(START, "agent")graph.add_conditional_edges("agent", should_execute, ["execute", END])graph.add_edge("execute", END) # Compile with interrupt_before for human reviewapp = graph.compile(    checkpointer=memory,    interrupt_before=["execute"]  # Pause before execution) # Run until interruptconfig = {"configurable": {"thread_id": "approval-flow"}}result = app.invoke({"messages": [("user", "Send report")]}, config) # Agent paused - get pending statestate = app.get_state(config)pending = state.values["pending_action"]print(f"Pending: {pending}")  # Human reviews # Human approves - update state and continueapp.update_state(config, {"approved": True})result = app.invoke(None, config)  # Resume ### Parallel Execution (Map-Reduce) Run multiple branches in parallel **When to use**: Parallel research, batch processing from langgraph.graph import StateGraph, START, END, Sendfrom langgraph.constants import Send class ParallelState(TypedDict):    topics: list[str]    results: Annotated[list[str], add]    summary: str def research_topic(state: dict) -> dict:    """Research a single topic."""    topic = state["topic"]    result = f"Research on {topic}..."    return {"results": [result]} def summarize(state: ParallelState) -> dict:    """Combine all research results."""    all_results = state["results"]    summary = f"Summary of {len(all_results)} topics"    return {"summary": summary} def fanout_topics(state: ParallelState) -> list[Send]:    """Create parallel tasks for each topic."""    return [        Send("research", {"topic": topic})        for topic in state["topics"]    ] # Build graphgraph = StateGraph(ParallelState)graph.add_node("research", research_topic)graph.add_node("summarize", summarize) # Fan out to parallel researchgraph.add_conditional_edges(START, fanout_topics, ["research"])# All research nodes lead to summarizegraph.add_edge("research", "summarize")graph.add_edge("summarize", END) app = graph.compile() result = app.invoke({    "topics": ["AI", "Climate", "Space"],    "results": []})# Research runs in parallel, then summarizes ## Collaboration ### Delegation Triggers - crewai|role-based|crew -> crewai (Need role-based multi-agent approach)- observability|tracing|langsmith -> langfuse (Need LLM observability)- structured output|json schema -> structured-output (Need structured LLM responses)- evaluate|benchmark|test agent -> agent-evaluation (Need to evaluate agent performance) ### Production Agent Stack Skills: langgraph, langfuse, structured-output Workflow: ```1. Design agent graph with LangGraph2. Add structured outputs for tool responses3. Integrate Langfuse for observability4. Test and monitor in production``` ### Multi-Agent System Skills: langgraph, crewai, agent-communication Workflow: ```1. Design agent roles (CrewAI patterns)2. Implement as LangGraph with subgraphs3. Add inter-agent communication4. Orchestrate with supervisor pattern``` ### Evaluated Agent Skills: langgraph, agent-evaluation, langfuse Workflow: ```1. Build agent with LangGraph2. Create evaluation suite3. Monitor with Langfuse4. Iterate based on metrics``` ## Related Skills Works well with: `crewai`, `autonomous-agents`, `langfuse`, `structured-output` ## When to Use- User mentions or implies: langgraph- User mentions or implies: langchain agent- User mentions or implies: stateful agent- User mentions or implies: agent graph- User mentions or implies: react agent- User mentions or implies: agent workflow- User mentions or implies: multi-step agent ## Limitations- Use this skill only when the task clearly matches the scope described above.- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.