Struct LLMBrain 

pub struct LLMBrain { /* private fields */ }

Core library struct holding initialized clients and configuration.

This is the main entry point for interacting with the LLMBrain library. It manages database connections, LLM client, and ConceptNet integration.

Implementations

impl LLMBrain

pub async fn launch() -> Result<Self>

Loads configuration, initializes clients, and returns an instance of LLMBrain.

This should be called once at application startup. It performs:

• Loading and parsing configuration
• Setting up the SurrealDB connection
• Initializing LLM client
• Initializing ConceptNet client (if configured)

Examples found in repository

examples/comprehensive_demo.rs (line 226)

async fn main() -> Result<()> {
    // Initialize LLMBrain instance
    println!("Initializing LLMBrain...");
    let llm_brain = LLMBrain::launch().await?;

    // Demonstrate different memory types
    demonstrate_memory_types(&llm_brain).await?;

    // Demonstrate memory recall
    demonstrate_memory_recall(&llm_brain).await?;

    // Demonstrate memory lookup
    demonstrate_memory_lookup(&llm_brain).await?;

    println!("\nComprehensive demonstration completed successfully!");
    Ok(())
}

examples/file_rag.rs (line 162)

async fn main() -> Result<()> {
    println!("--- Starting File RAG Example ---");
    ensure_config_exists()?;
    let llm_brain = LLMBrain::launch().await?;

    // --- Ingestion Step ---
    // IMPORTANT: Adjust this path to your actual test PDF file
    // Using the path relative to workspace root as seen in python example context
    let pdf_path = PathBuf::from("tests/document.pdf");

    if !pdf_path.exists() {
        eprintln!("Error: PDF file not found at {}", pdf_path.display());
        eprintln!("Please place a PDF file at that location or update the path in the code.");
        return Ok(()); // Exit gracefully
    }

    // Ingest the PDF content
    if let Err(e) = ingest_pdf(&llm_brain, &pdf_path).await {
        eprintln!("Error during PDF ingestion: {e}");
        // Decide if program should terminate or continue
    }

    // --- Query Step ---
    let test_queries = [
        "What is the main topic of the document?",
        "Summarize the key points from the document.",
        "What are the main conclusions drawn in the document?",
        "what is silha center",
        "who is Charlotte Higgins",
        "Explain the lawsuits",
        "Explain OpenAI's Involvement",
        "who is Mike Masnick",
        "content moderation liability shield", // Added query
    ];

    if let Err(e) = run_queries(&llm_brain, &test_queries).await {
        eprintln!("Error during querying: {e}");
    }

    println!("\n--- File RAG Example Finished ---");
    println!("Note: Database is at ./llm_brain_file_rag_db");

    Ok(())
}

examples/llm_brain_rag.rs (line 85)

async fn main() -> Result<()> {
    println!("--- Starting LLMBrain RAG Example (Rust/LLMBrain Version) ---");
    ensure_config_exists()?;
    let llm_brain = LLMBrain::launch().await?;

    // --- Add Memories Step ---
    println!("\nAdding example memories...");
    let examples = vec![
        TestMemoryData {
            content: "Python is a programming language created by Guido van Rossum in 1991. It supports object-oriented, imperative, and functional programming. Commonly used for web development, data science, automation.".to_owned(),
            metadata: json!({
                "entity_name": "Python_Language",
                "memory_type": "Semantic",
                "properties": {"creator": "Guido van Rossum", "year": 1991, "paradigms": ["OOP", "Imperative", "Functional"], "uses": ["web dev", "data science", "automation"]},
            }),
        },
        TestMemoryData {
            content: "Completed first Python project today in home office. Took 2 hours, successful. Reviewed code.".to_owned(),
            metadata: json!({
                "entity_name": "First_Python_Project",
                "memory_type": "Episodic",
                "properties": {"timestamp": Utc::now().timestamp(), "location": "home office", "duration_hours": 2, "outcome": "successful"},
            }),
        },
        TestMemoryData {
            content: "Tesla Model 3 is red, made in 2023, parked in the garage. Range 358 miles, 0-60 mph in 3.1 seconds.".to_owned(),
            metadata: json!({
                "entity_name": "Tesla_Model_3_Red",
                "memory_type": "Semantic",
                "properties": {"color": "red", "year": 2023, "location": "garage", "range_miles": 358, "acceleration_0_60_sec": 3.1},
            }),
        },
    ];

    for (i, data) in examples.into_iter().enumerate() {
        println!("\nAdding Example {}", i + 1);
        match llm_brain
            .add_memory(data.content.clone(), data.metadata.clone())
            .await
        {
            Ok(id) => println!("  Added successfully. ID: {id}"),
            Err(e) => eprintln!("  Failed to add: {e}"),
        }
    }

    // --- Query Step (Simulating RAG Retrieval) ---
    let test_queries = [
        "What programming language was created by Guido van Rossum?",
        "Tell me about the Tesla Model 3's specifications.",
        "What happened during the first Python project?",
    ];

    if let Err(e) = run_rag_queries(&llm_brain, &test_queries).await {
        eprintln!("Error during querying: {e}");
    }

    println!("\n--- LLMBrain RAG Example Finished ---");
    println!("Note: Database is at ./llm_brain_rag_db");

    Ok(())
}

examples/basic_demo.rs (line 17)

async fn main() -> Result<()> {
    println!("Initializing LLMBrain for basic demo...");

    // Ensure config exists before launching
    ensure_config_exists()?;

    // Initialize LLMBrain
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // Add a semantic memory
    println!("\nAdding semantic memory...");
    let cat_data = json!({
        "name": "Cat",
        "column": "Semantic",
        "properties": {
            "type": "Animal",
            "features": ["fur", "whiskers", "tail"],
            "diet": "carnivore"
        },
        "relationships": {
            "preys_on": ["mice", "birds"],
            "related_to": ["tiger", "lion"]
        }
    });

    let cat_content = "The cat is a small carnivorous mammal with fur, whiskers, and a tail. It preys on mice and birds, and is related to tigers and lions.";
    let result = llm_brain
        .add_memory(cat_content.to_owned(), cat_data)
        .await?;
    println!("Semantic memory added with ID: {result}");

    // Add an episodic memory
    println!("\nAdding episodic memory...");
    let event_data = json!({
        "name": "First Pet",
        "column": "Episodic",
        "properties": {
            "timestamp": Utc::now().to_rfc3339(),
            "action": "Got my first cat",
            "location": "Pet Store",
            "emotion": "happy",
            "participants": ["family", "pet store staff"]
        }
    });

    let event_content = "Today I went to the pet store with my family and got my first cat. Everyone was very happy.";
    let result = llm_brain
        .add_memory(event_content.to_owned(), event_data)
        .await?;
    println!("Episodic memory added with ID: {result}");

    // Add a procedural memory
    println!("\nAdding procedural memory...");
    let procedure_data = json!({
        "name": "Feed Cat",
        "column": "Procedural",
        "properties": {
            "steps": [
                "Get cat food from cabinet",
                "Fill bowl with appropriate amount",
                "Add fresh water to water bowl",
                "Call cat for feeding"
            ],
            "frequency": "twice daily",
            "importance": "high"
        }
    });

    let procedure_content = "To feed a cat: First, get cat food from the cabinet. Then fill the bowl with an appropriate amount. Add fresh water to the water bowl. Finally, call the cat for feeding. This should be done twice daily.";
    let result = llm_brain
        .add_memory(procedure_content.to_owned(), procedure_data)
        .await?;
    println!("Procedural memory added with ID: {result}");

    // Query memories
    println!("\nQuerying cat-related memories...");
    let cat_results = llm_brain.recall("cat animal features", 3).await?;
    println!("Cat-related memories:");
    for (memory, score) in cat_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nQuerying feeding procedure...");
    let feeding_results = llm_brain.recall("how to feed a cat", 2).await?;
    println!("Feeding procedure results:");
    for (memory, score) in feeding_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nDemo completed.");
    println!("Note: Database file created at ./llm_brain_example_db (if it didn't exist).");

    Ok(())
}

