agentdb

Stores and indexes embeddings using a proprietary RVF (RuVector Format) native binary format optimized for agentic workloads, with HNSW (Hierarchical Navigable Small World) graph indexing for approximate nearest neighbor search. The format is designed for rapid serialization/deserialization and supports sparse vector representations, enabling 150x faster retrieval than SQLite while maintaining ACID compliance through write-ahead logging and copy-on-write branching semantics.

Exposes a RuVector-powered graph database layer supporting Cypher query language for traversing relationships between agent memories, skills, and causal chains. Queries are compiled to optimized graph traversal operations over the underlying HNSW structure, enabling pattern matching, path finding, and relationship filtering without requiring separate graph DB infrastructure. Results include provenance chains showing how conclusions were derived.

Implements automated memory consolidation processes that move episodic memories (specific experiences) to semantic memory (general knowledge) as they become stable and frequently accessed. Consolidation uses clustering and abstraction to extract generalizable patterns from episodic traces, creating reusable knowledge that reduces future query latency. Procedural memory (skills) is similarly consolidated from repeated successful task executions, creating learned routines that can be invoked directly without re-reasoning.

Maintains a structured library of learned skills with explicit dependency graphs showing prerequisites and composition relationships. Skills are stored as procedural memories with parameters, success conditions, and applicability heuristics. The dependency graph enables skill composition — complex tasks are decomposed into learned skills, with the system automatically checking prerequisites and sequencing execution. Skills can be shared across agents and versioned for reproducibility.

Implements the Reflexion pattern where agents evaluate their own outputs, identify failures or suboptimal decisions, and update their reasoning strategies accordingly. Failed trajectories are stored with analysis of what went wrong, creating a feedback loop for self-improvement. The system tracks which reasoning patterns lead to success vs failure, gradually improving decision quality without external supervision. Reflexion operates on causal chains, enabling agents to identify specific reasoning steps that caused failures.

Implements six distinct memory patterns for agents: episodic (timestamped experiences), semantic (facts and concepts), procedural (skills and routines), working (active context), long-term (consolidated knowledge), and causal (decision chains). Each pattern uses specialized indexing and retrieval strategies — episodic uses temporal ordering, semantic uses embedding similarity, procedural uses skill graphs, causal uses provenance chains. Patterns are composable, allowing agents to query across memory types with unified interface.

Routes incoming queries and observations to appropriate memory patterns and retrieval strategies using a self-learning Graph Neural Network (GNN) that observes which memory patterns produce useful results. The GNN learns routing weights over time, optimizing which memory type (episodic, semantic, procedural, causal) to query first based on query characteristics and historical success rates. Routing decisions are cached and updated asynchronously, reducing latency for repeated query patterns.

Implements COW (Copy-on-Write) branching semantics for agent state, allowing agents to fork memory snapshots, explore alternative reasoning paths, and merge results without copying entire database. Each branch maintains isolated view of memory with lazy copying — only modified pages are copied, reducing memory overhead. Snapshot isolation ensures branches see consistent state at fork time, enabling safe parallel exploration and rollback to previous states without affecting other branches.

Provides ACID (Atomicity, Consistency, Isolation, Durability) guarantees for agent memory using write-ahead logging (WAL) and transactional semantics. All modifications are logged before application, enabling recovery from crashes and ensuring no data loss. Transactions can span multiple memory patterns (episodic, semantic, causal) with isolation levels preventing dirty reads and phantom updates. Durability is configurable — synchronous for critical operations, asynchronous for performance.

Supports both dense and sparse vector representations with specialized indexing strategies for each. Sparse vectors (common in NLP and recommendation systems) are indexed using inverted indices rather than HNSW, reducing memory overhead by 50-90%. Partial indexing allows selective indexing of vector subsets based on metadata filters, enabling efficient queries over filtered datasets without materializing full index. Hybrid queries combine sparse and dense results with learned fusion weights.

Trains a Graph Neural Network on agent's memory access patterns to learn which memory structures and retrieval strategies are most effective. The GNN observes query types, memory patterns accessed, and retrieval quality, then optimizes index structures and caching strategies accordingly. Learning is continuous and asynchronous — the system adapts to changing query patterns without requiring manual tuning or downtime.

Tracks full provenance of agent decisions and retrieved memories through causal chains showing how conclusions were derived. Each memory retrieval, reasoning step, and decision is linked to source observations and intermediate inferences, creating an auditable chain from raw input to final output. Provenance chains support multiple explanation types: causal (why was this decision made), counterfactual (what if different input), and contrastive (why this over alternatives).

Executes AgentDB in browser or Node.js using WebAssembly (WASM) for performance-critical operations (HNSW indexing, GNN inference), with SQL.js fallback for environments without WASM support. WASM modules are pre-compiled and bundled, enabling instant startup without build steps. SQL.js provides SQLite-compatible interface for queries, allowing agents to run entirely client-side without server dependency. Data is persisted to IndexedDB (browser) or filesystem (Node.js).