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

//! Search and reranking

use std::collections::HashMap;

use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json;

use crate::core::{ScopeIdentifiers, StoredFact};
use crate::error::Result;
use crate::vector_store::base::Filters;

pub mod semantic;

/// Trait for result reranking
#[async_trait]
pub trait ResultReranker: Send + Sync {
    /// Rerank search results
    async fn rerank(
        &self,
        query: &str,
        facts: Vec<StoredFact>,
        limit: Option<usize>,
    ) -> Result<Vec<StoredFact>>;
}

/// Kinds of memory/search that the engine can support.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum MemoryKind {
    Semantic,
    Episodic,
    Procedural,
}

/// Common request payload for search strategies.
#[derive(Debug, Clone)]
pub struct SearchRequest {
    pub query: String,
    pub scope: ScopeIdentifiers,
    pub limit: usize,
    /// Optional additional filters (e.g., metadata conditions).
    pub filters: Option<Filters>,
    /// Whether to apply reranking after retrieval.
    pub rerank: bool,
    /// What memory flavor this request targets.
    pub kind: MemoryKind,
}

impl SearchRequest {
    pub fn new(query: impl Into<String>, scope: ScopeIdentifiers, limit: usize) -> Self {
        Self {
            query: query.into(),
            scope,
            limit,
            filters: None,
            rerank: false,
            kind: MemoryKind::Semantic,
        }
    }

    pub fn with_filters(mut self, filters: HashMap<String, serde_json::Value>) -> Self {
        self.filters = Some(filters);
        self
    }

    pub fn with_rerank(mut self, rerank: bool) -> Self {
        self.rerank = rerank;
        self
    }

    pub fn with_kind(mut self, kind: MemoryKind) -> Self {
        self.kind = kind;
        self
    }
}

/// Standardized search result.
#[derive(Debug, Clone)]
pub struct SearchResult {
    pub facts: Vec<StoredFact>,
}

impl SearchResult {
    pub fn new(facts: Vec<StoredFact>) -> Self {
        Self { facts }
    }

    /// Convenience to limit results.
    pub fn truncate(&mut self, limit: usize) {
        self.facts.truncate(limit);
    }
}

/// Trait for pluggable memory search strategies.
#[async_trait]
pub trait MemorySearch: Send + Sync {
    /// Execute a search given a request.
    async fn search(&self, request: SearchRequest) -> Result<SearchResult>;
}