examples/llm_brain_basic_demo.rs (line 50)

async fn main() -> Result<()> {
    println!("\nStarting LLMBrain Basic Demo (Rust Version)...");

    // Ensure config exists
    ensure_config_exists()?;

    // Initialize LLMBrain (handles DB connection based on config)
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // --- Add Semantic Memory (Cat) ---
    println!("\nAdding basic semantic memory for 'cat'...");
    let cat_content = "A cat is a medium-sized, furry, agile, carnivorous animal often found in homes or outdoors. Common behaviors include hunting, sleeping, and grooming.".to_owned();
    let cat_metadata = json!({
        "entity_name": "cat",
        "memory_type": "Semantic",
        "properties": {
            "type": "animal",
            "size": "medium",
            "characteristics": ["furry", "agile", "carnivorous"]
        },
        "relationships": {
            "habitat": ["homes", "outdoors"],
            "behavior": ["hunting", "sleeping", "grooming"]
        }
    });
    match llm_brain
        .add_memory(cat_content.clone(), cat_metadata.clone())
        .await
    {
        Ok(id) => println!("Semantic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add semantic memory: {e}"),
    }

    // --- Add Episodic Memory (Cat Observation) ---
    println!("\nAdding episodic memory...");
    let episode_content = format!(
        "Timestamp: {}. Observed cat behavior in the Garden: Cat was chasing a butterfly. Observed by human.",
        Utc::now().to_rfc3339()
    );
    let episode_metadata = json!({
        "entity_name": "cat_observation",
        "memory_type": "Episodic",
        "properties": {
            "action": "Observed cat behavior",
            "location": "Garden",
            "details": "Cat was chasing a butterfly"
        },
        "relationships": {
            "relates_to": ["cat"],
            "observed_by": ["human"]
        }
    });
    match llm_brain
        .add_memory(episode_content.clone(), episode_metadata.clone())
        .await
    {
        Ok(id) => println!("Episodic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add episodic memory: {e}"),
    }

    // --- Query and Display Results ---
    println!("\nQuerying semantic memory for 'cat':");
    let cat_query = "information about cats";
    match llm_brain.recall(cat_query, 2).await {
        // Recall top 2
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{cat_query}': {e}"),
    }

    println!("\nQuerying episodic memory:");
    let episode_query = "cat observation in garden";
    match llm_brain.recall(episode_query, 1).await {
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{episode_query}': {e}"),
    }

    println!("\nDemo completed successfully!");
    println!("Note: Database file created at ./llm_brain_basic_demo_db (if it didn't exist).");

    Ok(())
}

examples/embedding_demo.rs (line 9)

async fn main() -> Result<()> {
    // Initialize LLMBrain instance
    println!("Initializing LLMBrain...");
    let llm_brain = LLMBrain::launch().await?;

    // Demo 1: Basic embedding generation and query
    println!("\n--- Basic Embedding Demo ---");

    // Add several memories
    let memories = vec![
        (
            "Cats are small mammals with fur, whiskers, and tails. They eat mice and birds, and are related to tigers and lions.",
            json!({
                "name": "Cat",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "whiskers", "tail"],
                    "diet": "carnivorous"
                }
            }),
        ),
        (
            "Dogs are one of the earliest domesticated animals, loyal companions to humans, with various breeds and purposes.",
            json!({
                "name": "Dog",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "loyalty", "keen sense of smell"],
                    "uses": ["pet", "working dog", "guide dog"]
                }
            }),
        ),
        (
            "Birds are warm-blooded vertebrates, covered with feathers, with forelimbs evolved into wings, and most can fly.",
            json!({
                "name": "Bird",
                "type": "Animal",
                "properties": {
                    "characteristics": ["feathers", "wings", "beak"],
                    "abilities": ["flying", "nest building", "singing"]
                }
            }),
        ),
    ];

    // Add memories to database
    for (content, metadata) in memories {
        let memory_id = llm_brain.add_memory(content.to_owned(), metadata).await?;
        println!("Added memory: ID={memory_id}");
    }

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related memories using semantic search
    println!("\nQuerying memories about 'pets':");
    let results = llm_brain.recall("pets and human relationships", 2).await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Demo 2: Long text processing
    println!("\n--- Long Text Processing Demo ---");

    // Prepare a longer text
    let long_text = r#"
        Artificial Intelligence (AI) is a branch of computer science aimed at creating systems capable of simulating human intelligence behaviors.
        AI research includes multiple sub-fields such as machine learning, deep learning, natural language processing, computer vision, expert systems, etc.
        Machine learning is one of the core technologies of AI, using statistical techniques to enable computer systems to "learn" (i.e., progressively improve performance) without explicit programming.
        Deep learning is a subset of machine learning that uses multi-layered neural networks to process data. These networks extract features from data, with each layer building on the output of the previous one.
        Large Language Models (LLMs) are a significant breakthrough in AI in recent years, generating human-like text, understanding context, and performing various language tasks by learning from vast amounts of text data.
        Vector embeddings are techniques for representing text, images, or other data as points in a multi-dimensional vector space, playing an important role in information retrieval, recommendation systems, and semantic search.
    "#;

    println!("Long text content:\n{long_text}");

    // Process long text using different strategies
    println!("\nUsing default strategy (no chunking):");
    let embedding1 = llm_brain.process_long_text(long_text, None).await?;
    println!("Generated embedding vector length: {}", embedding1.len());

    println!("\nUsing chunk and average strategy:");
    let chunk_strategy = ChunkingStrategy::ChunkAndAverage {
        chunk_size: 100,
        chunk_overlap: 20,
    };
    let embedding2 = llm_brain
        .process_long_text(long_text, Some(chunk_strategy))
        .await?;
    println!("Generated embedding vector length: {}", embedding2.len());

    // Calculate similarity between embeddings generated by different strategies
    let similarity = cosine_similarity(&embedding1, &embedding2);
    println!("\nCosine similarity between embeddings from two strategies: {similarity:.4}");

    // Demo 3: Adding long text to memory
    println!("\n--- Adding Long Text Memory Demo ---");

    let metadata = json!({
        "name": "Artificial Intelligence Overview",
        "type": "Knowledge",
        "tags": ["AI", "Machine Learning", "Deep Learning"]
    });

    let memory_id = llm_brain.add_memory(long_text.to_owned(), metadata).await?;
    println!("Added long text memory: ID={memory_id}");

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related content
    println!("\nQuerying memories about 'large language models':");
    let results = llm_brain
        .recall("large language models and vector embeddings", 1)
        .await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content summary: {}", truncate_text(&memory.content, 100));
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    println!("\nDemo completed.");
    Ok(())
}

pub async fn add_memory( &self, content: String, metadata: Value, ) -> Result<Thing>

