Struct AgentDB 

pub struct AgentDB { /* private fields */ }

The main AgentDB connection — your single-file AI database.

Implementations

impl AgentDB

pub fn open(path: &str) -> Result<Self>

Open or create an AgentDB database. Use ":memory:" for tests.

pub fn vectors(&self) -> VectorStore

Access the vector store layer

pub fn memory(&self) -> MemoryGraph

Access the memory graph layer

pub fn fts(&self) -> FullTextStore

Access the full-text search layer

pub fn conversations(&self) -> ConversationStore

Access the conversation / message-threading layer

pub fn workflows(&self) -> WorkflowStore

Access the workflow persistence layer

pub fn traces(&self) -> TraceStore

Access the reasoning-trace layer

pub fn hybrid_query(&self, q: HybridQuery<'_>) -> Result<Vec<HybridResult>>

Run a hybrid graph + vector query

pub fn execute(&self, sql: &str) -> Result<usize>

Execute a raw SQL statement

pub fn execute_params(&self, sql: &str, params: &[&dyn ToSql]) -> Result<usize>

Execute a parameterized SQL statement

pub fn transaction<F, T>(&self, f: F) -> Result<T>

where F: FnOnce(&Transaction<'_>) -> Result<T>,

Run multiple operations atomically inside a single SQLite transaction.

The closure receives a rusqlite::Transaction and may perform any number of reads or writes. If the closure returns Ok, the transaction is committed; if it returns Err (or panics), the transaction is rolled back automatically.

Example

let db = AgentDB::open(":memory:").unwrap();
db.transaction(|tx| {
    tx.execute("INSERT INTO _adb_nodes (id, kind, data, created_at, updated_at) VALUES ('x','tag','{}',0,0)", [])?;
    tx.execute("INSERT INTO _adb_nodes (id, kind, data, created_at, updated_at) VALUES ('y','tag','{}',0,0)", [])?;
    Ok(())
}).unwrap();

pub fn execute_batch(&self, sql: &str) -> Result<()>

Execute one or more semicolon-separated SQL statements as a single atomic batch. This is a convenience wrapper around execute_batch that wraps the statements in an explicit transaction so partial execution is never visible to other threads.

Example

let db = AgentDB::open(":memory:").unwrap();
db.execute_batch(
    "INSERT INTO _adb_nodes (id,kind,data,created_at,updated_at) VALUES ('a','t','{}',0,0);
     INSERT INTO _adb_nodes (id,kind,data,created_at,updated_at) VALUES ('b','t','{}',0,0);"
).unwrap();

pub fn query_json(&self, sql: &str) -> Result<Vec<Value>>

Query and return rows as JSON values

pub fn query_json_params( &self, sql: &str, params: &[&dyn ToSql], ) -> Result<Vec<Value>>

Query with parameters and return rows as JSON values.

Use this for any query involving user-supplied values to prevent SQL injection.

Example

let db = AgentDB::open(":memory:").unwrap();
let rows = db.query_json_params(
    "SELECT * FROM _adb_nodes WHERE kind = ?1",
    &[&"session" as &dyn rusqlite::ToSql],
).unwrap();

pub fn close(self) -> Result<()>

Flush dirty HNSW indexes and close gracefully.

After this returns, the subsequent Drop is a no-op (no double flush).

pub fn stats(&self) -> Result<DbStats>

Return database-wide statistics (single-query implementation).

Trait Implementations

impl Clone for AgentDB

fn clone(&self) -> AgentDB

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for AgentDB

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.