synaptic-vectorstores 0.4.0

Vector store trait with in-memory cosine similarity implementation
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
143
144
145
146
147
148
149
150
151
152
153
154

use std::sync::Arc;

use synaptic_embeddings::FakeEmbeddings;
use synaptic_vectorstores::{Document, InMemoryVectorStore, VectorStore};

#[tokio::test]
async fn add_and_delete_then_search_empty() {
    let store = InMemoryVectorStore::new();
    let embeddings = FakeEmbeddings::default();

    let ids = store
        .add_documents(vec![Document::new("d1", "hello world")], &embeddings)
        .await
        .unwrap();

    store
        .delete(&ids.iter().map(|s| s.as_str()).collect::<Vec<_>>())
        .await
        .unwrap();

    let results = store
        .similarity_search("hello", 5, &embeddings)
        .await
        .unwrap();
    assert!(
        results.is_empty(),
        "store should be empty after deleting all documents"
    );
}

#[tokio::test]
async fn search_empty_store() {
    let store = InMemoryVectorStore::new();
    let embeddings = FakeEmbeddings::default();

    let results = store
        .similarity_search("anything", 5, &embeddings)
        .await
        .unwrap();
    assert!(results.is_empty());
}

#[tokio::test]
async fn similarity_search_returns_at_most_k_results() {
    let store = InMemoryVectorStore::new();
    let embeddings = FakeEmbeddings::default();

    let docs: Vec<Document> = (0..10)
        .map(|i| Document::new(format!("d{i}"), format!("document number {i}")))
        .collect();
    store.add_documents(docs, &embeddings).await.unwrap();

    let results = store
        .similarity_search("document", 3, &embeddings)
        .await
        .unwrap();
    assert_eq!(
        results.len(),
        3,
        "should return exactly k=3 results when store has more"
    );
}

#[tokio::test]
async fn from_texts_creates_searchable_store() {
    let embeddings = FakeEmbeddings::default();
    let store = InMemoryVectorStore::from_texts(
        vec![("id1", "hello world"), ("id2", "goodbye world")],
        &embeddings,
    )
    .await
    .unwrap();

    let results = store
        .similarity_search("hello", 2, &embeddings)
        .await
        .unwrap();
    assert_eq!(results.len(), 2);
}

#[tokio::test]
async fn search_with_scores_values_in_range() {
    let store = InMemoryVectorStore::new();
    let embeddings = FakeEmbeddings::new(8);

    store
        .add_documents(
            vec![
                Document::new("d1", "rust programming language"),
                Document::new("d2", "python programming language"),
            ],
            &embeddings,
        )
        .await
        .unwrap();

    let results = store
        .similarity_search_with_score("rust", 2, &embeddings)
        .await
        .unwrap();
    assert_eq!(results.len(), 2);

    // Cosine similarity of unit vectors is in [-1, 1], but for
    // FakeEmbeddings (non-negative components) scores will be >= 0.
    for (doc, score) in &results {
        assert!(
            *score >= -1.0 && *score <= 1.0,
            "score out of cosine range for doc '{}': {}",
            doc.id,
            score,
        );
    }

    // Results should be sorted descending by score
    assert!(
        results[0].1 >= results[1].1,
        "first result score ({}) should be >= second ({})",
        results[0].1,
        results[1].1,
    );
}

#[tokio::test]
async fn concurrent_add_documents() {
    let store = Arc::new(InMemoryVectorStore::new());
    let embeddings = Arc::new(FakeEmbeddings::default());

    let mut handles = Vec::new();
    for i in 0..5 {
        let s = store.clone();
        let e = embeddings.clone();
        handles.push(tokio::spawn(async move {
            s.add_documents(
                vec![Document::new(format!("d{i}"), format!("text {i}"))],
                e.as_ref(),
            )
            .await
            .unwrap();
        }));
    }
    for h in handles {
        h.await.unwrap();
    }

    let results = store
        .similarity_search("text", 10, embeddings.as_ref())
        .await
        .unwrap();
    assert_eq!(
        results.len(),
        5,
        "all 5 concurrently added documents should be present"
    );
}