Struct InMemoryVectorStore 

pub struct InMemoryVectorStore { /* private fields */ }

In-memory vector store using cosine similarity

Implementations

impl InMemoryVectorStore

pub fn new() -> Self

Create a new in-memory vector store

Examples found in repository

examples/rag_advanced.rs (line 37)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Advanced RAG Features");
    println!("========================================\n");

    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_else(|_| {
        println!("⚠ Warning: OPENAI_API_KEY not set. Using placeholder.");
        "your-api-key-here".to_string()
    });

    // Create RAG system directly (without agent)
    let embeddings = OpenAIEmbeddings::new("https://api.openai.com/v1/embeddings", api_key);
    let vector_store = InMemoryVectorStore::new();
    let rag_system = RAGSystem::new(Box::new(embeddings), Box::new(vector_store));

    println!("✓ RAG system created\n");

    // --- Example 1: Adding documents with metadata ---
    println!("Example 1: Documents with Metadata");
    println!("===================================\n");

    let documents = vec![
        (
            "Rust is a systems programming language focused on safety and performance.",
            hashmap! {
                "category" => "programming",
                "language" => "rust",
                "year" => "2010",
                "difficulty" => "intermediate",
            },
        ),
        (
            "Python is known for its simplicity and extensive library ecosystem.",
            hashmap! {
                "category" => "programming",
                "language" => "python",
                "year" => "1991",
                "difficulty" => "beginner",
            },
        ),
        (
            "Machine learning is a subset of AI that enables systems to learn from data.",
            hashmap! {
                "category" => "ai",
                "topic" => "machine-learning",
                "difficulty" => "advanced",
            },
        ),
        (
            "Docker is a platform for developing, shipping, and running applications in containers.",
            hashmap! {
                "category" => "devops",
                "tool" => "docker",
                "year" => "2013",
            },
        ),
    ];

    let mut doc_ids = Vec::new();
    for (text, meta) in documents.iter() {
        let metadata: HashMap<String, serde_json::Value> = meta
            .iter()
            .map(|(k, v)| (k.to_string(), serde_json::json!(v)))
            .collect();

        let id = rag_system.add_document(text, Some(metadata)).await?;
        println!(
            "Added document: {} (ID: {})",
            &text[..50.min(text.len())],
            id
        );
        doc_ids.push(id);
    }
    println!();

    // --- Example 2: Semantic search ---
    println!("Example 2: Semantic Search");
    println!("==========================\n");

    let queries = vec![
        ("programming language safety", 3),
        ("containerization technology", 2),
        ("artificial intelligence", 2),
    ];

    for (query, limit) in queries {
        println!("Query: '{}' (limit: {})", query, limit);
        let results = rag_system.search(query, limit).await?;
        print_results(&results);
        println!();
    }

    // --- Example 3: Document count ---
    println!("Example 3: Document Management");
    println!("===============================\n");

    let count = rag_system.count().await?;
    println!("Total documents: {}\n", count);

    // --- Example 4: Delete a document ---
    if let Some(first_id) = doc_ids.first() {
        println!("Deleting document: {}", first_id);
        rag_system.delete_document(first_id).await?;
        let new_count = rag_system.count().await?;
        println!("Documents after deletion: {}\n", new_count);
    }

    // --- Example 5: Search after deletion ---
    println!("Example 5: Search After Deletion");
    println!("=================================\n");

    let results = rag_system.search("programming languages", 5).await?;
    println!("Results for 'programming languages':");
    print_results(&results);
    println!();

    // --- Example 6: Clear all documents ---
    println!("Example 6: Clear All Documents");
    println!("===============================\n");

    rag_system.clear().await?;
    let final_count = rag_system.count().await?;
    println!("Documents after clear: {}\n", final_count);

    println!("✅ Example completed successfully!");
    println!("\n💡 Key Features Demonstrated:");
    println!("  • Direct RAG system usage (no agent required)");
    println!("  • Documents with custom metadata");
    println!("  • Semantic search with configurable limits");
    println!("  • Document management (add, delete, count, clear)");
    println!("  • Batch operations");

    println!("\n📝 Advanced Use Cases:");
    println!("  • Building custom RAG pipelines");
    println!("  • Document management systems");
    println!("  • Knowledge base applications");
    println!("  • Semantic search engines");

    Ok(())
}

Trait Implementations

impl Default for InMemoryVectorStore

fn default() -> Self

Returns the “default value” for a type.

impl VectorStore for InMemoryVectorStore

fn initialize<'life0, 'async_trait>( &'life0 self, _dimension: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initialize the vector store (create collections, etc.)

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, embedding: Vec<f32>, text: &'life2 str, metadata: HashMap<String, Value>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Add a document with its embedding

fn search<'life0, 'async_trait>( &'life0 self, query_embedding: Vec<f32>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<SearchResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Search for similar documents

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a document by ID

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear all documents

fn count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get document count