langgraph-fundamentals

What it does

Instructs the agent to work with LangGraph to build directed graphs that represent agent workflows. It defines a StateGraph as the main class for stateful graphs, with nodes as functions that perform work and update state, and edges that determine execution order (static or conditional). It references START and END as entry/exit points and explains reducers for state updates (overwrite, append, or custom logic). The skill emphasizes that graphs must be compile()d before execution and provides guidance on graph design, state management, node signatures, edge types, and usage of Command and Send for combined state updates and routing or fan-out parallel tasks.

It includes concrete examples in Python and TypeScript for basic graph construction, conditional edges, command-based routing, and Send-based parallelism, showing how to define state schemas, node functions, and graph wiring, and how to invoke the graph to obtain results.

The skill also documents how to annotate return types for Command in Python and how to specify valid goto destinations in TypeScript, as well as cautions about static vs dynamic edges when using Command.

How it works

• Define a State schema and node functions that accept state (and optionally config or runtime) and return partial updates or Commands.
• Use add_node(s) to register nodes and add_edge or addEdge to set deterministic flow; use add_conditional_edges for routing based on state through a route function.
• Use reducers (via Annotated with operator.add or ReducedValue) to control how updates accumulate in state across nodes.
• Return partial updates from nodes rather than mutating and returning the full state.
• For complex routing, return a Command with update and goto to combine state changes with navigation; for parallel tasks use Send to fan out work and aggregate results with a reducer.
• Compile graphs with .compile() before invoking, then call graph.invoke(initial_state).

When to use it

• When you need fine-grained control over agent orchestration with branching or loops.
• When building complex workflows requiring persistence or human-in-the-loop routing.
• When you want explicit state sharing across nodes and conditional routing based on state.

What it can touch

• Graph construction APIs: StateGraph, START, END, add_node, add_edge, add_conditional_edges, compile, invoke.
• Node signatures and state updates: Python: def node(state: State) or def node(state: State, config: RunnableConfig) or def node(state: State, runtime: Runtime[Context]); TypeScript: (state) => {...} or (state, config) => {...}.
• State schemas and reducers: Python TypedDict with Annotated and operator.add; TypeScript StateSchema with ReducedValue.
• Command and Send usage for routing and parallelism; annotations for Command return types; and edge behavior warnings.

Caveats

• Command adds dynamic edges; static edges defined with add_edge/addEdge still run, so both paths may execute if both are configured.
• Nodes must return partial updates, not mutate and return full state.
• Graphs must be compile()d before execution; runtime relies on proper state reducers to accumulate lists and values.
• The skill description notes how to declare valid goto destinations for Command or addNode, and emphasizes not overwriting arrays without reducers.