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
138
139
140
141
142

//! Milvus vector store configuration

use serde::{Deserialize, Serialize};

/// Configuration for Milvus vector store
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MilvusConfig {
    /// Name of the collection
    #[serde(default = "default_collection_name")]
    pub collection_name: String,

    /// Host address for Milvus server
    #[serde(default = "default_host")]
    pub host: String,

    /// Port for Milvus REST API
    #[serde(default = "default_port")]
    pub port: u16,

    /// Database name
    #[serde(default = "default_database")]
    pub database: String,

    /// API key for Milvus Cloud (Zilliz)
    pub api_key: Option<String>,

    /// Dimension of vectors (must match your embedding model)
    #[serde(default = "default_dimension")]
    pub dimension: usize,

    /// Metric type for similarity search
    #[serde(default = "default_metric_type")]
    pub metric_type: MetricType,

    /// Index type for the collection
    #[serde(default = "default_index_type")]
    pub index_type: IndexType,

    /// Use secure connection (HTTPS)
    #[serde(default)]
    pub secure: bool,
}

/// Metric types for similarity search
#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum MetricType {
    /// Inner product (for normalized vectors)
    Ip,
    /// L2/Euclidean distance
    #[default]
    L2,
    /// Cosine similarity
    Cosine,
}

impl MetricType {
    /// Get the string representation for Milvus API
    pub fn as_str(&self) -> &'static str {
        match self {
            MetricType::Ip => "IP",
            MetricType::L2 => "L2",
            MetricType::Cosine => "COSINE",
        }
    }
}

/// Index types for vector search
#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum IndexType {
    /// Flat index (brute force, most accurate)
    Flat,
    /// IVF Flat index
    IvfFlat,
    /// HNSW index (default, good balance of speed/accuracy)
    #[default]
    Hnsw,
    /// Disk-based index
    DiskAnn,
    /// Auto index (let Milvus decide)
    Autoindex,
}

fn default_collection_name() -> String {
    "neomemx".to_string()
}

fn default_host() -> String {
    "localhost".to_string()
}

fn default_port() -> u16 {
    19530
}

fn default_database() -> String {
    "default".to_string()
}

fn default_dimension() -> usize {
    768
}

fn default_metric_type() -> MetricType {
    MetricType::Cosine
}

fn default_index_type() -> IndexType {
    IndexType::Autoindex
}

impl Default for MilvusConfig {
    fn default() -> Self {
        Self {
            collection_name: default_collection_name(),
            host: default_host(),
            port: default_port(),
            database: default_database(),
            api_key: None,
            dimension: default_dimension(),
            metric_type: default_metric_type(),
            index_type: default_index_type(),
            secure: false,
        }
    }
}

impl MilvusConfig {
    /// Get the base URL for REST API
    pub fn get_base_url(&self) -> String {
        let protocol = if self.secure { "https" } else { "http" };
        format!("{}://{}:{}", protocol, self.host, self.port)
    }

    /// Get API key from config or environment variable
    pub fn get_api_key(&self) -> Option<String> {
        self.api_key
            .clone()
            .or_else(|| std::env::var("MILVUS_API_KEY").ok())
    }
}