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

langgraph-patterns

/langgraph-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.

Licencja
MIT
Ostatnia zmiana repozytorium
26.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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
3
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.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 robi i kiedy

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.

Oryginalny opis (EN)

Production-grade agentic workflows with LangGraph — graph orchestration, state machines, human-in-the-loop, and advanced control flow. Use when building or debugging a LangGraph app, modeling agent state, or adding checkpoints and human approval steps.

Jak działa

  1. Purpose
  2. Core Philosophy
  3. The Six Production Features
  4. Graph-Based Architecture
  5. Core Patterns
  6. State Management
  7. Advanced Control Flow
  8. Production Deployment
  9. Best Practices
  10. Integration Examples
Sekcje z nagłówków SKILL.md, w oryginale · 293 linii, 747 słów
Podgląd SKILL.md
---
name: langgraph-patterns
description: Production-grade agentic workflows with LangGraph — graph orchestration, state machines, human-in-the-loop, and advanced control flow. Use when building or debugging a LangGraph app, modeling agent state, or adding checkpoints and human approval steps.
version: 1.0.0
---

# LangGraph Patterns Expert Skill

## Purpose
Master LangGraph for building production-ready AI agents with fine-grained control, checkpointing, streaming, and complex state management.

## Core Philosophy

**LangGraph is:** An orchestration framework with both declarative and imperative APIs focused on control and durability for production agents.

**Not:** High-level abstractions that hide complexity - instead provides building blocks for full control.

**Migration:** LangGraph replaces legacy AgentExecutor - migrate all old code.

## The Six Production Features

1. **Parallelization** - Run multiple nodes concurrently
2. **Streaming** - Real-time partial outputs
3. **Checkpointing** - Pause/resume execution
4. **Human-in-the-Loop** - Approval/correction workflows
5. **Tracing** - Observability and debugging
6. **Task Queue** - Asynchronous job processing

## Graph-Based Architecture

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

# Define state
class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    next_action: str

# Create graph
graph = StateGraph(AgentState)

# Add nodes
graph.add_node("analyze", analyze_node)
graph.add_node("execute", execute_node)
graph.add_node("verify", verify_node)

# Define edges
graph.add_edge("analyze", "execute")
graph.add_conditional_edges(
    "execute",
    should_verify,
    {"yes": "verify", "no": END}
)

# Compile
app = graph.compile()
```

## Core Patterns

### Pattern 1: Agent with Tools
```python
from langgraph.prebuilt import create_react_agent

tools = [search_tool, calculator_tool, db_query_tool]

agent = create_react_agent(
    model=llm,
    tools=tools,
    checkpointer=MemorySaver()
)

# Run with streaming
for chunk in agent.stream({"messages": [("user", "Analyze sales data")]}):
    print(chunk)
```

### Pattern 2: Multi-Agent Collaboration
```python
# Supervisor coordinates specialist agents
supervisor_graph = StateGraph(SupervisorState)

supervisor_graph.add_node("supervisor", supervisor_node)
supervisor_graph.add_node("researcher", researcher_agent)
supervisor_graph.add_node("analyst", analyst_agent)
supervisor_graph.add_node("writer", writer_agent)

# Supervisor routes to specialists
supervisor_graph.add_conditional_edges(
    "supervisor",
    route_to_agent,
    {
        "research": "researcher",
        "analyze": "analyst",
        "write": "writer",
        "finish": END
    }
)
```

### Pattern 3: Human-in-the-Loop
```python
from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("checkpoints.db")

graph = StateGraph(State)
graph.add_node("propose_action", propose)
graph.add_node("human_approval", interrupt())  # Pauses here
graph.add_node("execute_action", execute)

app = graph.compile(checkpointer=checkpointer)

# Run until human input needed
result = app.invoke(input, config={"configurable": {"thread_id": "123"}})

# Human reviews, then resume
app.invoke(None, config={"configurable": {"thread_id": "123"}})
```

## State Management

### Short-Term Memory (Session)
```python
class ConversationState(TypedDict):
    messages: Annotated[list, add_messages]
    context: dict

checkpointer = MemorySaver()
app = graph.compile(checkpointer=checkpointer)

# Maintains context across turns
config = {"configurable": {"thread_id": "user_123"}}
app.invoke({"messages": [("user", "Hello")]}, config)
app.invoke({"messages": [("user", "What did I just say?")]}, config)
```

### Long-Term Memory (Persistent)
```python
from langgraph.checkpoint.postgres import PostgresSaver

