cel-memory-duckdb 0.1.0

//! Minimal `cel-memory-duckdb` example.
//!
//! Run with: `cargo run --example basic`

use std::sync::Arc;

use cel_memory::{
    ChunkKind, ChunkSource, MemoryProvider, NewMemoryChunk, NewMemorySession, SessionOutcome,
};
use cel_memory_duckdb::{DuckdbMemoryProvider, MockEmbedder};

#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let dir = tempfile::tempdir()?;
    let db_path = dir.path().join("memory.duckdb");
    let embedder = Arc::new(MockEmbedder::new());
    let provider = DuckdbMemoryProvider::open(&db_path, embedder).await?;
    println!("opened DuckdbMemoryProvider at {}", db_path.display());

    let session = provider
        .open_session(NewMemorySession {
            caller_id: "example".into(),
            title: Some("basic-example".into()),
            metadata: serde_json::json!({}),
        })
        .await?;
    println!("opened session {}", session.id);

    for i in 0..10 {
        provider
            .write(NewMemoryChunk {
                kind: ChunkKind::Chat,
                source: ChunkSource::Embedded,
                session_id: Some(session.id.clone()),
                project_root: None,
                caller_id: "example".into(),
                content: format!("chunk number {i} — synthetic content for the basic example"),
                metadata: serde_json::json!({ "index": i }),
                importance: None,
                shareable: false,
                pinned: false,
            })
            .await?;
    }

    let stats = provider.stats().await?;
    println!(
        "stats: total_chunks={}, total_sessions={}, embedding_model={:?}",
        stats.total_chunks, stats.total_sessions, stats.embedding_model
    );

    provider
        .close_session(&session.id, SessionOutcome::Success)
        .await?;
    println!("closed session and finished cleanly");

    Ok(())
}