Przejdź do treści
Biblioteka skilli
AI i agenci · Budowanie i kod

langgraph

/langgraph

Buduje wieloagentowe systemy AI w LangGraph: wzorce supervisor, swarm i hierarchiczne, podgrafy, zarządzanie stanem, persystencję, ewaluacje i debugowanie produkcyjne.

Repozytorium
agent-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
17
Skrypty
6
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 6 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: assets/templates/subgraph-agent.py, assets/templates/supervisor-graph.py, assets/templates/swarm-graph.py, scripts/lg-eval-generator.py, scripts/lg-supervisor-scaffold.py, scripts/lg-swarm-scaffold.py

Co robi i kiedy

Buduje wieloagentowe systemy AI w LangGraph: wzorce supervisor, swarm i hierarchiczne, podgrafy, zarządzanie stanem, persystencję, ewaluacje i debugowanie produkcyjne.

Oryginalny opis (EN)

Build multi-agent AI systems with LangGraph — the low-level orchestration framework for stateful, graph-based agent workflows. Covers supervisor, swarm, and hierarchical multi-agent patterns; subgraph composition; state management (checkpointers/stores); persistence; evals; and production debugging. Reach for this when designing agent architectures that need cycles, conditional branching, parallel execution, or human-in-the-loop patterns. Do not use this skill for unrelated requests; route to the nearest named specialist.

Jak działa

  1. Quick Start
  2. When to Reach For This
  3. Pattern Selection Guide
  4. Choosing Your Starting Point
  5. Core Primitives
  6. Key Gotchas
  7. Reference Files
  8. Scripts
Sekcje z nagłówków SKILL.md, w oryginale · 126 linii, 1 386 słów
Podgląd SKILL.md
---
name: langgraph
description: >-
  Build multi-agent AI systems with LangGraph — the low-level orchestration framework for
  stateful, graph-based agent workflows. Covers supervisor, swarm, and hierarchical
  multi-agent patterns; subgraph composition; state management (checkpointers/stores);
  persistence; evals; and production debugging. Reach for this when designing agent
  architectures that need cycles, conditional branching, parallel execution, or
  human-in-the-loop patterns. Do not use this skill for unrelated requests; route to the
  nearest named specialist.
license: MIT
metadata:
  source: LangGraph by LangChain Inc — https://langchain.com/langgraph
  spec-version: '1.0'
  version: 1.0.2
---

# LangGraph

LangGraph is LangChain's low-level orchestration framework for building stateful, long-running, multi-agent AI workflows using directed graph architectures (inspired by Pregel/Beam and NetworkX). It models agents as **nodes** in a graph, with **edges** controlling flow — enabling cycles, conditional branching, parallel execution, human-in-the-loop, and subgraph composition that linear chains cannot express.

This skill covers all major patterns for building and deploying LangGraph systems: core graph architecture, the three canonical multi-agent patterns (supervisor, swarm, hierarchical), persistence and state management, production debugging, and evaluation methodology.

> **Before you begin:** Install dependencies:
> ```bash
> pip install langgraph langchain langchain-openai langsmith
> ```

## Quick Start

Create your first LangGraph agent in under 10 lines:

```python
from langgraph.graph import StateGraph, MessagesState, START, END

def hello_agent(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "Hello, world!"}]}

graph = StateGraph(MessagesState)
graph.add_node("agent", hello_agent)
graph.add_edge(START, "agent")
graph.add_edge("agent", END)
graph = graph.compile()

graph.invoke({"messages": [{"role": "user", "content": "hi!"}]})
```

**Next steps:**
1. Use the **Pattern Selection Guide** below to choose supervisor, swarm, or hierarchical architecture — each pattern links to its recommended template
2. Load the corresponding reference file for the deep pattern walkthrough
3. Use the **Choosing Your Starting Point** table below to pick scaffold, template, or reference based on your task
4. For a complete runnable example matching your pattern, use the linked template in assets/templates/

> **Design Principles — These Govern Every Graph Decision**
> 1. **State is the source of truth** — all inter-node communication happens through state, not through side channels or global variables.
> 2. **Nodes are pure-ish** — a node receives state, does work, returns updates. It should not depend on state that isn't passed to it.
> 3. **Reducers prevent conflicts** — any state key written by multiple nodes in parallel MUST have a reducer.
> 4. **Start simple** — a single agent with good prompts beats a multi-agent system with bad routing. Add agents only when a single prompt or toolset becomes unwieldy.
> 5. **Use `Send()` for dynamic fan-out** — when you don't know how many workers you'll need at compile time, spawn them dynamically from the orchestrator node.
> 6. **Subgraph state isolation** — subgraphs with different state schemas need a wrapper function to transform state at the boundary. Shared-schema subgraphs can be added directly as nodes.

## When to Reach For This

