langgraph 0.1.0

A Rust implementation of LangGraph for building stateful, multi-actor applications with LLMs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

use std::sync::Arc;
use crate::runnable::Runnable;

/// Specification for a graph node in the Pregel engine.
///
/// This is NOT a Runnable itself — it's a container from which
/// `PregelExecutableTask`s are built during each super-step.
pub struct PregelNode {
    /// Which channels to read as input.
    /// If the node reads a single channel, this is `[channel_name]`.
    /// If it reads multiple, each becomes a key in the input dict.
    pub channels: Vec<String>,
    /// Channels whose updates trigger this node.
    pub triggers: Vec<String>,
    /// The main node logic runnable.
    pub bound: Arc<dyn Runnable>,
    /// Writers executed after `bound` (typically ChannelWrite).
    pub writers: Vec<Arc<dyn Runnable>>,
    /// Optional retry policy name.
    pub retry_policy: Option<String>,
    /// Optional metadata.
    pub tags: Vec<String>,
}

impl PregelNode {
    pub fn new(
        channels: Vec<String>,
        triggers: Vec<String>,
        bound: Arc<dyn Runnable>,
    ) -> Self {
        Self {
            channels,
            triggers,
            bound,
            writers: Vec::new(),
            retry_policy: None,
            tags: Vec::new(),
        }
    }

    /// Add a writer to execute after the node logic.
    pub fn with_writer(mut self, writer: Arc<dyn Runnable>) -> Self {
        self.writers.push(writer);
        self
    }

    /// Get all writers flattened (deduped consecutive ChannelWrites).
    pub fn flat_writers(&self) -> &Vec<Arc<dyn Runnable>> {
        &self.writers
    }
}