Skip to content
Back to search

agentdb

MarketplaceWorks with Claude CodeGitHub

AgentDB Marketplace: vector memory, episodic recall, causal graph, RL routing, and advanced retrieval — all backed by the agentdb npm package

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked yesterday
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ruvnet--agentdb/badge.svg)](/listings/ruvnet--agentdb)

HTML

<a href="/listings/ruvnet--agentdb"><img src="/api/listings/ruvnet--agentdb/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Node.js 20.9.0 or newer is required, matching the patched sharp runtime used by local Transformers embeddings and better-sqlite3 12. Node 18 is no longer supported.

There are **three ways to use AgentDB** depending on what you're building. Pick whichever matches your stack:

| | **npm library** | **CLI** | **MCP server** | |---|---|---|---| | **What you get** | TypeScript / JS API for any Node app | `agentdb` binary, scriptable from any shell | 41 tools callable from Claude Code, Cursor, Cline, etc. | | **Install** | `npm i agentdb` | `npx agentdb …` (no install) | `claude mcp add agentdb -- npx agentdb mcp start` | | **Best for** | Embedding the engine in your own code | Quick experiments, CI scripts, ad-hoc memory | Plugging memory + learning into an LLM agent |

Path A — npm library

npm install agentdb
import { SelfLearningRvfBackend } from 'agentdb/backends/self-learning';

const db = await SelfLearningRvfBackend.create({
  dimension: 384,
  learning: true,
  storagePath: './memory.rvf',
});

// Use your embedding model here; any 384-dim Float32Array works.
const embedding = Float32Array.from({ length: 384 }, (_, i) => Math.sin(i));
await db.insertAsync('doc1', embedding, { text: 'Hello world' });
const hits = await db.searchAsync(embedding, 5);
db.recordFeedback(hits[0].id, 1.0);  // it was useful — db gets smarter

Path B — CLI in 10 seconds

# Try it without installing (creates ./agentdb.db)
npx agentdb init
npx agentdb reflexion store "session-1" "implement_auth" 0.95 true "Used OAuth2 with PKCE"
npx agentdb reflexion retrieve "authentication" --k 5

Path C — MCP server (Claude Code, Cursor, etc.)

claude mcp add agentdb -- npx agentdb@latest mcp start

That registers 41 MCP tools — `agentdb_pattern_store`, `agentdb_pattern_search`, `agentdb_hierarchical_store`, `agentdb_causal_edge`, `agentdb_skill_library`, `agentdb_reflexion`, etc. They call the same engine the npm library does, just over Claude's tool-calling surface.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 55 lines
  1. {
  2. "name": "agentdb",
  3. "description": "AgentDB Marketplace: vector memory, episodic recall, causal graph, RL routing, and advanced retrieval — all backed by the agentdb npm package",
  4. "owner": {
  5. "name": "ruvnet",
  6. "url": "https://github.com/ruvnet"
  7. },
  8. "plugins": [
  9. {
  10. "name": "agentdb",
  11. "source": "./plugins/agentdb",
  12. "description": "AgentDB's own standalone MCP server (npx agentdb mcp start, pinned to the plugin version) with a memory specialist agent, vector-memory, reflexion-learning and setup-diagnostics skills, /agentdb-status, and a mod that keeps secrets out of memory and refuses destructive admin tools unless enabled. Supplies the agentdb server the other agentdb-* plugins call. Distinct from ruflo-agentdb, which bridges AgentDB through ruflo's MCP server.",
  13. "category": "memory",
  14. "tags": [
  15. "agentdb",
  16. "memory",
  17. "vector-search",
  18. "reflexion",
  19. "learning",
  20. "mcp",
  21. "mod"
  22. ]
  23. },
  24. {
  25. "name": "agentdb-core",
  26. "source": "./plugins/agentdb-core",
  27. "description": "Foundation plugin — pattern store, search, stats. Surfaces agentdb_pattern_store, agentdb_pattern_search, agentdb_pattern_stats."
  28. },
  29. {
  30. "name": "agentdb-memory",
  31. "source": "./plugins/agentdb-memory",
  32. "description": "Episodic replay (Reflexion) + skill library. /remember and /recall slash commands; agentdb-curator agent for nightly consolidation; aidefence prompt-injection screening of memory writes."
  33. },
  34. {
  35. "name": "agentdb-causal",
  36. "source": "./plugins/agentdb-causal",
  37. "description": "Causal graph + hierarchical memory. /link and /explain-link slash commands; agentdb-investigator agent for root-cause traversal."
  38. },
  39. {
  40. "name": "agentdb-learning",
  41. "source": "./plugins/agentdb-learning",
  42. "description": "RL + Thompson Sampling bandit. 9 algorithms (Q-Learning, PPO, MCTS, etc.); /learn-task and /route-task slash commands."
  43. },
  44. {
  45. "name": "agentdb-graph",
  46. "source": "./plugins/agentdb-graph",
  47. "description": "Graph queries — Cypher execution, k-hop traversal, hyperedge search, plus exact min cut (@ruvector/mincut-wasm) and Personalized PageRank sparsification (@ruvector/graph-transformer)."
  48. },
  49. {
  50. "name": "agentdb-search",
  51. "source": "./plugins/agentdb-search",
  52. "description": "Advanced retrieval — MMR diversity rerank, explainable recall, metadata filters, hybrid (BM25 + dense) search, and the opt-in RaBitQ quantized index (@ruvector/rabitq-wasm)."
  53. }
  54. ]
  55. }
