Crate adk_graph 

adk-graph

Graph-based workflow orchestration for ADK-Rust agents, inspired by LangGraph.

Overview

adk-graph provides a powerful way to build complex, stateful agent workflows using a graph-based approach. It brings LangGraph-style capabilities to the Rust ADK ecosystem while maintaining full compatibility with ADK’s agent system, callbacks, and streaming infrastructure.

Features

• Graph-Based Workflows: Define agent workflows as directed graphs
• Cyclic Support: Native support for loops and iterative reasoning
• Conditional Routing: Dynamic edge routing based on state
• State Management: Typed state with reducers (overwrite, append, sum, custom)
• Checkpointing: Persistent state after each step
• Human-in-the-Loop: Interrupt before/after nodes, dynamic interrupts
• Streaming: Multiple stream modes (values, updates, messages, debug)
• ADK Integration: Full callback support, works with existing runners

Quick Start

use adk_graph::prelude::*;

let agent = GraphAgent::builder("processor")
    .description("Process data through multiple steps")
    .node_fn("fetch", |ctx| async move {
        Ok(NodeOutput::new().with_update("data", json!({"items": [1, 2, 3]})))
    })
    .node_fn("transform", |ctx| async move {
        let data = ctx.state.get("data").unwrap();
        Ok(NodeOutput::new().with_update("result", data.clone()))
    })
    .edge(START, "fetch")
    .edge("fetch", "transform")
    .edge("transform", END)
    .build()?;

// Execute
let result = agent.invoke(State::new(), ExecutionConfig::new("thread_1")).await?;

ReAct Pattern

use adk_graph::prelude::*;

let react_agent = GraphAgent::builder("react")
    .node(llm_agent_node)
    .node_fn("tools", execute_tools)
    .edge(START, "llm")
    .conditional_edge(
        "llm",
        |state| {
            if has_tool_calls(state) { "tools" } else { END }
        },
        [("tools", "tools"), (END, END)],
    )
    .edge("tools", "llm")  // Cycle back
    .recursion_limit(25)
    .build()?;

Re-exports

pub use agent::GraphAgent;

pub use agent::GraphAgentBuilder;

pub use checkpoint::Checkpointer;

pub use checkpoint::MemoryCheckpointer;

pub use deferred::DeferredNodeConfig;

pub use deferred::FanInTracker;

pub use deferred::MergeStrategy;

pub use edge::END;

pub use edge::Edge;

pub use edge::EdgeTarget;

pub use edge::Router;

pub use edge::START;

pub use error::GraphError;

pub use error::InterruptedExecution;

pub use error::Result;

pub use executor::PregelExecutor;

pub use graph::CompiledGraph;

pub use graph::StateGraph;

pub use interrupt::Interrupt;

pub use interrupt::interrupt;

pub use interrupt::interrupt_with_data;

pub use node::AgentNode;

pub use node::ExecutionConfig;

pub use node::FunctionNode;

pub use node::Node;

pub use node::NodeContext;

pub use node::NodeOutput;

pub use state::Channel;

pub use state::Checkpoint;

pub use state::Reducer;

pub use state::State;

pub use state::StateSchema;

pub use state::StateSchemaBuilder;

pub use stream::StreamEvent;

pub use stream::StreamMode;

pub use timeout::OnTimeout;

pub use timeout::ProgressHandle;

pub use timeout::TimeoutPolicy;

pub use timeout::execute_with_timeout;

Modules

agent

GraphAgent - ADK Agent integration for graph workflows

checkpoint

Checkpointing for persistent graph state

deferred

Deferred node (fan-in barrier) support for graph workflows.

edge

Edge types for graph control flow

error

Error types for adk-graph

executor

Pregel-based execution engine for graphs

graph

StateGraph builder for constructing graphs

interrupt

Human-in-the-loop interrupt types

node

Node types for graph execution

prelude

Prelude module for convenient imports

state

State management for graph execution

stream

Streaming types for graph execution

timeout

Timeout enforcement for graph node execution.