rswarm 0.1.8

A Rust implementation of the Swarm framework
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

//! Remote vector backend using Qdrant (task #37).
//!
//! # Activation
//!
//! Enable the `qdrant` feature in Cargo.toml and uncomment the `qdrant-client`
//! optional dependency. Then configure a [`QdrantConfig`] and call
//! [`QdrantMemory::connect`].
//!
//! Without the feature this module compiles but [`QdrantMemory::connect`]
//! returns an error explaining the feature is not enabled.

use crate::error::{SwarmError, SwarmResult};
use crate::memory::vector::{MemoryEntry, RetrievalPolicy, VectorMemory};
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json::Value;

// ---------------------------------------------------------------------------
// QdrantConfig
// ---------------------------------------------------------------------------

/// Configuration for the Qdrant remote vector store adapter.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct QdrantConfig {
    /// Qdrant gRPC/REST host (e.g. `http://localhost:6334`).
    pub host: String,
    /// Collection name to use.
    pub collection: String,
    /// Optional API key for Qdrant Cloud.
    pub api_key: Option<String>,
    /// Request timeout in seconds.
    pub timeout_secs: u64,
    /// Embedding vector dimension (must match the collection's config).
    pub vector_dim: u32,
}

impl Default for QdrantConfig {
    fn default() -> Self {
        Self {
            host: "http://localhost:6334".to_string(),
            collection: "rswarm_memory".to_string(),
            api_key: None,
            timeout_secs: 10,
            vector_dim: 1536,
        }
    }
}

// ---------------------------------------------------------------------------
// QdrantMemory
// ---------------------------------------------------------------------------

/// Remote vector store backed by Qdrant.
///
/// Requires the `qdrant` feature and `qdrant-client` optional dependency.
pub struct QdrantMemory {
    #[allow(dead_code)]
    config: QdrantConfig,
}

impl QdrantMemory {
    fn not_implemented_error() -> SwarmError {
        SwarmError::ConfigError(
            "QdrantMemory is not implemented yet; the feature is reserved until the adapter lands"
                .to_string(),
        )
    }

    /// Connect to a Qdrant instance described by `config`.
    pub async fn connect(_config: QdrantConfig) -> SwarmResult<Self> {
        Err(Self::not_implemented_error())
    }
}

#[async_trait]
impl VectorMemory for QdrantMemory {
    async fn store(
        &self,
        _id: &str,
        _text: &str,
        _embedding: Vec<f32>,
        _metadata: Value,
    ) -> SwarmResult<()> {
        Err(Self::not_implemented_error())
    }

    async fn search(
        &self,
        _query_embedding: Vec<f32>,
        _policy: RetrievalPolicy,
    ) -> SwarmResult<Vec<MemoryEntry>> {
        Err(Self::not_implemented_error())
    }

    async fn delete(&self, _id: &str) -> SwarmResult<()> {
        Err(Self::not_implemented_error())
    }

    async fn len(&self) -> SwarmResult<usize> {
        Err(Self::not_implemented_error())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_connect_reports_backend_unavailable() {
        let result = QdrantMemory::connect(QdrantConfig::default()).await;
        assert!(result.is_err());
    }
}