README.md · README · 412 lines
  1. <div align="center">
  2. [![npm version](https://img.shields.io/npm/v/agentdb.svg?style=for-the-badge&logo=npm&color=cb3837)](https://www.npmjs.com/package/agentdb)
  3. [![npm downloads](https://img.shields.io/npm/dm/agentdb.svg?style=for-the-badge&logo=npm&color=cb3837)](https://www.npmjs.com/package/agentdb)
  4. [![License](https://img.shields.io/badge/License-MIT_OR_Apache--2.0-yellow?style=for-the-badge)](LICENSE)
  5. [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178c6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
  6. [![🕸️ RuVector Engine](https://img.shields.io/badge/RuVector_Engine-Rust_+_NAPI-06b6d4?style=for-the-badge&logoColor=white&logo=rust)](https://github.com/ruvnet/ruvector)
  7. [![🧠 SONA Self-Learning](https://img.shields.io/badge/SONA-Self_Learning-8b5cf6?style=for-the-badge&logoColor=white)](#-self-learning-loop)
  8. [![🔌 MCP Compatible](https://img.shields.io/badge/MCP-41_tools-D97757?style=for-the-badge&logoColor=white&logo=anthropic)](#-mcp-integration)
  9. [![⭐ Star on GitHub](https://img.shields.io/github/stars/ruvnet/agentdb?style=for-the-badge&logo=github&color=gold)](https://github.com/ruvnet/agentdb)
  10. # AgentDB
  11. <!-- weaver:seo:flow:start -->
  12. ![agentdb: agent event → episodic memory → HNSW recall → MCP tools](https://raw.githubusercontent.com/ruvnet/agentdb/main/assets/agentdb-flow.svg)
  13. <!-- weaver:seo:flow:end -->
  14. **Vector memory that gets smarter every time your agent uses it.**
  15. </div>
  16. A single-file cognitive container — vectors, indexes, learning state, and a cryptographic audit trail in one `.rvf`. Self-learning search improves up to **36% from feedback alone**, with no manual tuning. Runs in Node, the browser, edge runtimes, and offline.
  17. <!-- ecosystem-cta:start -->
  18. ### Explore the wider ecosystem
  19. [![AgentDB: try ruOS. Conceptual project-to-destination animation.](docs/assets/ecosystem-cta.svg)](https://ruos.cognitum.one/)
  20. Building agents that remember? Explore the wider ecosystem.
  21. **[Explore Cognitum One](https://cognitum.one/) · [Try ruOS](https://ruos.cognitum.one/)**, an agentic desktop in your browser.
  22. <!-- ecosystem-cta:end -->
  23. ### Why AgentDB?
  24. > Most vector databases store embeddings and call it done. AgentDB watches *which* results your agent actually used, learns from that signal, and ranks the next query better. The bandit underneath also picks the right RL algorithm, the right compression tier, and the right pattern weighting on its own — so the database itself gets sharper while you focus on the agent.
  25. > The name: a database that thinks like an agent — episodic memory, skill library, causal reasoning, and a learning loop, all in one file. Built by [`rUv`](https://ruv.io) on the [`ruvector`](https://github.com/ruvnet/ruvector) Rust engine.
  26. ### What AgentDB Does
  27. ```
  28. Self-Learning Vector Memory
  29. Agent ──► AgentDB (.rvf) ──► HNSW search ──► top-k results
  30. │ │
  31. ▼ ▼
  32. recordFeedback(id, reward) ◄── agent uses some, ignores rest
  33. │
  34. ▼
  35. Bandit re-tunes ranking / RL choice / compression ──► next query is smarter
  36. ```
  37. > **3 lines to self-learning search:**
  38. > ```typescript
  39. > const backend = await SelfLearningRvfBackend.create({ learning: true, storagePath: "./my.rvf" });
  40. > const results = await backend.searchAsync(query, 10); // search
  41. > backend.recordFeedback(results[0].id, 0.9); // learn — next search is smarter
  42. > ```
  43. ---
  44. ## Quick Start
  45. Node.js 20.9.0 or newer is required, matching the patched sharp runtime used by local Transformers embeddings and better-sqlite3 12. Node 18 is no longer supported.
  46. There are **three ways to use AgentDB** depending on what you're building. Pick whichever matches your stack:
  47. | | **npm library** | **CLI** | **MCP server** |
  48. |---|---|---|---|
  49. | **What you get** | TypeScript / JS API for any Node app | `agentdb` binary, scriptable from any shell | 41 tools callable from Claude Code, Cursor, Cline, etc. |
  50. | **Install** | `npm i agentdb` | `npx agentdb …` (no install) | `claude mcp add agentdb -- npx agentdb mcp start` |
  51. | **Best for** | Embedding the engine in your own code | Quick experiments, CI scripts, ad-hoc memory | Plugging memory + learning into an LLM agent |
  52. ### Path A — npm library
  53. ```bash
  54. npm install agentdb
  55. ```
  56. ```typescript
  57. import { SelfLearningRvfBackend } from 'agentdb/backends/self-learning';
  58. const db = await SelfLearningRvfBackend.create({
  59. dimension: 384,
  60. learning: true,
  61. storagePath: './memory.rvf',
  62. });
  63. // Use your embedding model here; any 384-dim Float32Array works.
  64. const embedding = Float32Array.from({ length: 384 }, (_, i) => Math.sin(i));
  65. await db.insertAsync('doc1', embedding, { text: 'Hello world' });
  66. const hits = await db.searchAsync(embedding, 5);
  67. db.recordFeedback(hits[0].id, 1.0); // it was useful — db gets smarter
  68. ```
  69. ### Path B — CLI in 10 seconds
  70. ```bash
  71. # Try it without installing (creates ./agentdb.db)
  72. npx agentdb init
  73. npx agentdb reflexion store "session-1" "implement_auth" 0.95 true "Used OAuth2 with PKCE"
  74. npx agentdb reflexion retrieve "authentication" --k 5
  75. ```
  76. ### Path C — MCP server (Claude Code, Cursor, etc.)
  77. ```bash
  78. claude mcp add agentdb -- npx agentdb@latest mcp start
  79. ```
  80. That registers 41 MCP tools — `agentdb_pattern_store`, `agentdb_pattern_search`, `agentdb_hierarchical_store`, `agentdb_causal_edge`, `agentdb_skill_library`, `agentdb_reflexion`, etc. They call the same engine the npm library does, just over Claude's tool-calling surface.
  81. ---
  82. ## What You Get
  83. | Capability | Description |
  84. |------------|-------------|
  85. | 🧠 **Self-Learning Search** | Up to **+36% search quality** from feedback alone — Thompson Sampling bandit re-tunes ranking, RL choice, and compression tier with zero manual config |
  86. | 🐝 **Cognitive Memory** | 6 human-inspired patterns — episodic replay (Reflexion), skill library, causal reasoning, hierarchical context, semantic clustering, working memory |
  87. | 🤖 **9 RL Algorithms** | Q-Learning, SARSA, DQN, PPO, Actor-Critic, Policy Gradient, Decision Transformer, MCTS, Model-Based RL — bandit picks the right one per task |
  88. | ⚡ **150× faster than SQLite** | RuVector Rust engine via NAPI bindings; HNSW vector search; sub-millisecond reads on 100k+ vectors |
  89. | 🔍 **Hybrid Search** | BM25 keyword + dense vector fused with Reciprocal Rank Fusion — exact terms *and* semantic intent in one query |
  90. | 🕸️ **Graph Intelligence** | Cypher queries, causal edges, GNN 8-head attention (+12.4% recall), hyperedges for n-ary relationships |
  91. | 💾 **Single-file Storage** | Everything (vectors, indexes, learning state, audit log) in one `.rvf` "Cognitive Container" — no servers, no API keys, no monthly bills |
  92. | 🎯 **Quantization** | 4-32× memory reduction with PQ8 / PQ4 / binary quantization; minimal recall loss; runs on commodity hardware |
  93. | 🔌 **41 MCP Tools** | First-class Claude Code / Cursor / Cline integration — pattern store, search, skill library, reflexion, causal edges, hierarchical recall, delete |
  94. | 🌐 **Runs Anywhere** | Node, browser (WASM), edge runtimes, fully offline — same API, same `.rvf` file |
  95. | 🛡️ **Enterprise Security** | JWT auth, API key rotation, Argon2id hashing, SOC2 / GDPR audit trails, cryptographic witness chain |
  96. | 🔗 **agentic-flow Integration** | Drop-in for [`agentic-flow`](https://github.com/ruvnet/agentic-flow) — backs ReasoningBank, MemoryController, NightlyLearner, and 30+ agents |
  97. ### Optional native integrations
  98. Installed by default as optional dependencies. Each has a JavaScript fallback, so agentdb works without them ([ADR-018](docs/adrs/ADR-018-ecosystem-integrations.md)).
  99. | Package | Powers | Measured |
  100. |---|---|---|
  101. | [`@ruvector/graph-transformer`](https://www.npmjs.com/package/@ruvector/graph-transformer) | Personalized PageRank in `SparsificationService` and sparse attention | 40x–780x faster than the JS path (500–5,000 nodes) |
  102. | [`@ruvector/mincut-wasm`](https://www.npmjs.com/package/@ruvector/mincut-wasm) | Exact global min cut in `MincutService` and partitioned attention | cut of 4 edges where the old split cut 1,003 (1,000 nodes) |
  103. | [`@ruvector/rabitq-wasm`](https://www.npmjs.com/package/@ruvector/rabitq-wasm) | Opt-in 1-bit index for the built-in sql.js backend (`quantizedIndex: 'rabitq'`) | 6.4x faster at 50k vectors, recall@10 1.000 |
  104. | [`aidefence`](https://www.npmjs.com/package/aidefence) | Opt-in prompt-injection screening of stored memories (`AGENTDB_INJECTION_GUARD=warn\|block`) | 0.1–10 ms per field |
  105. ---
  106. ## 🧠 Self-Learning Loop
  107. Most retrieval systems are read-only. AgentDB closes the loop:
  108. ```
  109. search ──► top-k ──► agent picks the useful ones ──► recordFeedback()
  110. │
  111. ▼
  112. Thompson Sampling bandit
  113. │
  114. ▼
  115. re-weights ranking · re-picks RL algorithm · re-tunes compression
  116. │
  117. ▼
  118. next search is sharper
  119. ```
  120. The bandit isn't a gimmick — it's used at four decision points:
  121. 1. **Pattern ranking** — which historical pattern matches this new query best?
  122. 2. **RL algorithm selection** — Q-Learning for tabular tasks, PPO for continuous control, MCTS for planning, etc.
  123. 3. **Compression tier** — full precision when accuracy matters, PQ4 when memory does.
  124. 4. **Skill composition** — chain skill A→B→C or skill A→D→E?
  125. Each decision logs reward over time. Bad arms decay fast. Good arms stick.
  126. ---
  127. ## ⚡ Performance
  128. | Metric | AgentDB | Baseline | Source |
  129. |---|---|---|---|
  130. | Vector search (100k vectors) | **<1 ms** | ~150 ms (SQLite + cosine loop) | `benchmarks/hnsw/` |
  131. | HNSW query (1M vectors) | **2–5 ms** | ~100 ms (brute force) | `benchmarks/vector-search/` |
  132. | Bulk insert (10k vectors) | **<100 ms** | ~12 s (sql.js) | `benchmarks/database/` |
  133. | Memory footprint (1M × 384d) | **~96 MB (PQ8)** | ~1.5 GB (raw f32) | `benchmarks/quantization/` |
  134. | Self-learning quality lift | **+36%** | n/a | `benchmarks/ruvector-performance.test.ts` |
  135. | GNN attention recall | **+12.4%** | baseline HNSW | `benchmarks/attention-performance.ts` |
  136. Run them yourself: `npm run bench` from this repo.
  137. ### Long-term memory retrieval (LongMemEval)
  138. Episode search fuses BM25 keyword ranking with vector ranking by default (`hybrid: false` turns it off), and `rerank: true` adds a local cross-encoder over the top candidates. Session retrieval on [LongMemEval](https://github.com/xiaowu0162/LongMemEval), default MiniLM embedder, local models only, official protocol (470 questions):
  139. | LongMemEval_M (≈500 sessions per question) | recall_all@5 | NDCG@5 | recall_all@10 |
  140. |---|---|---|---|
  141. | dense only | 0.630 | 0.692 | 0.751 |
  142. | **hybrid** (default) | 0.719 | 0.750 | 0.806 |
  143. | **hybrid + `rerank: true`** | **0.789** | **0.828** | **0.881** |
  144. | LongMemEval paper, best (Contriever + LLM fact keys) | 0.762 | 0.632 | 0.862 |
  145. The harness (`benchmarks/longmemeval/`) runs the same ranking functions over turn chunks; protocol, S-split numbers, other rerankers and limits are in [ADR-016](docs/adrs/ADR-016-hybrid-retrieval-longmemeval.md).
  146. ---
  147. ## 🔌 MCP Integration
  148. 41 tools across six families, all callable from Claude Code, Cursor, Cline, or any MCP-compatible client:
  149. <details>
  150. <summary><strong>Pattern Store / Search (8 tools)</strong></summary>
  151. | Tool | Purpose |
  152. |---|---|
  153. | `agentdb_pattern_store` | Store a successful pattern with embedding + metadata |
  154. | `agentdb_pattern_search` | Semantic search for similar past patterns |
  155. | `agentdb_pattern_stats` | Retrieval stats, cache hits, hit-rate trends |
  156. | `agentdb_pattern_delete` | Remove a pattern by id |
  157. | `agentdb_batch_insert` | Bulk insert many patterns at once |
  158. | `agentdb_batch_search` | Parallel multi-query search |
  159. | `agentdb_export` | Dump patterns to JSON / CSV |
  160. | `agentdb_import` | Load patterns from JSON / CSV |
  161. </details>
  162. <details>
  163. <summary><strong>Hierarchical / Causal Memory (10 tools)</strong></summary>
  164. | Tool | Purpose |
  165. |---|---|
  166. | `agentdb_hierarchical_store` | Tier-aware memory store (working / short / long) |
  167. | `agentdb_hierarchical_recall` | Tier-filtered retrieval |
  168. | `agentdb_hierarchical_delete` | Remove hierarchical entry by key |
  169. | `agentdb_causal_edge` | Add a causal relationship between memories |
  170. | `agentdb_causal_edge_delete` | Remove a causal edge by id |
  171. | `agentdb_causal_node_delete` | Cascade-delete a node + incident edges |
  172. | `agentdb_edges_by_endpoints` | Bulk-delete edges by `(from, to, label)` |
  173. | `agentdb_causal_query` | Cypher-like graph queries |
  174. | `agentdb_causal_explain` | Explain why two memories are connected |
  175. | `agentdb_attestation_log` | Cryptographic audit trail |
  176. </details>
  177. <details>
  178. <summary><strong>Reflexion + Skill Library (12 tools)</strong></summary>
  179. | Tool | Purpose |
  180. |---|---|
  181. | `agentdb_reflexion_store` | Store an episode (task + outcome + critique) |
  182. | `agentdb_reflexion_recall` | Retrieve relevant past episodes |
  183. | `agentdb_reflexion_delete` | Remove an episode |
  184. | `agentdb_reflexion_rebuild` | Re-hydrate vector index from durable SQL |
  185. | `agentdb_skill_create` | Create a reusable skill from a pattern |
  186. | `agentdb_skill_compose` | Chain skills A→B→C with bandit-picked composition |
  187. | `agentdb_skill_search` | Find skills by intent embedding |
  188. | `agentdb_critique_summary` | Summarize lessons from past failures |
  189. | `agentdb_success_strategies` | Surface what worked across past episodes |
  190. | `agentdb_task_stats` | Per-task win-rate, latency, reward trends |
  191. | `agentdb_prune` | TTL + quality-based episode pruning |
  192. | `agentdb_warm_cache` | Pre-populate query cache for a session |
  193. </details>
  194. <details>
  195. <summary><strong>Learning + Routing (11 tools)</strong></summary>
  196. | Tool | Purpose |
  197. |---|---|
  198. | `agentdb_learning_route` | Route a task to the right RL algorithm |
  199. | `agentdb_learning_train` | Train a specific RL agent on episodes |
  200. | `agentdb_learning_predict` | Get an action prediction for a state |
  201. | `agentdb_bandit_update` | Update bandit reward for an arm |
  202. | `agentdb_bandit_pick` | Sample the best arm under Thompson Sampling |
  203. | `agentdb_consolidate` | Run NightlyLearner consolidation pipeline |
  204. | `agentdb_compose` | Combine memory patterns into a strategy |
  205. | `agentdb_synthesize` | Build a context window from related memories |
  206. | `agentdb_explain_recall` | Feature-attributed retrieval results |
  207. | `agentdb_diversity_rank` | MMR-rerank for diverse top-k |
  208. | `agentdb_metadata_filter` | Filtered semantic search |
  209. </details>
  210. ---
  211. ## 🔗 Used By
  212. AgentDB powers the memory + learning layer in:
  213. | Project | What it uses AgentDB for |
  214. |---|---|
  215. | [**`agentic-flow`**](https://github.com/ruvnet/agentic-flow) | ReasoningBank backend, ReflexionMemory, NightlyLearner consolidation, 30+ agent memory namespaces |
  216. | [**`ruflo`**](https://github.com/ruvnet/ruflo) | Plugin marketplace memory, agent federation audit log, hierarchical recall for /adr-index, swarm coordination patterns |
  217. | [**`@ruvector`**](https://github.com/ruvnet/ruvector) | Reference downstream for the Rust engine — every release is verified against AgentDB's test suite |
  218. If you ship something on top of AgentDB, [open an issue](https://github.com/ruvnet/agentdb/issues) and we'll add you.
  219. ---
  220. ## 🐳 Docker / Edge / Browser
  221. AgentDB compiles to four targets from one source:
  222. | Target | What | When |
  223. |---|---|---|
  224. | **Node native** | NAPI bindings (Linux, macOS, Windows; x64 + arm64) | Backend services, CLI, MCP server |
  225. | **Node WASM fallback** | sql.js + WASM engine | Restricted hosts that can't run NAPI |
  226. | **Browser** | Pure WASM bundle | Offline-first apps, edge functions, IDE extensions |
  227. | **Docker** | `docker-compose.yml` in `docker/` | Local dev, CI, prod deploy |
  228. ```bash
  229. # Browser
  230. import { createBrowserDb } from 'agentdb/browser';
  231. # Docker
  232. docker compose -f docker/docker-compose.yml up
  233. ```
  234. ---
  235. ## Documentation
  236. | Doc | When to read it |
  237. |---|---|
  238. | [**Full README** (deep)](docs/README-full.md) | Every feature, every API, every option — the complete reference (2,900+ lines) |
  239. | [**PUBLISHING.md**](docs/PUBLISHING.md) | npm publish flow, dist-tag policy, release verification |
  240. | [**ADR-071**](docs/ADR-071-agentdb-ruvector-wasm-capabilities-review.md) | WASM integration design |
  241. | [**ADR-072**](docs/ADR-072-ruvector-advanced-features-integration.md) | RuVector advanced-feature integration |
  242. | [**Examples**](examples/) | End-to-end runnable scripts — RAG chatbot, code-review agent, RL training, edge deploy |
  243. | [**Benchmarks**](benchmarks/) | Reproducible perf harness — HNSW, attention, quantization, RL, end-to-end |
  244. ---
  245. ## Repository
  246. | | |
  247. |---|---|
  248. | 📦 **npm** | [`agentdb`](https://www.npmjs.com/package/agentdb) |
  249. | 🌐 **Source** | https://github.com/ruvnet/agentdb |
  250. | 🐛 **Issues** | https://github.com/ruvnet/agentdb/issues |
  251. | 🎨 **Marketing site** | [`ui/`](./ui) (Vite + React + shadcn/ui) |
  252. | 🧬 **Engine** | [`@ruvector`](https://github.com/ruvnet/ruvector) (Rust + NAPI) |
  253. | 🔗 **Reference consumer** | [`agentic-flow`](https://github.com/ruvnet/agentic-flow) (uses this as a git submodule at `packages/agentdb/`) |
  254. ---
  255. ## Support
  256. | Resource | Link |
  257. |---|---|
  258. | Documentation | [docs/README-full.md](docs/README-full.md) |
  259. | Issues & Bugs | [GitHub Issues](https://github.com/ruvnet/agentdb/issues) |
  260. | Enterprise | [ruv.io](https://ruv.io) |
  261. | Community | [Agentics Foundation Discord](https://discord.com/invite/dfxmpwkG2D) |
  262. | Engine | [`ruvector`](https://github.com/ruvnet/ruvector) |
  263. | Powered by | [Cognitum.one](https://cognitum.one) |
  264. ## License
  265. [MIT](LICENSE) OR Apache-2.0 — [RuvNet](https://github.com/ruvnet)
  266. <!-- weaver:seo:links:start -->
  267. ## Works with / Used by
  268. Part of the [ruv.io](https://ruv.io) open-source stack for agent memory, vector database, AI agents.
  269. - **Works with** (its runtime dependencies): [`@ruvector/attention`](https://www.npmjs.com/package/@ruvector/attention), [`@ruvector/core`](https://www.npmjs.com/package/@ruvector/core), [`@ruvector/gnn`](https://www.npmjs.com/package/@ruvector/gnn), [`@ruvector/graph-node`](https://www.npmjs.com/package/@ruvector/graph-node), [`@ruvector/graph-transformer`](https://www.npmjs.com/package/@ruvector/graph-transformer), [`@ruvector/mincut-wasm`](https://www.npmjs.com/package/@ruvector/mincut-wasm), [`@ruvector/rabitq-wasm`](https://www.npmjs.com/package/@ruvector/rabitq-wasm), [`@ruvector/router`](https://www.npmjs.com/package/@ruvector/router), [`@ruvector/ruvllm`](https://www.npmjs.com/package/@ruvector/ruvllm), [`@ruvector/rvf`](https://www.npmjs.com/package/@ruvector/rvf), [`@ruvector/rvf-node`](https://www.npmjs.com/package/@ruvector/rvf-node), [`@ruvector/rvf-solver`](https://www.npmjs.com/package/@ruvector/rvf-solver), [`@ruvector/rvf-wasm`](https://www.npmjs.com/package/@ruvector/rvf-wasm), [`@ruvector/sona`](https://www.npmjs.com/package/@ruvector/sona), [`@ruvnet/sublinear-core`](https://www.npmjs.com/package/@ruvnet/sublinear-core), [`aidefence`](https://www.npmjs.com/package/aidefence), [`ruvector`](https://www.npmjs.com/package/ruvector), [`ruvector-attention-wasm`](https://www.npmjs.com/package/ruvector-attention-wasm), [`ruvector-graph-transformer-wasm`](https://www.npmjs.com/package/ruvector-graph-transformer-wasm)
  270. - **Used by** (published packages that depend on it): [`@agentic-robotics/mcp`](https://www.npmjs.com/package/@agentic-robotics/mcp), [`@agentic-robotics/self-learning`](https://www.npmjs.com/package/@agentic-robotics/self-learning), [`@claude-flow/aidefence`](https://www.npmjs.com/package/@claude-flow/aidefence), [`@claude-flow/cli`](https://www.npmjs.com/package/@claude-flow/cli), [`@claude-flow/memory`](https://www.npmjs.com/package/@claude-flow/memory), [`@claude-flow/neural`](https://www.npmjs.com/package/@claude-flow/neural), [`@foxruv/iris`](https://www.npmjs.com/package/@foxruv/iris), [`@foxruv/iris-ultrathink`](https://www.npmjs.com/package/@foxruv/iris-ultrathink), [`@foxruv/nova-medicina`](https://www.npmjs.com/package/@foxruv/nova-medicina), [`@neural-trader/agentic-accounting-agents`](https://www.npmjs.com/package/@neural-trader/agentic-accounting-agents), [`@neural-trader/agentic-accounting-core`](https://www.npmjs.com/package/@neural-trader/agentic-accounting-core), [`@neural-trader/example-dynamic-pricing`](https://www.npmjs.com/package/@neural-trader/example-dynamic-pricing)
  271. <!-- weaver:seo:links:end -->
  272. <!-- weaver:seo:footer:start -->
  273. ---
  274. Built by [rUv](https://ruv.io) · [ruv.io](https://ruv.io) · [Source](https://github.com/ruvnet/agentdb)
  275. <!-- weaver:seo:footer:end -->
  276. ### Learned memory reranking (3.10)
  277. `NeuralReranker` learns a small local ruv-FANN scorer from labeled query groups.
  278. It evaluates NDCG and MRR against baseline and active rankings before explicit
  279. promotion. Opt-in `neuralRerank` queries default to shadow mode, preserving normal
  280. results while exposing scores. Active mode ranks a bounded candidate pool;
  281. revisioned checkpoints support rollback. Ten MCP tools expose training,
  282. evaluation and model management, with admin-only promotion and rollback.
  283. The four versioned inputs are similarity, historical reward, success and recency.
  284. Supply independent relevance labels and separate evaluation queries. Included
  285. synthetic benchmarks validate the pipeline, not production retrieval quality.
  286. Agents can also inspect weights and propose hash-bound WSP edits without training;
  287. these candidates must pass the same evaluation gates before promotion.
  288. See [the learned memory reranking guide](https://github.com/ruvnet/agentdb/blob/main/docs/neural/memory-reranking.md).
  289. ### Persisted neural models (3.8)
  290. `WeightPrograms` from `agentdb/controllers/WeightPrograms` adds durable,
  291. gradient-free weight patches evaluated by real WASM. Caller-authored proposals
  292. are persisted with evaluation evidence; explicit promotion checks stored proposal
  293. identity, generation, hashes and revision. Rollback restores retained checkpoints
  294. as new revisions. Six strict MCP tools expose the workflow with learning/admin
  295. permissions. Acceptance applies to caller-supplied examples and does not prove
  296. generalization. See [the weight programs guide](docs/neural/weight-programs.md).
  297. `FannModels` from `agentdb/controllers/FannModels` stores dense ruv-FANN
  298. checkpoints and revisions in your database. It provides real WASM batch inference,
  299. SGD/AdamW training, and bounded prepared-model caching. AgentDB depends on
  300. `ruv-fann@0.1.2`, which depends on `ruv-fann-wasm@0.1.2`; no optional native
  301. accelerator is needed for this API.
  302. Six MCP tools (`agentdb_neural_create`, `get`, `list`, `predict`, `train`, and
  303. `delete`, each with the `agentdb_neural_` prefix) follow the existing capability
  304. policy. Readonly clients can inspect and predict; learning clients can create
  305. and train; deletion requires admin or an explicit allow. See
  306. [the neural-model guide](https://github.com/ruvnet/agentdb/blob/main/docs/neural/ruv-fann.md)
  307. for usage, persistence semantics and bounded training limits.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.