Adds a text fragment to the memory store.

This method:

1. Generates an embedding for the content using the LLM client
2. Creates a MemoryFragment with the content, embedding, and metadata
3. Stores it in the database

Returns the SurrealDB ID of the created record.

Examples found in repository

examples/file_rag.rs (line 84)

async fn ingest_pdf(llm_brain: &LLMBrain, pdf_path: &Path) -> Result<Vec<String>> {
    let start_time = Instant::now();
    println!("Processing PDF: {}", pdf_path.display());

    // 1. Extract text
    let text = extract_text(pdf_path).context("Failed to extract text from PDF")?;
    println!("Extracted {} characters.", text.len());

    // 2. Chunk text
    let chunks = chunk_text_by_words(&text, DEFAULT_CHUNK_SIZE);
    println!("Split into {} chunks.", chunks.len());

    // 3. Add chunks as MemoryFragments
    let filename = pdf_path
        .file_name()
        .unwrap_or_default()
        .to_string_lossy()
        .to_string();
    let file_stem = pdf_path
        .file_stem()
        .unwrap_or_default()
        .to_string_lossy()
        .to_string();

    let mut chunk_ids = Vec::new();

    for (i, chunk_content) in chunks.into_iter().enumerate() {
        let chunk_num = i + 1;
        let metadata = json!({
            "memory_type": "DocumentChunk",
            "source_file": filename,
            "chunk_number": chunk_num,
            // Optionally add entity_name for direct reference if needed
            "entity_name": format!("{}_chunk_{}", file_stem, chunk_num)
        });

        // Add memory (handle potential errors)
        match llm_brain.add_memory(chunk_content, metadata).await {
            Ok(id) => {
                chunk_ids.push(id.to_string());
                if chunk_num % 10 == 0 {
                    println!("Added chunk {chunk_num}...");
                }
            }
            Err(e) => {
                eprintln!("Failed to add chunk {chunk_num}: {e}");
                // Decide whether to continue or stop on error
            }
        }
    }

    // 4. (Optional) Add a MemoryFragment for the document itself, linking to chunks
    let doc_content = format!(
        "Metadata for document: {}. Contains {} chunks.",
        filename,
        chunk_ids.len()
    );
    let doc_metadata = json!({
        "memory_type": "DocumentMeta",
        "entity_name": file_stem,
        "properties": {
            "file_path": pdf_path.to_string_lossy(),
            "file_name": filename,
            "chunk_count": chunk_ids.len()
        },
        "relationships": {
            "contains_chunks": chunk_ids // Store the actual DB IDs
        }
    });
    llm_brain.add_memory(doc_content, doc_metadata).await?;
    println!("Added document metadata entry.");

    println!("Ingestion completed in {:?}.", start_time.elapsed());
    Ok(chunk_ids) // Return chunk IDs if needed elsewhere
}

examples/llm_brain_rag.rs (line 119)

async fn main() -> Result<()> {
    println!("--- Starting LLMBrain RAG Example (Rust/LLMBrain Version) ---");
    ensure_config_exists()?;
    let llm_brain = LLMBrain::launch().await?;

    // --- Add Memories Step ---
    println!("\nAdding example memories...");
    let examples = vec![
        TestMemoryData {
            content: "Python is a programming language created by Guido van Rossum in 1991. It supports object-oriented, imperative, and functional programming. Commonly used for web development, data science, automation.".to_owned(),
            metadata: json!({
                "entity_name": "Python_Language",
                "memory_type": "Semantic",
                "properties": {"creator": "Guido van Rossum", "year": 1991, "paradigms": ["OOP", "Imperative", "Functional"], "uses": ["web dev", "data science", "automation"]},
            }),
        },
        TestMemoryData {
            content: "Completed first Python project today in home office. Took 2 hours, successful. Reviewed code.".to_owned(),
            metadata: json!({
                "entity_name": "First_Python_Project",
                "memory_type": "Episodic",
                "properties": {"timestamp": Utc::now().timestamp(), "location": "home office", "duration_hours": 2, "outcome": "successful"},
            }),
        },
        TestMemoryData {
            content: "Tesla Model 3 is red, made in 2023, parked in the garage. Range 358 miles, 0-60 mph in 3.1 seconds.".to_owned(),
            metadata: json!({
                "entity_name": "Tesla_Model_3_Red",
                "memory_type": "Semantic",
                "properties": {"color": "red", "year": 2023, "location": "garage", "range_miles": 358, "acceleration_0_60_sec": 3.1},
            }),
        },
    ];

    for (i, data) in examples.into_iter().enumerate() {
        println!("\nAdding Example {}", i + 1);
        match llm_brain
            .add_memory(data.content.clone(), data.metadata.clone())
            .await
        {
            Ok(id) => println!("  Added successfully. ID: {id}"),
            Err(e) => eprintln!("  Failed to add: {e}"),
        }
    }

    // --- Query Step (Simulating RAG Retrieval) ---
    let test_queries = [
        "What programming language was created by Guido van Rossum?",
        "Tell me about the Tesla Model 3's specifications.",
        "What happened during the first Python project?",
    ];

    if let Err(e) = run_rag_queries(&llm_brain, &test_queries).await {
        eprintln!("Error during querying: {e}");
    }

    println!("\n--- LLMBrain RAG Example Finished ---");
    println!("Note: Database is at ./llm_brain_rag_db");

    Ok(())
}

examples/basic_demo.rs (line 38)

async fn main() -> Result<()> {
    println!("Initializing LLMBrain for basic demo...");

    // Ensure config exists before launching
    ensure_config_exists()?;

    // Initialize LLMBrain
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // Add a semantic memory
    println!("\nAdding semantic memory...");
    let cat_data = json!({
        "name": "Cat",
        "column": "Semantic",
        "properties": {
            "type": "Animal",
            "features": ["fur", "whiskers", "tail"],
            "diet": "carnivore"
        },
        "relationships": {
            "preys_on": ["mice", "birds"],
            "related_to": ["tiger", "lion"]
        }
    });

    let cat_content = "The cat is a small carnivorous mammal with fur, whiskers, and a tail. It preys on mice and birds, and is related to tigers and lions.";
    let result = llm_brain
        .add_memory(cat_content.to_owned(), cat_data)
        .await?;
    println!("Semantic memory added with ID: {result}");

    // Add an episodic memory
    println!("\nAdding episodic memory...");
    let event_data = json!({
        "name": "First Pet",
        "column": "Episodic",
        "properties": {
            "timestamp": Utc::now().to_rfc3339(),
            "action": "Got my first cat",
            "location": "Pet Store",
            "emotion": "happy",
            "participants": ["family", "pet store staff"]
        }
    });

    let event_content = "Today I went to the pet store with my family and got my first cat. Everyone was very happy.";
    let result = llm_brain
        .add_memory(event_content.to_owned(), event_data)
        .await?;
    println!("Episodic memory added with ID: {result}");

    // Add a procedural memory
    println!("\nAdding procedural memory...");
    let procedure_data = json!({
        "name": "Feed Cat",
        "column": "Procedural",
        "properties": {
            "steps": [
                "Get cat food from cabinet",
                "Fill bowl with appropriate amount",
                "Add fresh water to water bowl",
                "Call cat for feeding"
            ],
            "frequency": "twice daily",
            "importance": "high"
        }
    });

    let procedure_content = "To feed a cat: First, get cat food from the cabinet. Then fill the bowl with an appropriate amount. Add fresh water to the water bowl. Finally, call the cat for feeding. This should be done twice daily.";
    let result = llm_brain
        .add_memory(procedure_content.to_owned(), procedure_data)
        .await?;
    println!("Procedural memory added with ID: {result}");

    // Query memories
    println!("\nQuerying cat-related memories...");
    let cat_results = llm_brain.recall("cat animal features", 3).await?;
    println!("Cat-related memories:");
    for (memory, score) in cat_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nQuerying feeding procedure...");
    let feeding_results = llm_brain.recall("how to feed a cat", 2).await?;
    println!("Feeding procedure results:");
    for (memory, score) in feeding_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nDemo completed.");
    println!("Note: Database file created at ./llm_brain_example_db (if it didn't exist).");

    Ok(())
}

