neomemx 0.1.2

A high-performance memory library for AI agents with semantic search
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

# neomemx

<p align="center">
  <img src="static/neomemx-logo.png" width="560" alt="neomemx logo">
</p>

[![Crates.io](https://img.shields.io/crates/v/neomemx.svg)](https://crates.io/crates/neomemx)
[![Documentation](https://docs.rs/neomemx/badge.svg)](https://docs.rs/neomemx)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)

**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:
```bash
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:
```bash
export GROQ_API_KEY=your_key   # or OPENAI_API_KEY, JINA_API_KEY
```

### Rust

`Cargo.toml`:
```toml
[dependencies]
neomemx = "0.1"
tokio = { version = "1", features = ["full"] }
```

Example:
```rust
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)

| Variable | Description | Required |
|----------|-------------|----------|
| `GROQ_API_KEY` | Groq API key | If using Groq |
| `JINA_API_KEY` | Jina API key | If using Jina |
| `OPENAI_API_KEY` | OpenAI API key | If using OpenAI |
| `CHROMA_HOST` | ChromaDB host | No (default: localhost) |
| `CHROMA_PORT` | ChromaDB port | No (default: 8000) |

## License

MIT - see [LICENSE](LICENSE)