Struct AgentId 

pub struct AgentId(/* private fields */);

Identifiant d’agent (tenant logique d’une mémoire).

Implementations

impl AgentId

pub fn new(id: impl Into<String>) -> Option<Self>

Construit un AgentId. Vide => None (un agent valide est requis).

Examples found in repository

examples/llm_consolidation.rs (line 54)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = Store::open_in_memory().await?;
    let agent = AgentId::new("consolidation-demo").expect("non-empty id");
    let memory = Memory::open(store, Box::new(FakeEmbedder), agent).await?;

    // Store a raw episode (what happened).
    memory
        .remember(
            "Alice attended a conference in Paris, the capital of France.",
            MemoryLayer::Episodic,
        )
        .await?;

    // Consolidate: extract facts + populate graph via FakeLlm.
    let report = consolidate(&memory, &FakeLlm).await?;
    println!(
        "Consolidation: {} episode(s) seen, {} fact(s) added, {} entity(ies) upserted, {} relation(s).",
        report.episodes_seen, report.facts_added, report.entities_upserted, report.relations_upserted,
    );

    // The extracted fact should now be searchable in semantic layer.
    let facts = memory
        .recall_by_layer("What is the capital of France?", MemoryLayer::Semantic, 5)
        .await?;
    println!("\nSemantic facts after consolidation ({}):", facts.len());
    for f in &facts {
        println!("  • {}", f.text);
    }

    Ok(())
}

examples/temporal_replacement.rs (line 45)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = Store::open_in_memory().await?;
    let agent = AgentId::new("temporal-demo").expect("non-empty id");
    let memory = Memory::open(store, Box::new(DemoEmbedder), agent).await?;

    let old_id = memory
        .remember("The user is on the Free billing plan.", MemoryLayer::Semantic)
        .await?;

    println!("Initially remembered: Free plan ({old_id})");

    memory.invalidate(&old_id).await?;
    let new_id = memory
        .remember("The user is on the Pro billing plan.", MemoryLayer::Semantic)
        .await?;

    println!("Invalidated old fact and remembered: Pro plan ({new_id})");

    let hits = memory.recall_hybrid("current billing plan", 5).await?;
    println!("\nRecall for `current billing plan`:");
    for hit in &hits {
        println!("  [{layer}] {text}", layer = hit.layer.table(), text = hit.text);
    }

    assert!(
        hits.iter().any(|r| r.text.contains("Pro billing plan")),
        "the current fact should be recalled"
    );
    assert!(
        hits.iter().all(|r| !r.text.contains("Free billing plan")),
        "the invalidated fact should not be recalled"
    );

    Ok(())
}

examples/memory_basic.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = Store::open_in_memory().await?;
    let agent = AgentId::new("demo-agent").expect("non-empty id");
    let memory = Memory::open(store, Box::new(FakeEmbedder), agent).await?;

    memory
        .remember("The Eiffel Tower is in Paris.", MemoryLayer::Semantic)
        .await?;
    memory
        .remember("Paris is the capital of France.", MemoryLayer::Semantic)
        .await?;
    memory.remember("Bonjour!", MemoryLayer::ShortTerm).await?;

    println!("=== recall (top 2) ===");
    let results = memory.recall("What city is the Eiffel Tower in?", 2).await?;
    for r in &results {
        println!(
            "  [{layer}] {score:.3}  {text}",
            layer = r.layer.table(),
            score = r.score,
            text = r.text
        );
    }

    let first_id = results[0].id.clone();
    memory.invalidate(&first_id).await?;
    println!("\nInvalidated id={first_id}");

    let after = memory.recall("Eiffel Tower", 5).await?;
    println!("Recall after invalidation: {} result(s)", after.len());

    let stats = memory.stats().await?;
    println!(
        "\nStats: {} semantic, {} short-term (valid).",
        stats.semantic, stats.short_term
    );

    Ok(())
}

pub fn as_str(&self) -> &str

Trait Implementations

impl Clone for AgentId

fn clone(&self) -> AgentId

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AgentId

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

Formats the value using the given formatter.

impl Eq for AgentId

impl Hash for AgentId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AgentId

fn eq(&self, other: &AgentId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AgentId