Give your agent a brain
it can carry

Quick Start

Ten lines to persistent memory

use mnemo::{Mnemo, MnemoConfig, Memory, MemoryType, RecallRequest};

fn main() -> mnemo::Result<()> {
    let cfg = MnemoConfig { dimensions: 768, ..Default::default() };
    let mut db = Mnemo::create("agent.mnemo", "correct horse battery", cfg)?;

    db.remember(
        Memory::new("the user prefers dark mode", MemoryType::Semantic, vec![0.1, 0.2, 0.9])
            .with_agent("assistant-1")
            .with_importance(0.8),
    )?;
    db.flush()?; // durable + crash-safe

    for hit in db.recall(&RecallRequest::new(vec![0.1, 0.2, 0.9]).top_k(5))? {
        println!("{:.3}  {}", hit.score, hit.memory.content);
    }
    Ok(())
}

import mnemo

# Open or create an encrypted memory file
db = mnemo.open("agent.mnemo", "passphrase", dimensions=768)

# Store a memory with type, importance, and agent scope
db.remember(
    "the user prefers concise answers",
    "procedural",
    embedding_model.encode("the user prefers concise answers"),
    importance=0.8,
    agent_id="assistant",
)

# Multi-signal recall — similarity + recency + importance + frequency
for hit in db.recall(query_embedding, top_k=10):
    print(hit["score"], hit["content"])

db.flush()
db.close()

# Passphrase via env (preferred over --passphrase on the CLI)
$ export MNEMO_PASSPHRASE=your-secret

# Create, load, and index
$ mnemo init agent.mnemo --dimensions 768
$ mnemo import agent.mnemo memories.jsonl
$ mnemo index agent.mnemo

# Explore — browse, fetch by ULID, multi-signal recall
$ mnemo info agent.mnemo
$ mnemo list agent.mnemo --type semantic --limit 20
$ mnemo get agent.mnemo 01HXYZ... --verbose
$ mnemo recall agent.mnemo --query 0.1,0.2,0.9 --top-k 5

# Exact similarity-only search (ground truth)
$ mnemo search agent.mnemo --query 0.1,0.2,0.9 --top-k 5

# Re-key without rewriting bulk data
$ mnemo rekey agent.mnemo --new-passphrase new-secret