neomemx

neomemx is a high-performance, multi-tenant memory layer for AI agents build with a Rust.

Highlights

• High-performance AI memory — Stores facts, full history, and supports semantic search.
• Rust API — Fluent builder style (store, search, retrieve_all).
• Flexible providers — Groq, Jina, ChromaDB; optional OpenAI, HuggingFace, Milvus.
• LLM-assisted extraction — Automatic fact extraction and consolidation.
• Multi-tenant safe — Per-user/agent scoped memory.
• Advanced retrieval — Reranking and relationship-graph generation.

Quick start

1. Run ChromaDB:

docker run -d -p 8000:8000 chromadb/chroma
or
chroma run  --host 0.0.0.0 --port 8000

2. Export any provider keys you need:

export GROQ_API_KEY=your_key   # or OPENAI_API_KEY, JINA_API_KEY

Rust

Cargo.toml:

[dependencies]
neomemx = "0.1"
tokio = { version = "1", features = ["full"] }

Example:

use neomemx::prelude::*;

#[tokio::main]
async fn main() -> Result<()> {
    dotenvy::dotenv().ok(); // .env - keep your api-key

    println!("Initializing NeomemxEngine...");
    let engine = NeomemxEngine::new().await?;

    let user_id = "afjal";
    let scope = ScopeIdentifiers::for_user(user_id);

    println!("Storing memories...");
    let outcome = engine
        .store("I'm Afjal, a software engineer.")
        .with_scope(scope.clone())
        .execute()
        .await?;

    for op in outcome.operations {
        println!(
            "Fact operation: {:?} -> {} ({})",
            op.change_type, op.fact_id, op.content
        );
    }

    let outcome = engine
        .store("I enjoy playing football.")
        .with_scope(scope.clone())
        .execute()
        .await?;

    for op in outcome.operations {
        println!(
            "Fact operation: {:?} -> {} ({})",
            op.change_type, op.fact_id, op.content
        );
    }

    // Search memories
    println!("\nSearching for 'What does Afjal do?'...");
    let results = engine
        .search("What does Afjal do?")
        .with_scope(scope.clone())
        .limit(5)
        .execute()
        .await?;

    for fact in results.facts {
        println!(
            "  - {} (score: {:.2})",
            fact.content,
            fact.relevance_score.unwrap_or(0.0)
        );
    }

    // Retrieve all
    println!("\nRetrieving all facts for user...");
    let all = engine
        .retrieve_all()
        .with_scope(scope.clone())
        .limit(10)
        .execute()
        .await?;

    for fact in all.facts {
        println!("  - [{}] {}", &fact.id[..8], fact.content);
    }

    // Cleanup
    println!("\nCleaning up...");
    let count = engine.clear(scope).await?;
    println!("Deleted {} facts.", count);

    println!("Done!");
    Ok(())
}

Configuration (env vars)

License

MIT - see LICENSE