Create a new spec-driven LangGraph project: spec.yaml, nodes.py stub, init.py.

project_dir: directory to create/use (created if missing; error if a spec.yaml already exists there). name: project/graph name, stored in spec.yaml. state_fields: optional initial state fields, each {name, type, reducer?, default?}.

Add or update a node. config['function'] names the callable in nodes.py (defaults to the node id if omitted).

The first node added to a project becomes the entry point automatically; pass entry_point=True to (re)designate a later node instead.

Add an edge between nodes.

Simple edge: set to (a node id, or "END"). Conditional edge: set condition (the name of a router function in nodes.py) and paths (a mapping of the router's return value to a target node id or "END").

Remove a node, cascading to delete any edges that touch it.

Remove edge(s) from a source node. Omit to to remove all edges from that source.

Replace the graph's state schema wholesale.

Each field: {name, type, reducer?, default?}. type is a raw Python type expression (e.g. "str", "list[str]"); reducer names a reducer function (e.g. "add_messages", or a custom name defined in reducers.py).

Apply several spec edits in one call instead of one add_node/add_edge/... call each.

Prefer this over separate calls whenever wiring more than one node/edge at once (e.g. adding a whole tool-calling loop) — it's the same edit, one round trip instead of several.

operations is a list, applied in order against one loaded spec and saved once at the end. Nothing is written if any operation is invalid (bad op name, missing required field, dangling reference) — the whole batch is atomic. Each entry is a dict with an "op" key plus that operation's normal arguments:

{"op": "add_node", "id": "tools", "config": {"function": "call_tools"}} {"op": "add_edge", "from_": "chatbot", "condition": "route", "paths": {"continue": "tools", "end": "END"}} {"op": "add_edge", "from_": "tools", "to": "chatbot"} {"op": "remove_node", "id": "..."} {"op": "remove_edge", "from_": "...", "to": "..."} {"op": "set_state_schema", "fields": [...]}

entry_point is set automatically (the first node added, or pass entry_point=true on a later add_node op) — don't add an edge from "START" yourself, even though rendered graph.py contains one; that edge is derived from entry_point, not wired as a spec edge.

Returns a compact summary (counts), like the other mutating tools — call get_spec if you need the full picture afterward.

Read-only fetch of the full current spec.

Mutating tools (add_node, add_edge, remove_node, remove_edge, set_state_schema) return a compact summary (counts), not the full spec, to keep per-edit response cost flat as the graph grows. Call this when you actually need the whole picture.

Check the spec for unreachable nodes, missing paths to END, dangling conditions/edges, and duplicate/typo'd ids. Returns ok=False if any errors (as opposed to warnings) are found.

Render the current spec into idiomatic LangGraph Python (graph.py by default).

Deterministic Jinja2 templating — no LLM involved, same spec always produces the same code. Blocks if the spec has validation errors (warnings still allow rendering).