examples/comprehensive_demo.rs (line 34)

async fn demonstrate_memory_types(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Types ===");

    // Create semantic memory - a Tesla car entity
    println!("\nAdding semantic memory (Tesla Model 3)...");
    let car_data = json!({
        "name": "Tesla_Model_3",
        "column": "Semantic",
        "properties": {
            "color": "red",
            "year": "2023",
            "mileage": "1000 miles",
            "features": ["autopilot capabilities", "glass roof"],
            "type": "electric vehicle"
        },
        "relationships": {
            "type_of": ["Vehicle"],
            "location": "garage"
        }
    });

    let car_content = "The Tesla Model 3 is a red electric vehicle from 2023 with 1000 miles. \
                      It features autopilot capabilities and a glass roof. It is parked in the garage.";

    let car_id = llm_brain
        .add_memory(car_content.to_owned(), car_data)
        .await?;
    println!("Added car memory with ID: {car_id}");

    // Create episodic memory - buying the car
    println!("\nAdding episodic memory (Buying the car)...");
    let purchase_data = json!({
        "name": "Tesla_Purchase",
        "column": "Episodic",
        "timestamp": Utc::now().to_rfc3339(),
        "properties": {
            "action": "Bought a new car",
            "location": "Tesla Dealership",
            "participants": ["Me", "Tesla Sales Representative"],
            "emotion": "excited"
        },
        "relationships": {
            "related_to": ["Tesla_Model_3"]
        }
    });

    let purchase_content = "I bought a new Tesla Model 3 today at the Tesla Dealership. \
                           The sales representative was very helpful. I was very excited about getting my new car.";

    let purchase_id = llm_brain
        .add_memory(purchase_content.to_owned(), purchase_data)
        .await?;
    println!("Added purchase memory with ID: {purchase_id}");

    // Create procedural memory - charging the car
    println!("\nAdding procedural memory (Charging the car)...");
    let charging_data = json!({
        "name": "Charge_Tesla",
        "column": "Procedural",
        "properties": {
            "steps": [
                "Park near charging station",
                "Open charging port on car",
                "Connect charging cable",
                "Initiate charging via app or car interface",
                "Wait for sufficient charge",
                "Disconnect charging cable",
                "Close charging port"
            ],
            "required_tools": ["Charging cable", "Tesla app"],
            "estimated_time": "30-60 minutes",
            "frequency": "weekly"
        },
        "relationships": {
            "applies_to": ["Tesla_Model_3"]
        }
    });

    let charging_content = "To charge a Tesla Model 3: First, park near a charging station. \
                          Open the charging port on the car and connect the charging cable. \
                          Then initiate charging via the app or car interface. Wait for 30-60 minutes \
                          until there is sufficient charge. Finally, disconnect the charging cable \
                          and close the charging port. This procedure should be performed weekly \
                          and requires a charging cable and the Tesla app.";

    let charging_id = llm_brain
        .add_memory(charging_content.to_owned(), charging_data)
        .await?;
    println!("Added charging memory with ID: {charging_id}");

    // Allow time for embeddings to be processed
    sleep(Duration::from_millis(200)).await;

    Ok(())
}

/// Demonstrate querying and memory recall capabilities
async fn demonstrate_memory_recall(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Recall ===");

    // Query for Tesla car
    println!("\nQuerying for Tesla Model 3 information:");
    let tesla_query = "What do I know about my Tesla Model 3?";
    let tesla_results = llm_brain.recall(tesla_query, 3).await?;

    for (i, (memory, score)) in tesla_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Query for car purchase experience
    println!("\nQuerying for car purchase experience:");
    let purchase_query = "When did I buy my Tesla?";
    let purchase_results = llm_brain.recall(purchase_query, 2).await?;

    for (i, (memory, score)) in purchase_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Query for charging instructions
    println!("\nQuerying for charging instructions:");
    let charging_query = "How do I charge my car?";
    let charging_results = llm_brain.recall(charging_query, 2).await?;

    for (i, (memory, score)) in charging_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    Ok(())
}

/// Demonstrate adding a memory and then finding it by similarity
async fn demonstrate_memory_lookup(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Lookup ===");

    // Add a new memory about a trip
    println!("\nAdding memory about a road trip...");
    let trip_data = json!({
        "name": "Road_Trip_Tahoe",
        "column": "Episodic",
        "timestamp": Utc::now().to_rfc3339(),
        "properties": {
            "action": "Road trip to Lake Tahoe",
            "location": "Lake Tahoe",
            "participants": ["Me", "Family"],
            "duration": "3 days",
            "transportation": "Tesla Model 3",
            "highlights": ["Beautiful scenery", "Hiking", "Swimming"]
        }
    });

    let trip_content = "Last weekend, we took our Tesla Model 3 on a road trip to Lake Tahoe. \
                       The drive was smooth and we enjoyed the beautiful scenery. \
                       We spent 3 days there with the family, hiking and swimming in the lake. \
                       The car performed excellently on the mountain roads.";

    let trip_id = llm_brain
        .add_memory(trip_content.to_owned(), trip_data)
        .await?;
    println!("Added trip memory with ID: {trip_id}");

    // Allow time for embeddings to be processed
    sleep(Duration::from_millis(200)).await;

    // Now try to find this memory with various related queries
    let queries = [
        "Did we go on any trips with our Tesla?",
        "What activities did we do at Lake Tahoe?",
        "How did the Tesla perform on our road trip?",
    ];

    for (i, query) in queries.iter().enumerate() {
        println!("\nQuery {}: \"{}\"", i + 1, query);
        let results = llm_brain.recall(query, 1).await?;

        if !results.is_empty() {
            let (memory, score) = &results[0];
            println!("Found memory (score: {score:.4}):");
            println!("Content: {}", memory.content);
        } else {
            println!("No relevant memories found.");
        }
    }

    // Direct lookup by ID
    println!("\nDirect lookup by ID:");
    if let Some(memory) = llm_brain
        .get_memory_by_id_string(&trip_id.to_string())
        .await?
    {
        println!("Successfully retrieved memory");
        println!("Content: {}", memory.content);
    } else {
        println!("Failed to retrieve memory by ID");
    }

    Ok(())
}

examples/llm_brain_basic_demo.rs (line 70)

