uniko¶

Agent memory has become an integration project¶

Your agent needs to remember who said what, notice when a fact changes, reuse what worked, and explain why it believes something. The standard answer is a stack: a vector store for recall, a graph database when flat text runs out, a rules layer for inference, and glue to keep them consistent.

Every piece is a service to run, a consistency boundary to defend, and another LLM call on the write path — and you pay for that derivation again on every query. uniko removes all of it.

Compile knowledge once. Query it forever.¶

Raw messages are source code; uniko compiles them into reusable knowledge at write time. A local ONNX NLP cascade extracts entities and observations with zero LLM API calls, then one atomic transaction commits everything with full provenance. Recall queries the compiled knowledge — it never re-derives it, so there is no LLM in the recall hot path.

flowchart LR
  M[Messages] -->|local ONNX cascade · $0| E[Entities]
  M --> O[Observations]
  E --> F[Facts]
  O --> F
  F --> P[Procedures]
  M --> T[Topics]
  F --> A[Recall · no LLM in path]
  P --> A

What you get from one in-process engine¶

The numbers behind the claims¶

Measured on the full LoCoMo10 benchmark (1,986 questions) and the KTH dmas-memory comparison. Each result maps to a line item you care about: cost, latency, and operations.

Three calls: build, observe, recall¶

A Uniko instance is one in-process handle. Build it, observe messages, recall a context bundle. No services, no network, no separate vector index to reconcile.

use uniko_memory::{Turn, Uniko};

# async fn demo() -> Result<(), uniko_store::UnikoError> {
// 1. Build an embedded instance — no external services.
let memory = Uniko::open("./agent-memory").await?;
let agent = memory.agent("assistant");
let mut session = agent.session("session-1");

// 2. Observe a message. Extraction (NER + NLP cascade + observations)
//    runs locally; one atomic transaction writes the Message, Entities,
//    Observations, edges, and chunks — and commits before returning,
//    idempotent on the turn id.
session
    .observe(Turn::new("melanie", "Caroline researched coral reef restoration in Belize."))
    .await?;

// 3. Recall compiled knowledge for a query — no LLM in this path. Each
//    item carries its `kind` and the `sources` it traces back to.
let bundle = agent.recall("What did Caroline research?").await?;
for item in &bundle.items {
    println!("[{:?}] {}", item.kind, item.content);
}
# Ok(())
# }

Built for teams shipping agents in their own process¶

uniko is a Rust library for founders and engineering leads who want cognitive memory without standing up infrastructure. It fits when operational footprint, ingest cost, and offline capability matter; when conversation and provenance are central to your product; and when you want graph-native reasoning compiled at ingest instead of paid for on every query.

Next steps¶