| Context | What to load |
|---------|-------------|
| Building a new LangGraph workflow from scratch | `references/architecture.md` — core concepts first |
| Designing a multi-agent routing system | `references/multi-agent-supervisor.md` or `references/multi-agent-swarm.md` — compare patterns |
| Composing nested agent teams | `references/multi-agent-hierarchical.md` — subgraph composition |
| Adding persistence, interrupts, or long-term memory | `references/persistence.md` — checkpointers and stores |
| Deploying to production or debugging failures | `references/production.md` — deployment, observability, failure modes |
| Setting up eval pipelines for routing accuracy | `references/evals.md` — evaluation methodology |
| Diagnosing a specific failure (loop, context loss, crash) | `references/troubleshooting.md` — known failure modes |
| Placing a typed System One judgment in a graph | `references/architecture.md`; decision contract and calibration in [System One](../system-one/SKILL.md), workflow authority and whole-task evidence in [harness-engineering](../harness-engineering/SKILL.md) |

## Pattern Selection Guide

| Your constraint | Prefer | Why |
|----------------|--------|-----|
| Routing accuracy > latency | **Supervisor** | Centralized routing node, focused prompt: ~94% accuracy | `assets/templates/supervisor-graph.py` |
| Latency is primary constraint | **Swarm** | Direct agent-to-agent handoffs, ~40% fewer LLM calls | `assets/templates/swarm-graph.py` |
| Clear domain boundaries | **Swarm** | Agents rarely misroute, handoffs are crisp | `assets/templates/swarm-graph.py` |
| Ambiguous domain boundaries | **Supervisor** | Overlapping concerns resolved by dedicated router | `assets/templates/supervisor-graph.py` |
| < 3 distinct domains | **Skip multi-agent** | A specialized single agent is simpler | `references/architecture.md` |
| Multi-domain requests common | **Swarm** | Latency savings compound across handoffs | `assets/templates/swarm-graph.py` |
| Need centralized audit trail | **Supervisor** | Every routing decision visible in traces | `assets/templates/supervisor-graph.py` |
| Nested team structures | **Hierarchical** | Subgraphs as nodes, each team self-contained | `assets/templates/subgraph-agent.py` |

## Choosing Your Starting Point

| Your goal | Start with | Why |
|----------|------------|-----|
| Build a project from scratch, need generated code | `scripts/lg-supervisor-scaffold.py` or `scripts/lg-swarm-scaffold.py` | Scaffolds generate complete project structure (state.py, agents.py, graph.py) with placeholders to fill in |
| Understand a complete, working example | `assets/templates/` matching your chosen pattern | Templates are self-contained runnable files with all patterns wired — best for learning by reading |
| Deep dive into a pattern's internals | Corresponding reference in `references/` | References explain tradeoffs, failure modes, and design rationale — best for customization |
| Debug or optimize an existing system | `references/production.md` or `references/troubleshooting.md` | Production reference covers deployment + observability; troubleshooting reference covers symptom→fix tables |

## Core Primitives

LangGraph uses two APIs:

| API | When to use | Pattern |
|-----|-------------|---------|
| **Graph API** (`StateGraph`) | Full control over graph structure, conditional edges, subgraphs | `add_node()` + `add_edge()`/`add_conditional_edges()` |
| **Functional API** (`@task` + `@entrypoint`) | Simpler linear workflows, less boilerplate | Decorator-based, Pythonic |

Both APIs produce the same compiled graph — choose based on how much control you need.

## Key Gotchas

- **Subgraph persistence defaults to per-invocation** — each subgraph call starts fresh. Set `checkpointer=True` for per-thread memory, `checkpointer=False` for fully stateless.
- **Per-thread subgraphs cannot run in parallel** — same-namespace checkpoint conflicts. Use `ToolCallLimitMiddleware` or disable parallel tool calls.
- **The supervisor bottleneck** — every interaction requires a routing LLM call, even for obvious intents. Add a fast-path classifier (keyword matching or small model) for unambiguous requests.
- **Swarm ping-pong** — no natural recursion guard. Track `handoff_count` in state and hard-limit at 3, then escalate to human or fallback agent.
- **Lost messages on handoff** — `Command.update` must include paired messages from the specialist's tool-calling loop, or the next agent sees malformed history.
- **State access from parent to subgraph** — subgraphs manage their own checkpoint namespace. Use Store for cross-graph-boundary data.
- **Checkpoint bloat** — long conversations accumulate checkpoints. Prune periodically or set retention policies on DB-backed checkpointers.
- **No auto-load-on-install** — skills aren't auto-discovered at session start by name mention. The agent must explicitly call `skill_view(name='langgraph')` to load this skill.

## Reference Files

