@mnemoverse/mcp-memory-server 0.3.1 → 0.3.3

package/scripts/install-hooks.mjs

@@ -1,76 +0,0 @@
-#!/usr/bin/env node
-/**
- * install-hooks.mjs
- *
- * Installs the optional pre-push hook for local drift detection. The hook
- * runs `npm run verify:configs` before every push and aborts if any of the
- * 15 generated artifacts is out of sync with src/configs/source.json.
- *
- * The hook is per-clone (.git/hooks/ is not committed) and opt-in. CI is
- * the authoritative gate — see .github/workflows/verify-configs.yml.
- *
- * Usage: npm run install-hooks
- */
-
-import {
-  writeFileSync,
-  chmodSync,
-  existsSync,
-  mkdirSync,
-} from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..");
-const HOOKS_DIR = resolve(ROOT, ".git/hooks");
-const HOOK_PATH = resolve(HOOKS_DIR, "pre-push");
-
-if (!existsSync(resolve(ROOT, ".git"))) {
-  console.error(
-    "✗ Not a git repo (no .git directory found at " + ROOT + ").",
-  );
-  console.error("  Cannot install pre-push hook.");
-  process.exit(1);
-}
-
-mkdirSync(HOOKS_DIR, { recursive: true });
-
-const HOOK_BODY = `#!/usr/bin/env bash
-# Auto-generated by scripts/install-hooks.mjs.
-# Aborts the push if any of the 15 distribution artifacts has drifted from
-# src/configs/source.json. Re-run install-hooks after pulling generator changes.
-#
-# To bypass for a one-off (NOT recommended for branches targeting main):
-#   git push --no-verify
-
-set -e
-
-# Find repo root so the hook works regardless of where 'git push' was invoked.
-REPO_ROOT="$(git rev-parse --show-toplevel)"
-cd "$REPO_ROOT"
-
-if ! command -v node >/dev/null 2>&1; then
-  echo "pre-push: node not found in PATH; skipping drift check"
-  exit 0
-fi
-
-echo "pre-push: verifying distribution config drift..."
-if ! node scripts/generate-configs.mjs --check; then
-  echo ""
-  echo "✗ Push aborted: distribution configs are out of sync with src/configs/source.json"
-  echo "  Run \\\`npm run generate:configs\\\` to fix, commit the result, then push again."
-  echo "  See CONTRIBUTING.md for details."
-  exit 1
-fi
-`;
-
-writeFileSync(HOOK_PATH, HOOK_BODY, "utf8");
-chmodSync(HOOK_PATH, 0o755);
-
-console.log("✓ Installed pre-push hook at " + HOOK_PATH);
-console.log("  It will run `node scripts/generate-configs.mjs --check`");
-console.log("  before every push and abort on drift.");
-console.log("");
-console.log("  To remove: rm " + HOOK_PATH);
-console.log("  To bypass once: git push --no-verify");

package/server.json

@@ -1,29 +0,0 @@
-{
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-  "name": "io.github.mnemoverse/mcp-memory-server",
-  "description": "Shared AI memory across Claude, Cursor, VS Code, ChatGPT. Write once, recall anywhere.",
-  "repository": {
-    "url": "https://github.com/mnemoverse/mcp-memory-server",
-    "source": "github"
-  },
-  "version": "0.3.1",
-  "packages": [
-    {
-      "registryType": "npm",
-      "identifier": "@mnemoverse/mcp-memory-server",
-      "version": "0.3.1",
-      "transport": {
-        "type": "stdio"
-      },
-      "environmentVariables": [
-        {
-          "name": "MNEMOVERSE_API_KEY",
-          "description": "Your Mnemoverse API key (starts with mk_live_). Get one free at https://console.mnemoverse.com",
-          "isRequired": true,
-          "format": "string",
-          "isSecret": true
-        }
-      ]
-    }
-  ]
-}

package/smithery.yaml

@@ -1,24 +0,0 @@
-# Smithery configuration — AUTO-GENERATED from src/configs/source.json
-# Do not edit by hand. Run `npm run generate:configs` to regenerate.
-# Docs: https://smithery.ai/docs/build/project-config/smithery.yaml
-
-startCommand:
-  type: stdio
-  configSchema:
-    type: object
-    required:
-      - mnemoverseApiKey
-    properties:
-      mnemoverseApiKey:
-        type: string
-        description: |
-          Your Mnemoverse API key (starts with mk_live_). Get one free at https://console.mnemoverse.com
-  commandFunction:
-    |-
-    (config) => ({
-      command: 'npx',
-      args: ["-y","@mnemoverse/mcp-memory-server@latest"],
-      env: {
-        MNEMOVERSE_API_KEY: config.mnemoverseApiKey,
-      }
-    })