async fn main() -> Result<()> {
    println!("\nStarting LLMBrain Basic Demo (Rust Version)...");

    // Ensure config exists
    ensure_config_exists()?;

    // Initialize LLMBrain (handles DB connection based on config)
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // --- Add Semantic Memory (Cat) ---
    println!("\nAdding basic semantic memory for 'cat'...");
    let cat_content = "A cat is a medium-sized, furry, agile, carnivorous animal often found in homes or outdoors. Common behaviors include hunting, sleeping, and grooming.".to_owned();
    let cat_metadata = json!({
        "entity_name": "cat",
        "memory_type": "Semantic",
        "properties": {
            "type": "animal",
            "size": "medium",
            "characteristics": ["furry", "agile", "carnivorous"]
        },
        "relationships": {
            "habitat": ["homes", "outdoors"],
            "behavior": ["hunting", "sleeping", "grooming"]
        }
    });
    match llm_brain
        .add_memory(cat_content.clone(), cat_metadata.clone())
        .await
    {
        Ok(id) => println!("Semantic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add semantic memory: {e}"),
    }

    // --- Add Episodic Memory (Cat Observation) ---
    println!("\nAdding episodic memory...");
    let episode_content = format!(
        "Timestamp: {}. Observed cat behavior in the Garden: Cat was chasing a butterfly. Observed by human.",
        Utc::now().to_rfc3339()
    );
    let episode_metadata = json!({
        "entity_name": "cat_observation",
        "memory_type": "Episodic",
        "properties": {
            "action": "Observed cat behavior",
            "location": "Garden",
            "details": "Cat was chasing a butterfly"
        },
        "relationships": {
            "relates_to": ["cat"],
            "observed_by": ["human"]
        }
    });
    match llm_brain
        .add_memory(episode_content.clone(), episode_metadata.clone())
        .await
    {
        Ok(id) => println!("Episodic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add episodic memory: {e}"),
    }

    // --- Query and Display Results ---
    println!("\nQuerying semantic memory for 'cat':");
    let cat_query = "information about cats";
    match llm_brain.recall(cat_query, 2).await {
        // Recall top 2
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{cat_query}': {e}"),
    }

    println!("\nQuerying episodic memory:");
    let episode_query = "cat observation in garden";
    match llm_brain.recall(episode_query, 1).await {
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{episode_query}': {e}"),
    }

    println!("\nDemo completed successfully!");
    println!("Note: Database file created at ./llm_brain_basic_demo_db (if it didn't exist).");

    Ok(())
}

examples/embedding_demo.rs (line 53)

async fn main() -> Result<()> {
    // Initialize LLMBrain instance
    println!("Initializing LLMBrain...");
    let llm_brain = LLMBrain::launch().await?;

    // Demo 1: Basic embedding generation and query
    println!("\n--- Basic Embedding Demo ---");

    // Add several memories
    let memories = vec![
        (
            "Cats are small mammals with fur, whiskers, and tails. They eat mice and birds, and are related to tigers and lions.",
            json!({
                "name": "Cat",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "whiskers", "tail"],
                    "diet": "carnivorous"
                }
            }),
        ),
        (
            "Dogs are one of the earliest domesticated animals, loyal companions to humans, with various breeds and purposes.",
            json!({
                "name": "Dog",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "loyalty", "keen sense of smell"],
                    "uses": ["pet", "working dog", "guide dog"]
                }
            }),
        ),
        (
            "Birds are warm-blooded vertebrates, covered with feathers, with forelimbs evolved into wings, and most can fly.",
            json!({
                "name": "Bird",
                "type": "Animal",
                "properties": {
                    "characteristics": ["feathers", "wings", "beak"],
                    "abilities": ["flying", "nest building", "singing"]
                }
            }),
        ),
    ];

    // Add memories to database
    for (content, metadata) in memories {
        let memory_id = llm_brain.add_memory(content.to_owned(), metadata).await?;
        println!("Added memory: ID={memory_id}");
    }

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related memories using semantic search
    println!("\nQuerying memories about 'pets':");
    let results = llm_brain.recall("pets and human relationships", 2).await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Demo 2: Long text processing
    println!("\n--- Long Text Processing Demo ---");

    // Prepare a longer text
    let long_text = r#"
        Artificial Intelligence (AI) is a branch of computer science aimed at creating systems capable of simulating human intelligence behaviors.
        AI research includes multiple sub-fields such as machine learning, deep learning, natural language processing, computer vision, expert systems, etc.
        Machine learning is one of the core technologies of AI, using statistical techniques to enable computer systems to "learn" (i.e., progressively improve performance) without explicit programming.
        Deep learning is a subset of machine learning that uses multi-layered neural networks to process data. These networks extract features from data, with each layer building on the output of the previous one.
        Large Language Models (LLMs) are a significant breakthrough in AI in recent years, generating human-like text, understanding context, and performing various language tasks by learning from vast amounts of text data.
        Vector embeddings are techniques for representing text, images, or other data as points in a multi-dimensional vector space, playing an important role in information retrieval, recommendation systems, and semantic search.
    "#;

    println!("Long text content:\n{long_text}");

    // Process long text using different strategies
    println!("\nUsing default strategy (no chunking):");
    let embedding1 = llm_brain.process_long_text(long_text, None).await?;
    println!("Generated embedding vector length: {}", embedding1.len());

    println!("\nUsing chunk and average strategy:");
    let chunk_strategy = ChunkingStrategy::ChunkAndAverage {
        chunk_size: 100,
        chunk_overlap: 20,
    };
    let embedding2 = llm_brain
        .process_long_text(long_text, Some(chunk_strategy))
        .await?;
    println!("Generated embedding vector length: {}", embedding2.len());

    // Calculate similarity between embeddings generated by different strategies
    let similarity = cosine_similarity(&embedding1, &embedding2);
    println!("\nCosine similarity between embeddings from two strategies: {similarity:.4}");

    // Demo 3: Adding long text to memory
    println!("\n--- Adding Long Text Memory Demo ---");

    let metadata = json!({
        "name": "Artificial Intelligence Overview",
        "type": "Knowledge",
        "tags": ["AI", "Machine Learning", "Deep Learning"]
    });

    let memory_id = llm_brain.add_memory(long_text.to_owned(), metadata).await?;
    println!("Added long text memory: ID={memory_id}");

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related content
    println!("\nQuerying memories about 'large language models':");
    let results = llm_brain
        .recall("large language models and vector embeddings", 1)
        .await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content summary: {}", truncate_text(&memory.content, 100));
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    println!("\nDemo completed.");
    Ok(())
}

pub async fn recall( &self, query_text: &str, top_k: usize, ) -> Result<Vec<(MemoryFragment, f32)>>

Retrieves similar memories based on a text query.

This method:

1. Generates an embedding for the query text
2. Finds memory fragments with similar embeddings

Returns a vec of (MemoryFragment, similarity_score) tuples.

Examples found in repository

examples/file_rag.rs (line 128)

async fn run_queries(llm_brain: &LLMBrain, queries: &[&str]) -> Result<()> {
    println!("\n--- Running Queries ---");
    for query in queries {
        println!("\nQuery: {query}");
        let start_time = Instant::now();
        match llm_brain.recall(query, 3).await {
            // Retrieve top 3 relevant chunks
            Ok(results) => {
                println!(
                    "Found {} relevant chunks in {:?}:",
                    results.len(),
                    start_time.elapsed()
                );
                if results.is_empty() {
                    println!("  (No relevant chunks found)");
                } else {
                    for (fragment, score) in results {
                        println!(
                            "  - Score: {:.4}, Source: {:?}, Chunk: {:?}\n    Content: {:.150}...",
                            score,
                            fragment.metadata.get("source_file"),
                            fragment.metadata.get("chunk_number"),
                            fragment.content.replace('\n', " ") // Basic formatting
                        );
                    }
                }
            }
            Err(e) => {
                eprintln!("  Error during recall: {e}");
            }
        }
    }
    Ok(())
}

