memoryai-mcp 2.1.0 → 2.2.0

package/dist/index.js

@@ -40,7 +40,7 @@ function err(e) {
     return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
 }
 // --- MCP Server ---
-const server = new McpServer({ name: "memoryai", version: "0.9.0" }, { capabilities: { tools: {} } });
+const server = new McpServer({ name: "memoryai", version: "1.0.0" }, { capabilities: { tools: {} } });
 // 1. memory_store
 server.tool("memory_store", "Store information in persistent memory. Use when you learn something important — project context, user preferences, architectural decisions, patterns, bugs, pricing/cost discussions, business plans, financial calculations, credit/billing info, revenue models, partnership details, or ANY information the user might ask about later. When in doubt, STORE — MemoryAI handles dedup automatically, so storing too much is always better than forgetting.", {
     content: z.string().describe("What to remember"),
@@ -874,12 +874,30 @@ server.tool("context_guard_compact", "Compact session context with DNA protectio
         return err(e);
     }
 });
-// context_guard_bootstrap — DNA-first session bootstrap
-server.tool("context_guard_bootstrap", "Bootstrap a new session with DNA-first context — identity/preferences first, then recent activity, then task-relevant memories. For BOT clients: uses 3-tier wake-up (800 tokens). For IDE: flat layout (~4000 tokens).", {
+// context_guard_bootstrap — DNA-first session bootstrap (IDE)
+server.tool("context_guard_bootstrap", "Load context from previous sessions at session start. Returns preferences, recent activity, and task-relevant memories. Call once at the beginning of a session to restore context.", {
+    task: z.string().describe("Task description for context relevance"),
+    limit: z.number().optional().describe("Max memories to include (default: 10)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/context/guard/bootstrap", {
+            task: args.task,
+            limit: args.limit || 10,
+        }));
+        return ok(`Context restored: ${r.memories_restored || r.memories_included || 0} memories (${r.dna_memories || 0} DNA)\n` +
+            `Tokens used: ${r.tokens_used}\n\n` +
+            r.context_block);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// bot_guard_bootstrap — 3-tier wake-up for bots (800 tokens)
+server.tool("bot_guard_bootstrap", "Bot-specific bootstrap — 3-tier wake-up (Identity→Context→Details) with 800 token budget. Use for chatbots, not IDEs.", {
     task: z.string().describe("Task description for the new session"),
     limit: z.number().optional().describe("Max memories to include (default: 10)"),
-    mode: z.enum(["default", "deep"]).optional().describe("'default' = 800 token 3-tier wake-up, 'deep' = full context with L2 chunks"),
-    token_budget: z.number().optional().describe("Token budget for bootstrap (default: 800 for bot, 4000 for IDE)"),
+    mode: z.enum(["default", "deep"]).optional().describe("'default' = 800 token 3-tier, 'deep' = full context with L2 chunks"),
+    token_budget: z.number().optional().describe("Token budget (default: 800)"),
 }, async (args) => {
     try {
         const r = (await api("POST", "/v1/bot/guard/bootstrap", {
@@ -1289,6 +1307,168 @@ server.tool("memory_entity_profile", "Get complete profile for a specific entity
         return err(e);
     }
 });
+// ═══════════════════════════════════════════════════════════════════════════
+// PHASE 5 (2026-05-28) — DNA-aligned tools:
+//   • brain_export / brain_import   — DNA #3 vendor neutrality
+//   • benchmark_recall_vs_full      — DNA #2 retina (measurable moat)
+//   • benchmark_pricing             — public model pricing reference
+//   • trust_agents / trust_chunk    — DNA #1.5 trust graph
+//   • twin_respond / twin_status    — Cognitive Twin (promax+ tier)
+// ═══════════════════════════════════════════════════════════════════════════
+// brain_export
+server.tool("brain_export", "Export the entire brain to a portable JSON bundle (vendor-neutral). Use when the user wants to back up their brain, migrate to another instance (e.g. lite-build on-prem), or comply with data-portability rights. The bundle is self-contained — chunks, edges, entities, L2 sessions, mood, agents — and includes a sha256 checksum. Returns the bundle JSON.", {
+    scope: z.enum(["full", "dna_only", "since"]).optional().describe("'full'=everything (default), 'dna_only'=just preferences/decisions/identity (lightweight portable identity), 'since'=incremental (requires `since` ISO datetime)"),
+    since: z.string().optional().describe("ISO8601 datetime, only used when scope='since'"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/brain/export", {
+            scope: args.scope || "full",
+            since: args.since,
+        }));
+        const counts = r?.manifest?.counts || {};
+        const summary = `Exported brain bundle (format=${r.format} v${r.version}):\n` +
+            `- chunks: ${counts.chunks ?? 0}\n` +
+            `- memory_edges: ${counts.memory_edges ?? 0}\n` +
+            `- entities: ${counts.entities ?? 0}\n` +
+            `- l2_sessions: ${counts.l2_sessions ?? 0}\n` +
+            `- agents: ${counts.agents ?? 0}\n` +
+            `- checksum: ${r?.manifest?.checksum?.slice(0, 16)}...\n\n` +
+            `Bundle JSON ready (truncated preview):\n\`\`\`json\n${JSON.stringify(r, null, 2).slice(0, 1200)}...\n\`\`\``;
+        return ok(summary);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_import
+server.tool("brain_import", "Import a MemoryAI bundle (from brain_export) into the current tenant. Idempotent — chunks deduped by content_hash; edges/entities upserted. Embeddings are reused if the bundle's embedding_model matches the local one; otherwise dropped (chunks re-embed lazily).", {
+    bundle: z.record(z.string(), z.unknown()).describe("The bundle JSON produced by brain_export (must contain format='memoryai-bundle', version, manifest, etc.)"),
+    keep_embeddings: z.boolean().optional().describe("Reuse bundle embeddings if model matches (default: true)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", `/v1/brain/import?keep_embeddings=${args.keep_embeddings === false ? "false" : "true"}`, args.bundle));
+        const rep = r?.report || {};
+        const out = `Brain import complete (format=${rep.bundle_format} v${rep.bundle_version}):\n` +
+            `- chunks: ${rep.chunks?.inserted ?? 0} inserted, ${rep.chunks?.skipped_duplicate ?? 0} skipped (dup), ${rep.chunks?.skipped_invalid ?? 0} invalid\n` +
+            `- memory_edges: ${rep.memory_edges?.upserted ?? 0} upserted (${rep.memory_edges?.skipped ?? 0} skipped)\n` +
+            `- entities: ${rep.entities?.upserted ?? 0} upserted\n` +
+            `- l2_sessions: ${rep.l2_sessions?.inserted ?? 0} inserted\n` +
+            `- agents: ${rep.agents?.upserted ?? 0} upserted\n` +
+            `- embedding_model_match: ${rep.embedding_model_match}\n` +
+            (rep.warnings?.length ? `\nWarnings:\n  ${rep.warnings.join("\n  ")}` : "");
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// benchmark_recall_vs_full
+server.tool("benchmark_recall_vs_full", "Run a public benchmark: smart recall vs full-context dump on the calling brain. DNA #2 — proves the 'retina for AI' moat with measurable numbers (cost, latency, signal density). Available on every tier; safe to share results publicly.", {
+    query: z.string().describe("The query to benchmark (e.g. 'what does the user prefer?')"),
+    model: z.string().optional().describe("Model whose pricing to apply (default: claude-opus-4-6). Affects $cost only."),
+    naive_budget_tokens: z.number().optional().describe("Cap on full-context dump (default: 200K = Claude window)"),
+    smart_top_k: z.number().optional().describe("Top-K chunks for smart mode (default: 8)"),
+    smart_depth: z.enum(["instant", "fast", "deep"]).optional().describe("Smart recall depth (default: deep)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/benchmark/recall-vs-fullcontext", {
+            query: args.query,
+            model: args.model || "claude-opus-4-6",
+            naive_budget_tokens: args.naive_budget_tokens,
+            smart_top_k: args.smart_top_k,
+            smart_depth: args.smart_depth,
+        }));
+        const out = `Benchmark — query: ${JSON.stringify(r.query)}\n` +
+            `Model: ${r.model} ($${r.price_per_m_tokens_usd}/M tokens)\n\n` +
+            `NAIVE: ${r.naive.chunks_used} chunks · ${r.naive.input_tokens} tok · $${r.naive.estimated_cost_usd} · ${r.naive.latency_ms}ms\n` +
+            `SMART: ${r.smart.chunks_used} chunks · ${r.smart.input_tokens} tok · $${r.smart.estimated_cost_usd} · ${r.smart.latency_ms}ms\n\n` +
+            `→ ${r.headline}`;
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// benchmark_pricing
+server.tool("benchmark_pricing", "Get the assumed $/1M-input-tokens pricing for each LLM (used by benchmark_recall_vs_full). No auth required; list prices only.", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/benchmark/pricing"));
+        const lines = Object.entries(r.prices || {}).map(([k, v]) => `- ${k}: $${v}`);
+        return ok(`Model pricing (${r.currency} ${r.unit}, as of ${r.as_of}):\n${lines.join("\n")}\n\nNote: ${r.note}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// trust_agents
+server.tool("trust_agents", "Get the agent reputation leaderboard (sorted by reputation_score desc). DNA #1.5 — when 20 agents share memory and disagree, this tells you whose claims to trust. Requires team+ plan.", {
+    limit: z.number().optional().describe("Max agents to return (default: 50, max: 500)"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/trust/agents?limit=${args.limit ?? 50}`));
+        if (!r.agents?.length)
+            return ok("No agent reputation snapshots yet. Run /v1/trust/recompute-all to populate.");
+        const lines = r.agents.map((a) => `- ${a.agent_id}: ${a.reputation_score.toFixed(3)} [${a.label}] — V=${a.verified_count}/C=${a.contradicted_count}/N=${a.feedback_n}`);
+        return ok(`Agent reputation (${r.agents.length} agents):\n${lines.join("\n")}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// trust_chunk
+server.tool("trust_chunk", "Get per-chunk trust info: which agent claimed it, that agent's reputation, helpful/unhelpful counts. Use after a recall to decide whether to trust a specific result. Available on every paid tier.", {
+    chunk_id: z.number().describe("The chunk ID returned by recall"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/trust/chunks/${args.chunk_id}`));
+        const stats = r.agent_stats || {};
+        const fb = r.feedback || {};
+        return ok(`Chunk #${r.chunk_id} (${r.memory_type})\n` +
+            `Source agent: ${r.source_agent_id ?? "(none)"}\n` +
+            `Agent trust: ${r.agent_trust?.toFixed(3) ?? "(none)"} — V=${stats.verified_count ?? 0}/C=${stats.contradicted_count ?? 0}/total=${stats.claim_count ?? 0}\n` +
+            `Per-chunk trust: ${r.chunk_trust_score?.toFixed(3) ?? "(none)"} (helpful=${fb.helpful ?? 0}, unhelpful=${fb.unhelpful ?? 0})`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// twin_respond
+server.tool("twin_respond", "Ask the Cognitive Twin to predict how the user would respond to a given query. The twin uses the user's personality + mood + DNA + procedures to simulate their voice. Returns the predicted response, a confidence score 0-1, and the chunk IDs that informed it (provenance trail). Auto-refuses with confidence=0 if the brain has fewer than 5 DNA memories. Requires promax+ plan.", {
+    query: z.string().describe("The free-form question to ask the twin (e.g. 'what database for a chat app?')"),
+    operation: z.enum(["respond", "decide"]).optional().describe("'respond'=free-form answer (default), 'decide'=pick one option from the query"),
+}, async (args) => {
+    try {
+        const path = args.operation === "decide" ? "/v1/twin/decide" : "/v1/twin/respond";
+        const r = (await api("POST", path, { query: args.query }));
+        const out = `Cognitive Twin (${r.operation}, confidence ${r.confidence}):\n` +
+            `Persona: ${r.persona_summary || "(not synthesized)"}\n` +
+            `Mood: ${r.mood || "unknown"}\n` +
+            `Provenance chunks: ${r.provenance_chunks?.length ?? 0}\n\n` +
+            `Response:\n${r.response}\n\n` +
+            `(reason: ${r.confidence_reason})`;
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// twin_status
+server.tool("twin_status", "Check whether the Cognitive Twin is ready for the calling tenant. Cheap — no LLM call. Returns DNA count, personality/mood presence, and a `ready` boolean. Useful before invoking twin_respond.", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/twin/status"));
+        return ok(`Twin ready: ${r.ready ? "YES" : "NO"} (need ≥${r.min_dna_required} DNA, have ${r.dna_count})\n` +
+            `- has_personality: ${r.has_personality}\n` +
+            `- has_mood: ${r.has_mood}\n` +
+            `- procedures: ${r.procedures_count}\n` +
+            `- active_goals: ${r.active_goals_count}\n` +
+            `- top_entities: ${r.top_entities_count}\n` +
+            (r.persona_summary ? `\nPersona: ${r.persona_summary}\n` : "") +
+            (r.mood ? `Mood: ${r.mood}\n` : ""));
+    }
+    catch (e) {
+        return err(e);
+    }
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memoryai-mcp",
-  "version": "2.1.0",
-  "description": "MCP server for MemoryAI — Long-term memory for AI agents. Works with Claude Code, Cursor, Windsurf, VS Code, Kiro.",
+  "version": "2.2.0",
+  "description": "MCP server for MemoryAI v2.0 — One brain. ∞ agents. Forever. Adds Brain Export/Import (vendor-neutral bundles), Public Benchmark (smart recall vs full context), Trust Graph (per-agent reputation), Cognitive Twin (simulate user voice). Plus the v1.5 base: 11 biological behaviors, DNA-protected memories, Multi-Agent Mesh.",
   "homepage": "https://memoryai.dev",
   "repository": {
     "type": "git",