package/src/configs/source.json

@@ -1,28 +0,0 @@
-{
-  "$comment": "SINGLE SOURCE OF TRUTH for all distribution channel configs. Edit this file → run `npm run generate:configs` → all 9+ artifacts regenerate. CI verifies committed artifacts match source.",
-  "name": "mnemoverse",
-  "displayName": "Mnemoverse Memory",
-  "description": "Shared AI memory across Claude, Cursor, VS Code, ChatGPT. Write once, recall anywhere.",
-  "type": "stdio",
-  "command": "npx",
-  "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
-  "env": {
-    "MNEMOVERSE_API_KEY": {
-      "value": "mk_live_YOUR_KEY",
-      "description": "Your Mnemoverse API key (starts with mk_live_). Get one free at https://console.mnemoverse.com",
-      "required": true,
-      "secret": true
-    }
-  },
-  "package": {
-    "registry": "npm",
-    "name": "@mnemoverse/mcp-memory-server"
-  },
-  "metadata": {
-    "homepage": "https://mnemoverse.com/docs/api/mcp-server",
-    "repository": "https://github.com/mnemoverse/mcp-memory-server",
-    "license": "MIT",
-    "author": "Mnemoverse",
-    "tags": ["memory", "persistent", "ai-agents", "cross-tool", "oauth"]
-  }
-}

package/src/index.ts