examples/llm_brain_rag.rs (line 47)

async fn run_rag_queries(llm_brain: &LLMBrain, queries: &[&str]) -> Result<()> {
    println!("\n--- Running Simulated RAG Queries (Retrieval Only) ---");
    for query in queries {
        println!("\nQuery: {query}");
        let start_time = Instant::now();
        match llm_brain.recall(query, 3).await {
            // Retrieve top 3 relevant fragments
            Ok(results) => {
                println!(
                    "Retrieved {} relevant fragments in {:?}:",
                    results.len(),
                    start_time.elapsed()
                );
                if results.is_empty() {
                    println!("  (No relevant fragments found for RAG context)");
                } else {
                    println!("  --- Potential RAG Context: ---");
                    for (fragment, score) in results {
                        println!(
                            "  - Score: {:.4}, Entity: {:?}\n    Content: {:.150}...",
                            score,
                            fragment.metadata.get("entity_name"), // Display name if available
                            fragment.content.replace('\n', " ")
                        );
                    }
                    println!("  --- End Context ---");
                    println!(
                        "  (Note: In a full RAG system, these fragments would be passed to an LLM with the query to generate a final answer.)"
                    );
                }
            }
            Err(e) => {
                eprintln!("  Error during recall: {e}");
            }
        }
    }
    Ok(())
}

examples/comprehensive_demo.rs (line 112)

