//! # Cerebro 🧠
//!
//! **Cerebro** is a blazing-fast, storage-agnostic semantic memory engine
//! for AI Agents and LLM applications, written in pure Rust.
//!
//! ## Quick Start
//!
//! ```rust,no_run
//! use cerebro::prelude::*;
//! use std::sync::Arc;
//!
//! #[tokio::main]
//! async fn main() {
//!     let chunker = Arc::new(RecursiveCharacterChunker::new(512, 50));
//!     let embedder = Arc::new(MockEmbedder::new(1536));
//!     let store = Arc::new(MemoryVectorStore::new());
//!
//!     let engine = MemoryEngine::new(chunker, embedder, store);
//!
//!     let doc = Document::new("Rust ensures memory safety without a garbage collector.");
//!     engine.ingest_document(doc).await.unwrap();
//!
//!     let results = engine.query("memory safety", 5).await.unwrap();
//!     for (node, score) in results {
//!         println!("Score {:.3}: {}", score, node.chunk.text);
//!     }
//! }
//! ```

pub mod models;
pub mod traits;
pub mod chunker;
pub mod engine;
pub mod storage;
pub mod compute;
pub mod ingest;
pub mod ffi;

// Re-export core types at the crate root
pub use models::*;
pub use traits::*;

/// Convenience prelude — `use cerebro::prelude::*` to import everything you need.
pub mod prelude {
    pub use crate::models::*;
    pub use crate::traits::*;
    pub use crate::chunker::*;
    pub use crate::engine::*;
    pub use crate::storage::memory::*;
    pub use crate::compute::mock::*;
    pub use crate::compute::openai::*;
}