checkpointer = PostgresSaver.from_conn_string(db_url)

# Persists across sessions
app = graph.compile(checkpointer=checkpointer)
```

## Advanced Control Flow

### Conditional Routing
```python
def route_next(state):
    if state["confidence"] > 0.9:
        return "approve"
    elif state["confidence"] > 0.5:
        return "review"
    else:
        return "reject"

graph.add_conditional_edges(
    "classifier",
    route_next,
    {
        "approve": "auto_approve",
        "review": "human_review",
        "reject": "reject_node"
    }
)
```

### Cycles and Loops
```python
def should_continue(state):
    if state["iterations"] < 3 and not state["success"]:
        return "retry"
    return "finish"

graph.add_conditional_edges(
    "process",
    should_continue,
    {"retry": "process", "finish": END}
)
```

### Parallel Execution
```python
from langgraph.graph import START

# Fan out to parallel nodes
graph.add_edge(START, ["agent_a", "agent_b", "agent_c"])

# Fan in to aggregator
graph.add_edge(["agent_a", "agent_b", "agent_c"], "synthesize")
```

## Production Deployment

### Streaming for UX
```python
async for event in app.astream_events(input, version="v2"):
    if event["event"] == "on_chat_model_stream":
        print(event["data"]["chunk"].content, end="")
```

### Error Handling
```python
def error_handler(state):
    try:
        return execute_risky_operation(state)
    except Exception as e:
        return {"error": str(e), "next": "fallback"}

graph.add_node("risky_op", error_handler)
graph.add_conditional_edges(
    "risky_op",
    lambda s: "fallback" if "error" in s else "success"
)
```

### Monitoring with LangSmith
```python
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "..."

# All agent actions automatically logged to LangSmith
app.invoke(input)
```

## Best Practices

**DO:**
✅ Use checkpointing for long-running tasks
✅ Stream outputs for better UX
✅ Implement human approval for critical actions
✅ Use conditional edges for complex routing
✅ Leverage parallel execution when possible
✅ Monitor with LangSmith in production

**DON'T:**
❌ Use AgentExecutor (deprecated)
❌ Skip error handling on nodes
❌ Forget to set thread_id for stateful conversations
❌ Over-complicate graphs unnecessarily
❌ Ignore memory management for long conversations

## Integration Examples

### With Claude
```python
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-5")
agent = create_react_agent(llm, tools)
```

### With OpenAI
```python
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, tools)
```

### With MCP Servers
```python
from langchain_mcp import MCPTool

github_tool = MCPTool.from_server("github-mcp")
tools = [github_tool, ...]
agent = create_react_agent(llm, tools)
```

## Decision Framework

**Use LangGraph when:**
- Need fine-grained control over agent execution
- Building complex state machines
- Require human-in-the-loop workflows
- Want production-grade durability (checkpointing)
- Need to support multiple LLM providers

**Use alternatives when:**
- Want managed platform (use OpenAI AgentKit)
- Need visual builder (use AgentKit)
- Want simpler API (use Claude SDK directly)
- Building on Oracle Cloud only (use Oracle ADK)

## Resources

- Docs: https://langchain-ai.github.io/langgraph/
- GitHub: https://github.com/langchain-ai/langgraph
- Tutorials: https://langchain-ai.github.io/langgraph/

---

*LangGraph is the production-grade choice for complex agentic workflows requiring maximum control.*

Wersje

W bazie nie ma innych skilli o nazwie langgraph-patterns.

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

Pobrania w ostatnich 30 dniach: 0 · ranking

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

Podobne skille

  • 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-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.
  • 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.
  • 100langchain-langgraph-human-in-loop
    Buduje w LangGraph 1.0 przepływy zatwierdzania z udziałem człowieka przez interrupt_before, interrupt_after i Command(resume=...), z serializowalnym stanem i podpięciem interfejsu decyzji.
  • 100langgraph
    Wspiera budowę stanowych aplikacji wieloagentowych w LangGraph: konstrukcja grafów, zarządzanie stanem, cykle i gałęzie, checkpointery, udział człowieka oraz wzorzec agenta ReAct.
  • 100langgraph
    Buduje stanowych, wieloetapowych agentów AI i przepływy w LangGraph: systemy wieloagentowe, udział człowieka, maszyny stanów, agentowy RAG, wzorce supervisor i worker oraz potoki z cyklami.

Uwagi i zgłoszenia

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