async fn demonstrate_memory_recall(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Recall ===");

    // Query for Tesla car
    println!("\nQuerying for Tesla Model 3 information:");
    let tesla_query = "What do I know about my Tesla Model 3?";
    let tesla_results = llm_brain.recall(tesla_query, 3).await?;

    for (i, (memory, score)) in tesla_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Query for car purchase experience
    println!("\nQuerying for car purchase experience:");
    let purchase_query = "When did I buy my Tesla?";
    let purchase_results = llm_brain.recall(purchase_query, 2).await?;

    for (i, (memory, score)) in purchase_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Query for charging instructions
    println!("\nQuerying for charging instructions:");
    let charging_query = "How do I charge my car?";
    let charging_results = llm_brain.recall(charging_query, 2).await?;

    for (i, (memory, score)) in charging_results.iter().enumerate() {
        println!("\nResult {}: Score {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    Ok(())
}

/// Demonstrate adding a memory and then finding it by similarity
async fn demonstrate_memory_lookup(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Lookup ===");

    // Add a new memory about a trip
    println!("\nAdding memory about a road trip...");
    let trip_data = json!({
        "name": "Road_Trip_Tahoe",
        "column": "Episodic",
        "timestamp": Utc::now().to_rfc3339(),
        "properties": {
            "action": "Road trip to Lake Tahoe",
            "location": "Lake Tahoe",
            "participants": ["Me", "Family"],
            "duration": "3 days",
            "transportation": "Tesla Model 3",
            "highlights": ["Beautiful scenery", "Hiking", "Swimming"]
        }
    });

    let trip_content = "Last weekend, we took our Tesla Model 3 on a road trip to Lake Tahoe. \
                       The drive was smooth and we enjoyed the beautiful scenery. \
                       We spent 3 days there with the family, hiking and swimming in the lake. \
                       The car performed excellently on the mountain roads.";

    let trip_id = llm_brain
        .add_memory(trip_content.to_owned(), trip_data)
        .await?;
    println!("Added trip memory with ID: {trip_id}");

    // Allow time for embeddings to be processed
    sleep(Duration::from_millis(200)).await;

    // Now try to find this memory with various related queries
    let queries = [
        "Did we go on any trips with our Tesla?",
        "What activities did we do at Lake Tahoe?",
        "How did the Tesla perform on our road trip?",
    ];

    for (i, query) in queries.iter().enumerate() {
        println!("\nQuery {}: \"{}\"", i + 1, query);
        let results = llm_brain.recall(query, 1).await?;

        if !results.is_empty() {
            let (memory, score) = &results[0];
            println!("Found memory (score: {score:.4}):");
            println!("Content: {}", memory.content);
        } else {
            println!("No relevant memories found.");
        }
    }

    // Direct lookup by ID
    println!("\nDirect lookup by ID:");
    if let Some(memory) = llm_brain
        .get_memory_by_id_string(&trip_id.to_string())
        .await?
    {
        println!("Successfully retrieved memory");
        println!("Content: {}", memory.content);
    } else {
        println!("Failed to retrieve memory by ID");
    }

    Ok(())
}

examples/basic_demo.rs (line 87)

async fn main() -> Result<()> {
    println!("Initializing LLMBrain for basic demo...");

    // Ensure config exists before launching
    ensure_config_exists()?;

    // Initialize LLMBrain
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // Add a semantic memory
    println!("\nAdding semantic memory...");
    let cat_data = json!({
        "name": "Cat",
        "column": "Semantic",
        "properties": {
            "type": "Animal",
            "features": ["fur", "whiskers", "tail"],
            "diet": "carnivore"
        },
        "relationships": {
            "preys_on": ["mice", "birds"],
            "related_to": ["tiger", "lion"]
        }
    });

    let cat_content = "The cat is a small carnivorous mammal with fur, whiskers, and a tail. It preys on mice and birds, and is related to tigers and lions.";
    let result = llm_brain
        .add_memory(cat_content.to_owned(), cat_data)
        .await?;
    println!("Semantic memory added with ID: {result}");

    // Add an episodic memory
    println!("\nAdding episodic memory...");
    let event_data = json!({
        "name": "First Pet",
        "column": "Episodic",
        "properties": {
            "timestamp": Utc::now().to_rfc3339(),
            "action": "Got my first cat",
            "location": "Pet Store",
            "emotion": "happy",
            "participants": ["family", "pet store staff"]
        }
    });

    let event_content = "Today I went to the pet store with my family and got my first cat. Everyone was very happy.";
    let result = llm_brain
        .add_memory(event_content.to_owned(), event_data)
        .await?;
    println!("Episodic memory added with ID: {result}");

    // Add a procedural memory
    println!("\nAdding procedural memory...");
    let procedure_data = json!({
        "name": "Feed Cat",
        "column": "Procedural",
        "properties": {
            "steps": [
                "Get cat food from cabinet",
                "Fill bowl with appropriate amount",
                "Add fresh water to water bowl",
                "Call cat for feeding"
            ],
            "frequency": "twice daily",
            "importance": "high"
        }
    });

    let procedure_content = "To feed a cat: First, get cat food from the cabinet. Then fill the bowl with an appropriate amount. Add fresh water to the water bowl. Finally, call the cat for feeding. This should be done twice daily.";
    let result = llm_brain
        .add_memory(procedure_content.to_owned(), procedure_data)
        .await?;
    println!("Procedural memory added with ID: {result}");

    // Query memories
    println!("\nQuerying cat-related memories...");
    let cat_results = llm_brain.recall("cat animal features", 3).await?;
    println!("Cat-related memories:");
    for (memory, score) in cat_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nQuerying feeding procedure...");
    let feeding_results = llm_brain.recall("how to feed a cat", 2).await?;
    println!("Feeding procedure results:");
    for (memory, score) in feeding_results {
        println!("Score: {:.4}, Content: {}", score, memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
        println!();
    }

    println!("\nDemo completed.");
    println!("Note: Database file created at ./llm_brain_example_db (if it didn't exist).");

    Ok(())
}

examples/llm_brain_basic_demo.rs (line 107)

async fn main() -> Result<()> {
    println!("\nStarting LLMBrain Basic Demo (Rust Version)...");

    // Ensure config exists
    ensure_config_exists()?;

    // Initialize LLMBrain (handles DB connection based on config)
    let llm_brain = LLMBrain::launch().await?;
    println!("LLMBrain initialized.");

    // --- Add Semantic Memory (Cat) ---
    println!("\nAdding basic semantic memory for 'cat'...");
    let cat_content = "A cat is a medium-sized, furry, agile, carnivorous animal often found in homes or outdoors. Common behaviors include hunting, sleeping, and grooming.".to_owned();
    let cat_metadata = json!({
        "entity_name": "cat",
        "memory_type": "Semantic",
        "properties": {
            "type": "animal",
            "size": "medium",
            "characteristics": ["furry", "agile", "carnivorous"]
        },
        "relationships": {
            "habitat": ["homes", "outdoors"],
            "behavior": ["hunting", "sleeping", "grooming"]
        }
    });
    match llm_brain
        .add_memory(cat_content.clone(), cat_metadata.clone())
        .await
    {
        Ok(id) => println!("Semantic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add semantic memory: {e}"),
    }

    // --- Add Episodic Memory (Cat Observation) ---
    println!("\nAdding episodic memory...");
    let episode_content = format!(
        "Timestamp: {}. Observed cat behavior in the Garden: Cat was chasing a butterfly. Observed by human.",
        Utc::now().to_rfc3339()
    );
    let episode_metadata = json!({
        "entity_name": "cat_observation",
        "memory_type": "Episodic",
        "properties": {
            "action": "Observed cat behavior",
            "location": "Garden",
            "details": "Cat was chasing a butterfly"
        },
        "relationships": {
            "relates_to": ["cat"],
            "observed_by": ["human"]
        }
    });
    match llm_brain
        .add_memory(episode_content.clone(), episode_metadata.clone())
        .await
    {
        Ok(id) => println!("Episodic memory added successfully. ID: {id}"),
        Err(e) => println!("Failed to add episodic memory: {e}"),
    }

    // --- Query and Display Results ---
    println!("\nQuerying semantic memory for 'cat':");
    let cat_query = "information about cats";
    match llm_brain.recall(cat_query, 2).await {
        // Recall top 2
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{cat_query}': {e}"),
    }

    println!("\nQuerying episodic memory:");
    let episode_query = "cat observation in garden";
    match llm_brain.recall(episode_query, 1).await {
        Ok(results) => {
            println!("Found {} memories:", results.len());
            for (fragment, score) in results {
                println!(
                    "- Score: {:.4}, Content: {:.80}...",
                    score, fragment.content
                );
                println!(
                    "  Metadata: {}",
                    serde_json::to_string_pretty(&fragment.metadata)?
                );
            }
        }
        Err(e) => println!("Failed to recall memories for '{episode_query}': {e}"),
    }

    println!("\nDemo completed successfully!");
    println!("Note: Database file created at ./llm_brain_basic_demo_db (if it didn't exist).");

    Ok(())
}

examples/embedding_demo.rs (line 62)

async fn main() -> Result<()> {
    // Initialize LLMBrain instance
    println!("Initializing LLMBrain...");
    let llm_brain = LLMBrain::launch().await?;

    // Demo 1: Basic embedding generation and query
    println!("\n--- Basic Embedding Demo ---");

    // Add several memories
    let memories = vec![
        (
            "Cats are small mammals with fur, whiskers, and tails. They eat mice and birds, and are related to tigers and lions.",
            json!({
                "name": "Cat",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "whiskers", "tail"],
                    "diet": "carnivorous"
                }
            }),
        ),
        (
            "Dogs are one of the earliest domesticated animals, loyal companions to humans, with various breeds and purposes.",
            json!({
                "name": "Dog",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "loyalty", "keen sense of smell"],
                    "uses": ["pet", "working dog", "guide dog"]
                }
            }),
        ),
        (
            "Birds are warm-blooded vertebrates, covered with feathers, with forelimbs evolved into wings, and most can fly.",
            json!({
                "name": "Bird",
                "type": "Animal",
                "properties": {
                    "characteristics": ["feathers", "wings", "beak"],
                    "abilities": ["flying", "nest building", "singing"]
                }
            }),
        ),
    ];

    // Add memories to database
    for (content, metadata) in memories {
        let memory_id = llm_brain.add_memory(content.to_owned(), metadata).await?;
        println!("Added memory: ID={memory_id}");
    }

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related memories using semantic search
    println!("\nQuerying memories about 'pets':");
    let results = llm_brain.recall("pets and human relationships", 2).await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Demo 2: Long text processing
    println!("\n--- Long Text Processing Demo ---");

    // Prepare a longer text
    let long_text = r#"
        Artificial Intelligence (AI) is a branch of computer science aimed at creating systems capable of simulating human intelligence behaviors.
        AI research includes multiple sub-fields such as machine learning, deep learning, natural language processing, computer vision, expert systems, etc.
        Machine learning is one of the core technologies of AI, using statistical techniques to enable computer systems to "learn" (i.e., progressively improve performance) without explicit programming.
        Deep learning is a subset of machine learning that uses multi-layered neural networks to process data. These networks extract features from data, with each layer building on the output of the previous one.
        Large Language Models (LLMs) are a significant breakthrough in AI in recent years, generating human-like text, understanding context, and performing various language tasks by learning from vast amounts of text data.
        Vector embeddings are techniques for representing text, images, or other data as points in a multi-dimensional vector space, playing an important role in information retrieval, recommendation systems, and semantic search.
    "#;

    println!("Long text content:\n{long_text}");

    // Process long text using different strategies
    println!("\nUsing default strategy (no chunking):");
    let embedding1 = llm_brain.process_long_text(long_text, None).await?;
    println!("Generated embedding vector length: {}", embedding1.len());

    println!("\nUsing chunk and average strategy:");
    let chunk_strategy = ChunkingStrategy::ChunkAndAverage {
        chunk_size: 100,
        chunk_overlap: 20,
    };
    let embedding2 = llm_brain
        .process_long_text(long_text, Some(chunk_strategy))
        .await?;
    println!("Generated embedding vector length: {}", embedding2.len());

    // Calculate similarity between embeddings generated by different strategies
    let similarity = cosine_similarity(&embedding1, &embedding2);
    println!("\nCosine similarity between embeddings from two strategies: {similarity:.4}");

    // Demo 3: Adding long text to memory
    println!("\n--- Adding Long Text Memory Demo ---");

    let metadata = json!({
        "name": "Artificial Intelligence Overview",
        "type": "Knowledge",
        "tags": ["AI", "Machine Learning", "Deep Learning"]
    });

    let memory_id = llm_brain.add_memory(long_text.to_owned(), metadata).await?;
    println!("Added long text memory: ID={memory_id}");

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related content
    println!("\nQuerying memories about 'large language models':");
    let results = llm_brain
        .recall("large language models and vector embeddings", 1)
        .await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content summary: {}", truncate_text(&memory.content, 100));
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    println!("\nDemo completed.");
    Ok(())
}