| File | Load when |
|------|-----------|
| `references/architecture.md` | You need to understand LangGraph core concepts: graph structure, nodes, edges, state, the two APIs, and basic agent loop construction. Read this first if you're new to LangGraph. |
| `references/multi-agent-supervisor.md` | You're designing a supervisor-based multi-agent system with a central routing node. Contains architecture, structured output routing, specialist wrappers, and full code examples. |
| `references/multi-agent-swarm.md` | You're designing a swarm-based multi-agent system with direct agent-to-agent handoffs. Contains handoff tool patterns, Command-based routing, and comparative metrics vs supervisor. |
| `references/multi-agent-hierarchical.md` | You're composing nested agent teams using subgraphs. Covers subgraph wiring (shared vs different state schemas), persistence modes, namespace isolation, and hierarchical team structures. |
| `references/persistence.md` | You're adding checkpointer-based short-term memory or store-based long-term memory. Covers per-invocation vs per-thread vs stateless modes, checkpoint backends, and cross-thread memory patterns. |
| `references/production.md` | You're deploying a LangGraph system to production. Covers Agent Server deployment, LangSmith observability, streaming patterns, and common production failure modes with fixes. |
| `references/evals.md` | You're setting up evaluation pipelines for multi-agent systems. Covers routing accuracy, resolution coverage, LangSmith eval datasets, and LLM-as-judge evaluators. |
| `references/troubleshooting.md` | You're debugging a specific LangGraph failure. Covers routing loops, context loss, checkpointer conflicts, token waste, and state inspection techniques. |
| `assets/templates/supervisor-graph.py` | Runnable supervisor example with billing, tech support, and account specialists — fast-path classifier, structured output routing, audit trail, and recursion guard. |
| `assets/templates/swarm-graph.py` | Runnable swarm example with triage agent plus 3 specialists — direct agent-to-agent handoffs via Command, recursion guard, and full traceability. |
| `assets/templates/subgraph-agent.py` | Runnable subgraph composition examples — all 3 wiring patterns (different state schemas, shared state keys, per-thread with namespace isolation). |

## Scripts

| Script | What it does |
|--------|-------------|
| `scripts/lg-supervisor-scaffold.py` | Generates a complete supervisor pattern project with state schema, routing agent, specialist nodes, and graph assembly |
| `scripts/lg-swarm-scaffold.py` | Generates a complete swarm pattern project with handoff tools, triage agent, specialist agents, and conditional routing |
| `scripts/lg-eval-generator.py` | Generates evaluation datasets and runs LangSmith evaluators for routing accuracy and resolution coverage |
Pliki w paczce (17)
  • README.md 2 KB
  • SKILL.md 11 KB
  • assets/templates/subgraph-agent.py 8 KB
  • assets/templates/supervisor-graph.py 10 KB
  • assets/templates/swarm-graph.py 10 KB
  • evals/evals.json 10 KB
  • references/architecture.md 10 KB
  • references/evals.md 6 KB
  • references/multi-agent-hierarchical.md 9 KB
  • references/multi-agent-supervisor.md 7 KB
  • references/multi-agent-swarm.md 9 KB
  • references/persistence.md 4 KB
  • references/production.md 6 KB
  • references/troubleshooting.md 6 KB
  • scripts/lg-eval-generator.py 14 KB
  • scripts/lg-supervisor-scaffold.py 10 KB
  • scripts/lg-swarm-scaffold.py 9 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · magnus919/agent-skills100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
TerminalSkills/skills100Apache-2.0
davila7/claude-code-templates100MIT
langchain-ai/docs100MIT
Aadarsh-x54/deep-agents-with-langchain100MIT
bcastelino/agent-skills-kit100MIT
MARUCIE/openclaw-foundry100MIT

Migawka bazy z 13.11.2026 · wersja paczki a207b90a3cd5 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 2 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100building-langgraph-agents
    Wspiera rozwój w LangGraph dla stanowych aplikacji wieloagentowych: przepływy cykliczne, routing warunkowy, wzorce human-in-the-loop i trwałe zarządzanie stanem w złożonej orkiestracji AI.
  • 100langgraph-workflows
    Buduje przepływy agentów jako maszyny stanów w LangGraph 1.0: węzły, krawędzie warunkowe i wzorzec ReAct.
  • 100langgraph-stateful-agent-graphs
    Projektuje cykliczne, stanowe i odporne na awarie architektury wieloagentowe z checkpointami w LangGraph.
  • 100langgraph-patterns
    Dostarcza produkcyjne wzorce agentowych przepływów w LangGraph: orkiestracja grafów, maszyny stanów, udział człowieka i sterowanie przepływem, w tym punkty kontrolne i zatwierdzenia.
  • 100langgraph-agents
    Tworzy stanowych agentów AI w LangGraph z przepływami opartymi na grafach: punkty kontrolne, udział człowieka, streaming wykonania i kompozycja podgrafów.
  • 100langchain-and-langgraph-agent-orchestration
    Prowadzi budowę aplikacji LLM z łańcuchami i agentami LangChain oraz stanowych wieloetapowych agentów w LangGraph: węzły, krawędzie, cykle, trwałość z checkpointami i przerwania human-in-the-loop.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.