[dependencies]
embeddings = { path = "../embeddings" }
storage = { path = "../storage" }
tokio = { version = "1.42", features = ["full"] }
anyhow = "1.0"
tracing-subscriber = "0.3"
dotenv = "0.15"

[features]
openai = ["embeddings/openai"]

OPENAI_API_KEY=sk-proj-your-api-key-here
OPENAI_EMBEDDING_MODEL=text-embedding-3-small
EMBEDDING_CACHE_SIZE=1000

use embeddings::{create_embedding_service, EmbeddingConfig, EmbeddingCache};
use storage::{HybridMemoryStore, MemoryStore, SqliteMemoryStore, QdrantMemoryStore};
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize logging
    tracing_subscriber::fmt::init();
    
    // Load environment variables
    if let Ok(_) = dotenv::from_filename("openai.env") {
        println!("Loaded configuration from openai.env");
    }
    
    // Create embedding service
    let embedding_config = if cfg!(feature = "openai") && std::env::var("OPENAI_API_KEY").is_ok() {
        println!("Using OpenAI API for embeddings");
        EmbeddingConfig::openai(std::env::var("OPENAI_API_KEY").unwrap())
    } else {
        println!("Using mock embeddings");
        EmbeddingConfig::default()
    };
    
    let embedding_service = create_embedding_service(&embedding_config).await?;
    let embedding_cache = EmbeddingCache::new(100);
    
    // Create storage
    let sqlite = Arc::new(SqliteMemoryStore::in_memory()?);
    let vector = Arc::new(QdrantMemoryStore::new("mock://")?);
    let store = HybridMemoryStore::new(sqlite, vector);
    
    Ok(())
}

use storage::{MemoryEvent, MemoryMetadata};

// Sample memories to store
let memories = vec![
    ("I love pizza with extra cheese", vec!["food", "preference"]),
    ("The weather is sunny today in San Francisco", vec!["weather", "location"]),
    ("Remember to buy milk and eggs", vec!["todo", "shopping"]),
    ("My favorite programming language is Rust", vec!["tech", "preference"]),
    ("The meeting is scheduled for 3 PM tomorrow", vec!["schedule", "work"]),
];

println!("Storing memories with embeddings...");

for (content, tags) in memories {
    // Check cache first
    let embedding = if let Some(cached) = embedding_cache.get(content) {
        println!("  Using cached embedding for: {}", content);
        cached
    } else {
        // Generate embedding
        let embedding = embedding_service.generate_embedding(content).await?;
        embedding_cache.put(content, embedding.clone());
        println!("  Generated embedding for: {}", content);
        embedding
    };
    
    // Create memory event
    let event = MemoryEvent::new(
        content.to_string(),
        embedding,
        MemoryMetadata {
            source: "example".to_string(),
            tags: tags.iter().map(|s| s.to_string()).collect(),
            confidence: 0.9,
            ..Default::default()
        },
    );
    
    // Store in database
    store.insert(&event).await?;
}

// Queries to test
let queries = vec![
    "What food do I like?",
    "Tell me about the weather",
    "What should I remember to do?",
    "Programming languages",
];

for query in queries {
    println!("\nQuery: '{}'", query);
    
    // Generate query embedding
    let query_embedding = embedding_service.generate_embedding(query).await?;
    
    // Search for similar memories
    let results = store.search_by_embedding(&query_embedding, 3).await?;
    
    println!("Top {} results:", results.len());
    for (i, result) in results.iter().enumerate() {
        println!("  {}. [Score: {:.3}] {}", 
            i + 1, 
            result.score, 
            result.event.content
        );
        if !result.event.metadata.tags.is_empty() {
            println!("     Tags: {}", result.event.metadata.tags.join(", "));
        }
    }
}

let texts = vec![
    "First document about AI".to_string(),
    "Second document about ML".to_string(),
    "Third document about data science".to_string(),
];

// Generate embeddings in batch
let embeddings = embedding_service.generate_embeddings(&texts).await?;

// Store all at once
for (text, embedding) in texts.iter().zip(embeddings.iter()) {
    let event = MemoryEvent::new(
        text.clone(),
        embedding.clone(),
        MemoryMetadata::default(),
    );
    store.insert(&event).await?;
}

use storage::{SearchFilter};

let filter = SearchFilter {
    tags: Some(vec!["food".to_string(), "preference".to_string()]),
    sources: Some(vec!["conversation".to_string()]),
    min_confidence: Some(0.8),
    time_range: None,
};

let results = store.search_by_embedding_filtered(
    &query_embedding, 
    5,     // top_k
    filter
).await?;

let results = store.search_by_embedding(&query_embedding, 10).await?;

// Filter by similarity score
let relevant_results: Vec<_> = results
    .into_iter()
    .filter(|r| r.score > 0.7)  // Only high similarity
    .collect();

// Create a larger cache for production
let cache = EmbeddingCache::new(10000);

// Pre-warm cache with common queries
let common_queries = vec!["weather", "schedule", "tasks", "preferences"];
for query in common_queries {
    let embedding = embedding_service.generate_embedding(query).await?;
    cache.put(query, embedding);
}

// Instead of this:
for text in texts {
    let embedding = service.generate_embedding(&text).await?;
    // Process...
}

// Do this:
let embeddings = service.generate_embeddings(&texts).await?;
for (text, embedding) in texts.iter().zip(embeddings.iter()) {
    // Process...
}

// Use in-memory for testing
let store = SqliteMemoryStore::in_memory()?;

// Use file-based for production
let store = SqliteMemoryStore::new("memories.db")?;

// Enable WAL mode (done automatically)
// Provides better concurrent performance

cargo run --bin embedding_search

cargo run --bin embedding_search --features openai

kernel/examples/embedding_search.rs

cd kernel/examples
cargo run --bin embedding_search --features openai