@@ -1,422 +0,0 @@
-#!/usr/bin/env node
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-const API_URL =
-  process.env.MNEMOVERSE_API_URL || "https://core.mnemoverse.com/api/v1";
-const API_KEY = process.env.MNEMOVERSE_API_KEY || "";
-
-// Hard cap on tool result size — required by Claude Connectors Directory
-// (https://support.claude.com/en/articles/12922490-remote-mcp-server-submission-guide).
-// Approximate token count = chars / 4. Cap at 24,000 tokens to leave headroom under the 25K limit.
-const MAX_RESULT_CHARS = 24_000 * 4;
-
-if (!API_KEY) {
-  console.error(
-    "Error: MNEMOVERSE_API_KEY environment variable is required.\n" +
-      "Get your free key at https://console.mnemoverse.com",
-  );
-  process.exit(1);
-}
-
-async function apiFetch(
-  path: string,
-  options: RequestInit = {},
-): Promise<unknown> {
-  const res = await fetch(`${API_URL}${path}`, {
-    ...options,
-    headers: {
-      "Content-Type": "application/json",
-      "X-Api-Key": API_KEY,
-      ...((options.headers as Record<string, string>) || {}),
-    },
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Mnemoverse API error ${res.status}: ${text}`);
-  }
-
-  return res.json();
-}
-
-/**
- * Truncate a result string to MAX_RESULT_CHARS, appending a notice if truncated.
- * Required by Claude Connectors Directory submission policy.
- */
-function capResult(text: string): string {
-  if (text.length <= MAX_RESULT_CHARS) return text;
-  const truncated = text.slice(0, MAX_RESULT_CHARS - 200);
-  return (
-    truncated +
-    `\n\n[…truncated to fit 25K token limit. Use a more specific query or smaller top_k to see all results.]`
-  );
-}
-
-// --- Server setup ---
-
-const server = new McpServer({
-  name: "mnemoverse-memory",
-  version: "0.3.1",
-});
-
-// --- Tool: memory_write ---
-
-server.registerTool(
-  "memory_write",
-  {
-    description:
-      "Store a memory that should persist across sessions — preferences, decisions, lessons learned, project facts, people and roles. Memories you store are also accessible from Claude, ChatGPT, Cursor, VS Code, and any other AI tool the user connects to Mnemoverse — write once, recall everywhere. Call this PROACTIVELY whenever the user states a preference, makes a decision, or you learn something important. Don't wait to be asked — if it's worth remembering, store it now.",
-    inputSchema: {
-      content: z
-        .string()
-        .min(1)
-        .max(10000)
-        .describe("The memory to store — what happened, what was learned"),
-      concepts: z
-        .array(z.string())
-        .optional()
-        .describe(
-          "Key concepts for linking related memories (e.g. ['deploy', 'friday', 'staging'])",
-        ),
-      domain: z
-        .string()
-        .optional()
-        .describe(
-          "Namespace to organize memories (e.g. 'engineering', 'user:alice', 'project:acme')",
-        ),
-    },
-    annotations: {
-      title: "Store Memory",
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: true,
-    },
-  },
-  async ({ content, concepts, domain }) => {
-    const result = await apiFetch("/memory/write", {
-      method: "POST",
-      body: JSON.stringify({
-        content,
-        concepts: concepts || [],
-        domain: domain || "general",
-      }),
-    });
-
-    const r = result as {
-      stored: boolean;
-      atom_id: string | null;
-      importance: number;
-      reason: string;
-    };
-
-    if (r.stored) {
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Stored (importance: ${r.importance.toFixed(2)}). ID: ${r.atom_id}`,
-          },
-        ],
-      };
-    }
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: `Filtered — ${r.reason} (importance: ${r.importance.toFixed(2)})`,
-        },
-      ],
-    };
-  },
-);
-
-// --- Tool: memory_read ---
-
-server.registerTool(
-  "memory_read",
-  {
-    description:
-      "ALWAYS call this tool first when the user asks a question about preferences, past decisions, project setup, people, or anything that might have been discussed before. This is your long-term memory — it persists across sessions and tools (Claude, ChatGPT, Cursor, VS Code, and any other AI tool the user connects). Search by natural language query. If you have any doubt whether you know something — check memory first.",
-    inputSchema: {
-      query: z
-        .string()
-        .min(1)
-        .max(5000)
-        .describe("Natural language query — what are you looking for?"),
-      top_k: z
-        .number()
-        .int()
-        .min(1)
-        .max(50)
-        .optional()
-        .describe("Max results to return (default: 5)"),
-      domain: z
-        .string()
-        .optional()
-        .describe("Filter by domain namespace"),
-    },
-    annotations: {
-      title: "Search Memories",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: true,
-    },
-  },
-  async ({ query, top_k, domain }) => {
-    const result = await apiFetch("/memory/read", {
-      method: "POST",
-      body: JSON.stringify({
-        query,
-        top_k: top_k || 5,
-        domain: domain || undefined,
-        include_associations: true,
-      }),
-    });
-
-    const r = result as {
-      items: Array<{
-        content: string;
-        relevance: number;
-        concepts: string[];
-        domain: string;
-      }>;
-      search_time_ms: number;
-    };
-
-    if (r.items.length === 0) {
-      return {
-        content: [
-          { type: "text" as const, text: "No memories found for this query." },
-        ],
-      };
-    }
-
-    const lines = r.items.map(
-      (item, i) =>
-        `${i + 1}. [${(item.relevance * 100).toFixed(0)}%] ${item.content}` +
-        (item.concepts.length > 0
-          ? ` (${item.concepts.join(", ")})`
-          : ""),
-    );
-
-    const text = lines.join("\n\n") + `\n\n(${r.search_time_ms.toFixed(0)}ms)`;
-
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: capResult(text),
-        },
-      ],
-    };
-  },
-);
-
-// --- Tool: memory_feedback ---
-
-server.registerTool(
-  "memory_feedback",
-  {
-    description:
-      "Report whether a retrieved memory was helpful. Positive feedback makes memories easier to find next time across all tools. Negative feedback lets them fade. Call this after using memories from memory_read.",
-    inputSchema: {
-      atom_ids: z
-        .array(z.string())
-        .min(1)
-        .describe("IDs of memories to give feedback on (from memory_read results)"),
-      outcome: z
-        .number()
-        .min(-1)
-        .max(1)
-        .describe("How helpful was this? 1.0 = very helpful, 0 = neutral, -1.0 = harmful/wrong"),
-    },
-    annotations: {
-      title: "Rate Memory Helpfulness",
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: true,
-    },
-  },
-  async ({ atom_ids, outcome }) => {
-    const result = await apiFetch("/memory/feedback", {
-      method: "POST",
-      body: JSON.stringify({ atom_ids, outcome }),
-    });
-
-    const r = result as { updated_count: number };
-
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: `Feedback recorded for ${r.updated_count} memor${r.updated_count === 1 ? "y" : "ies"}.`,
-        },
-      ],
-    };
-  },
-);
-
-// --- Tool: memory_stats ---
-
-server.registerTool(
-  "memory_stats",
-  {
-    description:
-      "Get memory statistics — how many memories are stored, which domains exist, average quality scores. These memories are shared with all AI tools the user has connected to Mnemoverse. Useful for understanding the current state of memory.",
-    inputSchema: {},
-    annotations: {
-      title: "Memory Statistics",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: true,
-    },
-  },
-  async () => {
-    const result = await apiFetch("/memory/stats");
-
-    const r = result as {
-      total_atoms: number;
-      episodes: number;
-      prototypes: number;
-      hebbian_edges: number;
-      domains: string[];
-      avg_valence: number;
-      avg_importance: number;
-    };
-
-    const text = [
-      `Memories: ${r.total_atoms} (${r.episodes} episodes, ${r.prototypes} prototypes)`,
-      `Associations: ${r.hebbian_edges} Hebbian edges`,
-      `Domains: ${r.domains.length > 0 ? r.domains.join(", ") : "general"}`,
-      `Avg quality: valence ${r.avg_valence.toFixed(2)}, importance ${r.avg_importance.toFixed(2)}`,
-    ].join("\n");
-
-    return { content: [{ type: "text" as const, text }] };
-  },
-);
-
-// --- Tool: memory_delete ---
-
-server.registerTool(
-  "memory_delete",
-  {
-    description:
-      "Permanently delete a single memory by its atom_id. Use when the user explicitly asks to forget something specific, or when you stored a wrong fact that needs correcting. The deletion is irreversible — the memory is gone for good. For broad cleanup of an entire topic, prefer memory_delete_domain.",
-    inputSchema: {
-      atom_id: z
-        .string()
-        .min(1)
-        .describe(
-          "The atom_id of the memory to delete (from memory_read results — each item has an id)",
-        ),
-    },
-    annotations: {
-      title: "Delete a Memory",
-      readOnlyHint: false,
-      destructiveHint: true,
-      idempotentHint: true,
-      openWorldHint: true,
-    },
-  },
-  async ({ atom_id }) => {
-    const result = await apiFetch(`/memory/atoms/${encodeURIComponent(atom_id)}`, {
-      method: "DELETE",
-    });
-
-    // Core API returns { deleted: <count>, atom_id }. count == 0 means
-    // the atom didn't exist (or was already removed). count >= 1 means it was deleted.
-    const r = result as { deleted: number; atom_id?: string };
-
-    if (!r.deleted) {
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `No memory found with id ${atom_id}.`,
-          },
-        ],
-      };
-    }
-
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: `Deleted memory ${atom_id}.`,
-        },
-      ],
-    };
-  },
-);
-
-// --- Tool: memory_delete_domain ---
-
-server.registerTool(
-  "memory_delete_domain",
-  {
-    description:
-      "Permanently delete ALL memories in a given domain. Use when the user wants to clean up an entire topic — e.g., 'forget everything about project X' or 'wipe my benchmark experiments'. The deletion is irreversible. List domains first with memory_stats to confirm the exact name. Refuse to call this without an explicit user request — it is much more destructive than memory_delete.",
-    inputSchema: {
-      domain: z
-        .string()
-        .min(1)
-        .max(200)
-        .describe(
-          "The domain namespace to wipe (e.g., 'project:old', 'experiments-2025'). Must match exactly.",
-        ),
-      confirm: z
-        .literal(true)
-        .describe(
-          "Must be exactly true to proceed. Acts as a safety interlock against accidental invocation.",
-        ),
-    },
-    annotations: {
-      title: "Delete an Entire Memory Domain",
-      readOnlyHint: false,
-      destructiveHint: true,
-      idempotentHint: true,
-      openWorldHint: true,
-    },
-  },
-  async ({ domain, confirm }) => {
-    if (confirm !== true) {
-      throw new Error(
-        "memory_delete_domain requires confirm=true as a safety interlock.",
-      );
-    }
-
-    const result = await apiFetch(`/memory/domain/${encodeURIComponent(domain)}`, {
-      method: "DELETE",
-    });
-
-    const r = result as { deleted: number; domain: string };
-
-    return {
-      content: [
-        {
-          type: "text" as const,
-          text: `Deleted ${r.deleted} ${r.deleted === 1 ? "memory" : "memories"} from domain "${r.domain}".`,
-        },
-      ],
-    };
-  },
-);
-
-// --- Start ---
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-main().catch((err) => {
-  console.error("MCP server error:", err);
-  process.exit(1);
-});

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"]
-}