LangGraph Multi-Agent

What this skill does

Build, review, and modernize production-grade multi-agent systems with LangGraph/LangChain while staying version-accurate by default: always resolve the current APIs from docs + installed versions, and fall back to

opensrc/

source snapshots for under-the-hood edge cases.

Default operating rules (do these every time)

1. Treat all LangGraph/LangChain APIs as versioned; never “code from memory” for any API surface that might have changed.
2. Establish ground truth before coding:
   • Determine installed/pinned versions (repo lockfiles +

     importlib.metadata

     ).
   • Query official docs via

     langchain-docs.SearchDocsByLangChain

     .
   • Use Context7 for canonical API references and examples.
3. When docs are ambiguous or behavior is subtle, inspect dependency internals via

   opensrc/

   (read-only):
   • Run

     npx opensrc pypi:<package>@<version> --modify=false

   • Check

     opensrc/sources.json

     and cite exact

     opensrc/...

     paths + versions in your writeup.

Use

references/research_playbook.md

when you need a rigorous doc-sweep, including

llms.txt

-driven crawling of LangGraph docs.

Workflow decision tree

• Build something new → follow Build workflow.
• Audit/deprecations/migration → follow Audit & migrate workflow.
• Latency/cost/scale issues → follow Performance & scale workflow.

Quick start (repo-aware)

1. Generate a deprecations + framework audit report:
   • Run

     python scripts/audit_repo_agents.py --root .

     (from the skill folder)
   • Optional:

     python scripts/audit_repo_agents.py --root . --json agent_audit.json

   • Optional:

     python scripts/generate_migration_plan.py --audit-json agent_audit.json --out migration_plan.md

2. If you need “latest docs” for a specific area, start with:

   • langchain-docs.SearchDocsByLangChain

     using queries from

     references/docs_index.md

3. If you hit a behavior edge case, snapshot internals:
   • Run

     python scripts/opensrc_snapshot.py --packages langgraph langchain langchain-core

     (from the skill folder)
4. If you need a doc sitemap for LangGraph (for agentic RAG or doc crawling):
   • Run

     python scripts/fetch_llms_txt_urls.py --print --unique

     (from the skill folder)
5. If you need to build an offline docs cache (bounded crawl):
   • Use seeds in

     references/doc_crawl_targets.md

   • Run

     python scripts/crawl_docs.py --llms-txt https://langchain-ai.github.io/langgraph/llms.txt --allow-prefixes https://langchain-ai.github.io/langgraph/ --out-dir docs_cache_langgraph

     (from the skill folder)

Reference map (use these, don’t guess)

• references/langchain_create_agent_middleware.md

  :

  create_agent

  + middleware hooks + migration mappings.

• references/langchain_multiagent_handoffs.md

  : choosing between subagents vs handoffs vs multi-node subgraphs.

• references/langgraph_graph_api_primitives.md

  : reducers, Send API, subgraphs, and common error codes.

• references/memory_and_context_engineering.md

  : state vs store vs runtime context; memory design.

• references/mcp_integration_patterns.md

  : MCP client/interceptors and ToolRuntime-driven auth/DI.

• references/testing_evaluation.md

  : tests + eval strategy for safe migrations.

• references/deployment_agent_server.md

  :

  langgraph.json

  and Agent Server deployment basics.

• references/security_threat_model.md

  : threat model + mitigations for tool calling systems.

• references/upgrades_and_versioning.md

  : repeatable upgrade process.

• references/audit_and_migration_methodology.md

  : end-to-end audit→plan→execute methodology.

• references/api_map_python.md

  : import-path cheat sheet (verify for your version).

• references/ui_nextjs_rsc.md

  : Next.js App Router (RSC) + React UI integration (Agent Server +

  useStream

  ).

• references/ui_nextjs_ai_sdk.md

  : Next.js App Router using AI SDK v6 (

  useChat

  ) + Streamdown (alternative UI stack).

• references/ui_fastapi_backend.md

  : FastAPI backend patterns for in-process agents or Agent Server BFF/proxy.

• references/ui_streaming_protocol.md

  : simple SSE event protocol for custom UI backends.

• references/ui_streamlit.md

  : Streamlit UI integration patterns (streaming + HITL).

Build workflow (LangChain v1 + LangGraph v1+)

1. Select the right multi-agent topology (start simple):
   • Supervisor + subagents (tool-calling): a main “supervisor” calls subagents as tools for context isolation.
   • Orchestrator-worker (fan-out): use LangGraph’s worker primitives (e.g., Send-style fanout) for parallelizable tasks; use reducers to avoid concurrent state-update errors.
   • Deterministic workflow + agent nodes: keep control-flow explicit; use agents only where needed.
2. Define strict tool schemas and failure behavior:
   • Make tools idempotent where possible; add timeouts and retries; “fail open” on non-critical model/rerank steps.
3. Do context engineering explicitly:
   • Use typed state for dynamic runtime context; keep “store” for long-term memory; use runtime context injection for user/org-scoped dependencies.
4. Add safety controls early:
   • Use middleware guardrails and human-in-the-loop for high-stakes tools (payments, outbound emails, destructive actions).
5. Add observability before scaling:
   • Enable tracing (LangSmith/OpenTelemetry), record tool latency/cost, and add regression evaluations.

Use

references/patterns.md

for design templates and “gotchas” per topology.

Audit & migrate workflow (deprecated patterns → modern stack)

1. Inventory current architecture (dependencies + imports + runtime behavior):
   • Run

     scripts/audit_repo_agents.py

     and expand it with repo-specific patterns if needed.
2. Identify deprecated patterns and their replacements using official docs:
   • Prioritize the LangGraph v1 and LangChain v1 migration guides.
   • Verify whether

     langgraph.prebuilt.create_react_agent

     usage should move to

     langchain.agents.create_agent

     .
3. Plan the migration in slices (keep it shippable):
   • Preserve external behavior; migrate internals; then upgrade prompts/tools; finally tighten types and add tests.
4. Execute migration and harden:
   • Replace legacy agent frameworks (LlamaIndex agents, CrewAI, Agno, OpenAI Agents) with LangGraph/LangChain equivalents.
   • Add offline tests with fixtures/mocks, and add trace-based regression checks when possible.

Use

references/migration_supervisor.md

and

references/migration_other_frameworks.md

for playbooks.

Performance & scale workflow

1. Add measurement first:
   • Capture per-node latency, token usage, tool call counts, cache hit rates, and error taxonomy.
2. Apply the “cheapest win” stack in order:
   • Reduce context size (summaries, retrieval, subagent isolation).
   • Cache tool results (deterministic and keyed); add request coalescing.
   • Parallelize only where state updates are safe (reducers, fanout collection keys).
   • Use smaller/faster models for routing/validation; reserve larger models for synthesis.
3. Constrain worst-case behavior:
   • Recursion limits, max steps, max tool calls, and circuit breakers for flaky dependencies.

Use

references/performance_cost.md

for checklists and tactics.

Bundled resources in this skill

• scripts/

  : deterministic helpers (audits,

  llms.txt

  extraction,

  opensrc

  snapshot runner)

• references/

  : playbooks + templates for docs research, patterns, migrations, safety, observability, and performance

• assets/

  : copy/paste templates for Python + UI integrations (Next.js, FastAPI, Streamlit)

Start with

references/docs_index.md

and

references/research_playbook.md

.