pub async fn process_long_text( &self, text: &str, strategy: Option<ChunkingStrategy>, ) -> Result<Vec<f32>>

Process long text using appropriate chunking strategy

Examples found in repository

examples/embedding_demo.rs (line 89)

async fn main() -> Result<()> {
    // Initialize LLMBrain instance
    println!("Initializing LLMBrain...");
    let llm_brain = LLMBrain::launch().await?;

    // Demo 1: Basic embedding generation and query
    println!("\n--- Basic Embedding Demo ---");

    // Add several memories
    let memories = vec![
        (
            "Cats are small mammals with fur, whiskers, and tails. They eat mice and birds, and are related to tigers and lions.",
            json!({
                "name": "Cat",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "whiskers", "tail"],
                    "diet": "carnivorous"
                }
            }),
        ),
        (
            "Dogs are one of the earliest domesticated animals, loyal companions to humans, with various breeds and purposes.",
            json!({
                "name": "Dog",
                "type": "Animal",
                "properties": {
                    "characteristics": ["fur", "loyalty", "keen sense of smell"],
                    "uses": ["pet", "working dog", "guide dog"]
                }
            }),
        ),
        (
            "Birds are warm-blooded vertebrates, covered with feathers, with forelimbs evolved into wings, and most can fly.",
            json!({
                "name": "Bird",
                "type": "Animal",
                "properties": {
                    "characteristics": ["feathers", "wings", "beak"],
                    "abilities": ["flying", "nest building", "singing"]
                }
            }),
        ),
    ];

    // Add memories to database
    for (content, metadata) in memories {
        let memory_id = llm_brain.add_memory(content.to_owned(), metadata).await?;
        println!("Added memory: ID={memory_id}");
    }

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related memories using semantic search
    println!("\nQuerying memories about 'pets':");
    let results = llm_brain.recall("pets and human relationships", 2).await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content: {}", memory.content);
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    // Demo 2: Long text processing
    println!("\n--- Long Text Processing Demo ---");

    // Prepare a longer text
    let long_text = r#"
        Artificial Intelligence (AI) is a branch of computer science aimed at creating systems capable of simulating human intelligence behaviors.
        AI research includes multiple sub-fields such as machine learning, deep learning, natural language processing, computer vision, expert systems, etc.
        Machine learning is one of the core technologies of AI, using statistical techniques to enable computer systems to "learn" (i.e., progressively improve performance) without explicit programming.
        Deep learning is a subset of machine learning that uses multi-layered neural networks to process data. These networks extract features from data, with each layer building on the output of the previous one.
        Large Language Models (LLMs) are a significant breakthrough in AI in recent years, generating human-like text, understanding context, and performing various language tasks by learning from vast amounts of text data.
        Vector embeddings are techniques for representing text, images, or other data as points in a multi-dimensional vector space, playing an important role in information retrieval, recommendation systems, and semantic search.
    "#;

    println!("Long text content:\n{long_text}");

    // Process long text using different strategies
    println!("\nUsing default strategy (no chunking):");
    let embedding1 = llm_brain.process_long_text(long_text, None).await?;
    println!("Generated embedding vector length: {}", embedding1.len());

    println!("\nUsing chunk and average strategy:");
    let chunk_strategy = ChunkingStrategy::ChunkAndAverage {
        chunk_size: 100,
        chunk_overlap: 20,
    };
    let embedding2 = llm_brain
        .process_long_text(long_text, Some(chunk_strategy))
        .await?;
    println!("Generated embedding vector length: {}", embedding2.len());

    // Calculate similarity between embeddings generated by different strategies
    let similarity = cosine_similarity(&embedding1, &embedding2);
    println!("\nCosine similarity between embeddings from two strategies: {similarity:.4}");

    // Demo 3: Adding long text to memory
    println!("\n--- Adding Long Text Memory Demo ---");

    let metadata = json!({
        "name": "Artificial Intelligence Overview",
        "type": "Knowledge",
        "tags": ["AI", "Machine Learning", "Deep Learning"]
    });

    let memory_id = llm_brain.add_memory(long_text.to_owned(), metadata).await?;
    println!("Added long text memory: ID={memory_id}");

    // Wait for embedding processing to complete
    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;

    // Query related content
    println!("\nQuerying memories about 'large language models':");
    let results = llm_brain
        .recall("large language models and vector embeddings", 1)
        .await?;
    for (i, (memory, score)) in results.iter().enumerate() {
        println!("\nResult {}: Similarity {:.4}", i + 1, score);
        println!("Content summary: {}", truncate_text(&memory.content, 100));
        println!(
            "Metadata: {}",
            serde_json::to_string_pretty(&memory.metadata)?
        );
    }

    println!("\nDemo completed.");
    Ok(())
}

pub async fn get_memory_by_id_string( &self, id_string: &str, ) -> Result<Option<MemoryFragment>>

Retrieves a specific memory by its SurrealDB ID string.

Returns None if no memory with the given ID exists.

Examples found in repository

examples/comprehensive_demo.rs (line 210)

async fn demonstrate_memory_lookup(llm_brain: &LLMBrain) -> Result<()> {
    println!("\n=== Demonstrating Memory Lookup ===");

    // Add a new memory about a trip
    println!("\nAdding memory about a road trip...");
    let trip_data = json!({
        "name": "Road_Trip_Tahoe",
        "column": "Episodic",
        "timestamp": Utc::now().to_rfc3339(),
        "properties": {
            "action": "Road trip to Lake Tahoe",
            "location": "Lake Tahoe",
            "participants": ["Me", "Family"],
            "duration": "3 days",
            "transportation": "Tesla Model 3",
            "highlights": ["Beautiful scenery", "Hiking", "Swimming"]
        }
    });

    let trip_content = "Last weekend, we took our Tesla Model 3 on a road trip to Lake Tahoe. \
                       The drive was smooth and we enjoyed the beautiful scenery. \
                       We spent 3 days there with the family, hiking and swimming in the lake. \
                       The car performed excellently on the mountain roads.";

    let trip_id = llm_brain
        .add_memory(trip_content.to_owned(), trip_data)
        .await?;
    println!("Added trip memory with ID: {trip_id}");

    // Allow time for embeddings to be processed
    sleep(Duration::from_millis(200)).await;

    // Now try to find this memory with various related queries
    let queries = [
        "Did we go on any trips with our Tesla?",
        "What activities did we do at Lake Tahoe?",
        "How did the Tesla perform on our road trip?",
    ];

    for (i, query) in queries.iter().enumerate() {
        println!("\nQuery {}: \"{}\"", i + 1, query);
        let results = llm_brain.recall(query, 1).await?;

        if !results.is_empty() {
            let (memory, score) = &results[0];
            println!("Found memory (score: {score:.4}):");
            println!("Content: {}", memory.content);
        } else {
            println!("No relevant memories found.");
        }
    }

    // Direct lookup by ID
    println!("\nDirect lookup by ID:");
    if let Some(memory) = llm_brain
        .get_memory_by_id_string(&trip_id.to_string())
        .await?
    {
        println!("Successfully retrieved memory");
        println!("Content: {}", memory.content);
    } else {
        println!("Failed to retrieve memory by ID");
    }

    Ok(())
}

Trait Implementations

impl Clone for LLMBrain

fn clone(&self) -> LLMBrain

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.