Struct AgenticDB 

pub struct AgenticDB { /* private fields */ }

Main AgenticDB interface

Implementations

impl AgenticDB

pub fn new(options: DbOptions) -> Result<Self>

Create a new AgenticDB with the given options and default hash-based embeddings

pub fn with_embedding_provider( options: DbOptions, embedding_provider: BoxedEmbeddingProvider, ) -> Result<Self>

Create a new AgenticDB with a custom embedding provider

Example with API embeddings

use ruvector_core::{AgenticDB, ApiEmbedding};
use ruvector_core::types::DbOptions;
use std::sync::Arc;

let mut options = DbOptions::default();
options.dimensions = 1536; // OpenAI embedding dimensions
options.storage_path = "agenticdb.db".to_string();

let provider = Arc::new(ApiEmbedding::openai("sk-...", "text-embedding-3-small"));
let db = AgenticDB::with_embedding_provider(options, provider)?;

Example with Candle (requires feature flag)

use ruvector_core::{AgenticDB, CandleEmbedding};
use ruvector_core::types::DbOptions;
use std::sync::Arc;

let mut options = DbOptions::default();
options.dimensions = 384; // MiniLM dimensions
options.storage_path = "agenticdb.db".to_string();

let provider = Arc::new(CandleEmbedding::from_pretrained(
    "sentence-transformers/all-MiniLM-L6-v2",
    false
)?);
let db = AgenticDB::with_embedding_provider(options, provider)?;

pub fn with_dimensions(dimensions: usize) -> Result<Self>

Create with default options and hash-based embeddings

pub fn embedding_provider_name(&self) -> &str

Get the embedding provider name (for debugging/logging)

pub fn insert(&self, entry: VectorEntry) -> Result<VectorId>

Insert a vector entry

pub fn insert_batch(&self, entries: Vec<VectorEntry>) -> Result<Vec<VectorId>>

Insert multiple vectors in a batch

pub fn search(&self, query: SearchQuery) -> Result<Vec<SearchResult>>

Search for similar vectors

pub fn delete(&self, id: &str) -> Result<bool>

Delete a vector by ID

pub fn get(&self, id: &str) -> Result<Option<VectorEntry>>

Get a vector by ID

pub fn store_episode( &self, task: String, actions: Vec<String>, observations: Vec<String>, critique: String, ) -> Result<String>

Store a reflexion episode with self-critique

pub fn retrieve_similar_episodes( &self, query: &str, k: usize, ) -> Result<Vec<ReflexionEpisode>>

Retrieve similar reflexion episodes

pub fn create_skill( &self, name: String, description: String, parameters: HashMap<String, String>, examples: Vec<String>, ) -> Result<String>

Create a new skill in the library

pub fn search_skills( &self, query_description: &str, k: usize, ) -> Result<Vec<Skill>>

Search skills by description

pub fn auto_consolidate( &self, action_sequences: Vec<Vec<String>>, success_threshold: usize, ) -> Result<Vec<String>>

Auto-consolidate action sequences into skills

pub fn add_causal_edge( &self, causes: Vec<String>, effects: Vec<String>, confidence: f64, context: String, ) -> Result<String>

Add a causal edge (supporting hypergraphs with multiple causes/effects)

pub fn query_with_utility( &self, query: &str, k: usize, alpha: f64, beta: f64, gamma: f64, ) -> Result<Vec<UtilitySearchResult>>

Query with utility function: U = α·similarity + β·causal_uplift − γ·latency

pub fn start_session( &self, algorithm: String, state_dim: usize, action_dim: usize, ) -> Result<String>

Start a new learning session

pub fn add_experience( &self, session_id: &str, state: Vec<f32>, action: Vec<f32>, reward: f64, next_state: Vec<f32>, done: bool, ) -> Result<()>

Add an experience to a learning session

pub fn predict_with_confidence( &self, session_id: &str, state: Vec<f32>, ) -> Result<Prediction>

Predict action with confidence interval

pub fn get_session(&self, session_id: &str) -> Result<Option<LearningSession>>

Get learning session by ID