zkr 0.4.0

Evidence-backed temporal memory for personal agents
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use super::*;
use std::collections::HashSet;

fn remember(tenant: &str, person: &str, value: &str) -> RememberInput {
    RememberInput {
        tenant_id: TenantId(tenant.into()),
        person_id: PersonId(person.into()),
        ingestion_key: None,
        kind: SourceKind::Conversation,
        text: format!("Sam works at {value}"),
        captured_at: 10,
        recorded_at: 10,
        claim: Some(ClaimInput {
            subject: "Sam".into(),
            predicate: "employer".into(),
            value: value.into(),
            kind: ClaimKind::Fact,
            valid_from: 10,
            tier: MemoryTier::LongTerm,
            processing_state: MemoryProcessingState::Processed,
        }),
        feature_flag: None,
    }
}

fn remember_raw(tenant: &str, person: &str, text: &str) -> RememberInput {
    RememberInput {
        tenant_id: TenantId(tenant.into()),
        person_id: PersonId(person.into()),
        ingestion_key: None,
        kind: SourceKind::Conversation,
        text: text.into(),
        captured_at: 10,
        recorded_at: 10,
        claim: None,
        feature_flag: None,
    }
}

fn hash_for(db: &MemoryDb, target: EmbeddingTarget) -> String {
    db.projection_input(&TenantId("a".into()), &PersonId("sam".into()), target)
        .unwrap()
        .input_hash
}

fn claim_with_older_last_support() -> (MemoryDb, SourceId, ClaimId) {
    let mut db = MemoryDb {
        connection: Connection::open_in_memory().unwrap(),
    };
    db.migrate().unwrap();
    let older = db
        .remember(remember_raw("a", "sam", "Earlier supporting evidence"))
        .unwrap();
    let mut claimed = remember("a", "sam", "Acme");
    claimed.captured_at = 20;
    claimed.recorded_at = 20;
    claimed.claim.as_mut().unwrap().valid_from = 20;
    let newer = db.remember(claimed).unwrap();
    let claim_id = newer.claim_id.unwrap();
    db.link_claim_evidence(ClaimEvidence {
        tenant_id: TenantId("a".into()),
        person_id: PersonId("sam".into()),
        claim_id: claim_id.clone(),
        evidence_id: older.evidence_id,
        relation: EvidenceRelation::Supports,
        confidence_basis_points: 10_000,
    })
    .unwrap();
    db.delete_source(DeleteInput {
        tenant_id: TenantId("a".into()),
        person_id: PersonId("sam".into()),
        source_id: newer.source_id,
        deleted_at: 21,
    })
    .unwrap();
    (db, older.source_id, claim_id)
}

mod apply;
mod embeddings;
mod export;
mod lifecycle;
mod migrations;
mod retrieval;