Struct NodeCache 

pub struct NodeCache { /* private fields */ }

Available on crate feature graph only.

Node cache that stores and retrieves execution results.

Supports in-memory LRU caching and optionally Redis-backed caching (behind the redis-cache feature flag).

Example

use adk_graph::cache::{CacheBackend, NodeCache, NodeCachePolicy};
use serde_json::json;
use std::time::Duration;

let policy = NodeCachePolicy {
    backend: CacheBackend::InMemory { max_entries: 100 },
    ttl: Some(Duration::from_secs(60)),
};

let cache = NodeCache::from_policy(&policy);

// Cache miss
assert!(cache.get("key1").await.is_none());

// Store a value
cache.set("key1", json!({"answer": 42}), Some(Duration::from_secs(60))).await;

// Cache hit
assert_eq!(cache.get("key1").await, Some(json!({"answer": 42})));

Implementations

impl NodeCache

pub fn from_policy(policy: &NodeCachePolicy) -> NodeCache

Available on crate feature node-cache only.

Creates a new NodeCache from a NodeCachePolicy.

For the InMemory backend, this initializes an LRU cache with the configured maximum entries. For the Redis backend, this creates a Redis client (connection is established lazily on first use).

Arguments

• policy — the cache policy specifying backend and TTL

Example

use adk_graph::cache::{CacheBackend, NodeCache, NodeCachePolicy};
use std::time::Duration;

let policy = NodeCachePolicy {
    backend: CacheBackend::InMemory { max_entries: 256 },
    ttl: Some(Duration::from_secs(120)),
};
let cache = NodeCache::from_policy(&policy);

pub async fn get(&self, key: &str) -> Option<Value>

Available on crate feature node-cache only.

Retrieves a cached value by key.

Returns Some(value) on a cache hit, or None on a miss (including expired entries).

Arguments

• key — the cache key (typically produced by compute_cache_key)

Example

let value = cache.get("some_key").await;
if let Some(cached) = value {
    println!("Cache hit: {cached}");
}

pub async fn set(&self, key: &str, value: Value, _ttl: Option<Duration>)

Available on crate feature node-cache only.

Stores a value in the cache.

For the in-memory backend, the value is stored with the current timestamp for TTL tracking. For the Redis backend, the TTL is applied as a Redis key expiration.

Arguments

• key — the cache key
• value — the JSON value to cache
• ttl — optional time-to-live for this entry

Example

use serde_json::json;
use std::time::Duration;

cache.set("key", json!({"result": "ok"}), Some(Duration::from_secs(300))).await;

Trait Implementations

impl Debug for NodeCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.