oh-memos-mcp 1.0.0

package/dist/query-processing.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Query Processing Module
+ *
+ * Intent detection, keyword extraction, reranking, type extraction.
+ */
+import type { SearchData, MemoryNode, QueryIntent } from "./types.js";
+export declare const INTENT_TO_GRAPHS: Record<string, string[]>;
+export declare function detectQueryIntent(query: string): QueryIntent;
+export declare function getGraphsForIntent(intent: QueryIntent): string[];
+export declare function getIntentDescription(intent: QueryIntent): string;
+export declare function parseMemoryTypePrefix(query: string): [string | null, string];
+export declare function extractKeywords(query: string): string[];
+export declare function keywordMatchScore(text: string, keywords: string[], metadata?: Record<string, unknown>, enableFuzzy?: boolean): number;
+export declare function applyKeywordRerank(data: SearchData, query: string, enableFuzzy?: boolean): SearchData;
+export declare function filterEdgesByIntent(data: SearchData, intent: QueryIntent): SearchData;
+export declare function filterMemoriesByType(data: SearchData, memType: string | null): SearchData;
+export declare function extractMemoriesFromResponse(data: SearchData): MemoryNode[];
+export declare function extractMcpType(memory: MemoryNode | Record<string, unknown>): string;
+export declare function computeMemoryStats(data: SearchData): [Record<string, number>, number];
+//# sourceMappingURL=query-processing.d.ts.map

package/dist/query-processing.js

@@ -0,0 +1,265 @@
+/**
+ * Query Processing Module
+ *
+ * Intent detection, keyword extraction, reranking, type extraction.
+ */
+import { MEMORY_TYPES } from "./config.js";
+import { ALL_STOPWORDS, extractKeywordsEnhanced, keywordMatchScoreEnhanced } from "./keyword-enhancer.js";
+// ============================================================================
+// Intent to Graph Type Mapping
+// ============================================================================
+export const INTENT_TO_GRAPHS = {
+    causal: ["CAUSE", "CONDITION"],
+    related: ["RELATE"],
+    conflict: ["CONFLICT"],
+    temporal: ["FOLLOWS"],
+    default: ["CAUSE", "RELATE", "CONDITION"],
+};
+export function detectQueryIntent(query) {
+    const q = query.toLowerCase();
+    const causalPatterns = [
+        /为什么/, /why/, /原因/, /cause/, /导致/, /因为/,
+        /根本原因/, /root\s*cause/, /怎么.*出错/, /how.*fail/,
+        /什么.*引起/, /what.*caused/, /出了什么问题/,
+    ];
+    if (causalPatterns.some((p) => p.test(q)))
+        return "causal";
+    const conflictPatterns = [
+        /冲突/, /conflict/, /矛盾/, /contradict/, /不一致/,
+        /inconsisten/, /问题.*之间/, /clash/,
+    ];
+    if (conflictPatterns.some((p) => p.test(q)))
+        return "conflict";
+    const temporalPatterns = [
+        /什么时候/, /when/, /之前/, /before/, /之后/, /after/,
+        /最近/, /recent/, /先.*后/, /顺序/, /timeline/, /历史/,
+        /上次/, /last\s*time/, /earlier/, /previously/,
+    ];
+    if (temporalPatterns.some((p) => p.test(q)))
+        return "temporal";
+    const relatedPatterns = [
+        /相关/, /related/, /关联/, /有关/, /涉及/,
+        /association/, /connect/, /link/,
+    ];
+    if (relatedPatterns.some((p) => p.test(q)))
+        return "related";
+    return "default";
+}
+export function getGraphsForIntent(intent) {
+    return INTENT_TO_GRAPHS[intent] ?? INTENT_TO_GRAPHS.default;
+}
+export function getIntentDescription(intent) {
+    const descriptions = {
+        causal: "🔍 因果分析 (Causal Analysis)",
+        related: "🔗 关联查询 (Related Search)",
+        conflict: "⚠️ 冲突检测 (Conflict Detection)",
+        temporal: "📅 时序查询 (Temporal Search)",
+        default: "📚 综合查询 (General Search)",
+    };
+    return descriptions[intent] ?? descriptions.default;
+}
+// ============================================================================
+// Memory Type Prefix Parsing
+// ============================================================================
+export function parseMemoryTypePrefix(query) {
+    if (!query)
+        return [null, ""];
+    const m = query.match(/^\s*\[?([A-Z_]+)\]?\s*[:\-]?\s*(.*)$/);
+    if (!m)
+        return [null, query.trim()];
+    const memType = m[1];
+    const rest = (m[2] ?? "").trim();
+    if (MEMORY_TYPES.has(memType)) {
+        return [memType, rest];
+    }
+    return [null, query.trim()];
+}
+// ============================================================================
+// Keyword Extraction
+// ============================================================================
+export function extractKeywords(query) {
+    return extractKeywordsEnhanced(query, ALL_STOPWORDS);
+}
+// ============================================================================
+// Keyword Match Score
+// ============================================================================
+export function keywordMatchScore(text, keywords, metadata, enableFuzzy = true) {
+    return keywordMatchScoreEnhanced(text, keywords, metadata, enableFuzzy);
+}
+// ============================================================================
+// Reranking
+// ============================================================================
+export function applyKeywordRerank(data, query, enableFuzzy = true) {
+    const keywords = extractKeywords(query);
+    if (keywords.length === 0)
+        return data;
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.nodes) {
+            memData.nodes = [...memData.nodes].sort((a, b) => {
+                const scoreA = (a.metadata?.relativity ?? 0) + keywordMatchScore(a.memory ?? "", keywords, a.metadata, enableFuzzy);
+                const scoreB = (b.metadata?.relativity ?? 0) + keywordMatchScore(b.memory ?? "", keywords, b.metadata, enableFuzzy);
+                return scoreB - scoreA;
+            });
+        }
+        else if (Array.isArray(memData)) {
+            memData.sort((a, b) => {
+                const scoreA = (a.metadata?.relativity ?? 0) + keywordMatchScore(a.memory ?? "", keywords, a.metadata, enableFuzzy);
+                const scoreB = (b.metadata?.relativity ?? 0) + keywordMatchScore(b.memory ?? "", keywords, b.metadata, enableFuzzy);
+                return scoreB - scoreA;
+            });
+        }
+    }
+    return data;
+}
+// ============================================================================
+// Edge Filtering by Intent
+// ============================================================================
+export function filterEdgesByIntent(data, intent) {
+    const allowedEdgeTypes = getGraphsForIntent(intent);
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.edges && memData.nodes) {
+            const filteredEdges = memData.edges.filter((edge) => edge.type && allowedEdgeTypes.includes(edge.type));
+            memData.edges = filteredEdges;
+            if (filteredEdges.length > 0) {
+                const boostedIds = new Set();
+                for (const edge of filteredEdges) {
+                    if (edge.source)
+                        boostedIds.add(edge.source);
+                    if (edge.target)
+                        boostedIds.add(edge.target);
+                }
+                for (const node of memData.nodes) {
+                    if (node.id && boostedIds.has(node.id) && node.metadata) {
+                        node.metadata.relativity = (node.metadata.relativity ?? 0) + 0.5;
+                        node.metadata.intent_matched = true;
+                    }
+                }
+            }
+        }
+    }
+    return data;
+}
+// ============================================================================
+// Memory Type Filter
+// ============================================================================
+export function filterMemoriesByType(data, memType) {
+    if (!memType)
+        return data;
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.nodes) {
+            const filtered = memData.nodes.filter((n) => new RegExp(`^\\[${memType}\\]`).test(n.memory ?? ""));
+            if (memData.edges) {
+                const keptIds = new Set(filtered.map((n) => n.id));
+                memData.edges = memData.edges.filter((e) => e.source && keptIds.has(e.source) && e.target && keptIds.has(e.target));
+            }
+            memData.nodes = filtered;
+        }
+        else if (Array.isArray(memData)) {
+            cubeData.memories = memData.filter((m) => new RegExp(`^\\[${memType}\\]`).test(m.memory ?? ""));
+        }
+    }
+    return data;
+}
+// ============================================================================
+// Memory Extraction
+// ============================================================================
+export function extractMemoriesFromResponse(data) {
+    const memories = [];
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.nodes) {
+            memories.push(...memData.nodes);
+        }
+        else if (Array.isArray(memData)) {
+            memories.push(...memData);
+        }
+    }
+    return memories;
+}
+// ============================================================================
+// MCP Type Extraction
+// ============================================================================
+const VALID_MEMORY_TYPES = new Set([
+    "BUGFIX", "ERROR_PATTERN", "DECISION", "GOTCHA", "CODE_PATTERN",
+    "CONFIG", "FEATURE", "MILESTONE", "PROGRESS",
+]);
+const TYPE_PATTERN = /^\[([A-Z_]+)\]/;
+function extractTypeFromText(text) {
+    const m = TYPE_PATTERN.exec(text);
+    if (m && VALID_MEMORY_TYPES.has(m[1]))
+        return m[1];
+    return null;
+}
+function decodeSourceEntry(entry) {
+    if (entry && typeof entry === "object")
+        return entry;
+    if (typeof entry !== "string")
+        return null;
+    try {
+        let result = JSON.parse(entry);
+        if (typeof result === "string")
+            result = JSON.parse(result);
+        return typeof result === "object" && result !== null ? result : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractTypeFromSources(sources) {
+    if (!sources || sources.length === 0)
+        return null;
+    for (const entry of sources) {
+        const decoded = decodeSourceEntry(entry);
+        if (decoded) {
+            const content = String(decoded.content ?? "");
+            const found = extractTypeFromText(content);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+export function extractMcpType(memory) {
+    // 1. [TYPE] prefix in memory text
+    const memText = memory.memory ?? "";
+    const fromText = extractTypeFromText(memText);
+    if (fromText)
+        return fromText;
+    // 2. [TYPE] prefix in sources (tree_text mode)
+    const sources = memory.sources ??
+        (memory.metadata?.sources) ??
+        [];
+    const fromSources = extractTypeFromSources(sources);
+    if (fromSources)
+        return fromSources;
+    // 3. LLM-inferred nodes
+    const meta = memory.metadata ?? memory;
+    const nodeType = typeof meta === "object" ? meta.type : null;
+    const key = memory.key ?? (typeof meta === "object" ? String(meta.key ?? "") : "");
+    if (nodeType === "reasoning" || String(key).startsWith("InferredFact")) {
+        return "INFERRED";
+    }
+    return "PROGRESS";
+}
+// ============================================================================
+// Stats
+// ============================================================================
+export function computeMemoryStats(data) {
+    const memories = extractMemoriesFromResponse(data);
+    const stats = {};
+    let total = 0;
+    for (const mem of memories) {
+        total++;
+        const memType = extractMcpType(mem);
+        stats[memType] = (stats[memType] ?? 0) + 1;
+    }
+    return [stats, total];
+}
+//# sourceMappingURL=query-processing.js.map

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MemOS MCP Server — McpServer setup + background init
+ */
+export declare function runServer(): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,114 @@
+/**
+ * MemOS MCP Server — McpServer setup + background init
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { MEMOS_DEFAULT_CUBE, MEMOS_ENABLE_DELETE, logger } from "./config.js";
+import { waitForApiReady } from "./api-client.js";
+import { ensureCubeRegistered } from "./cube-manager.js";
+import { toolSchemas } from "./tools-registry.js";
+import { dispatchTool, handleApiUnreachable } from "./handlers/index.js";
+// ============================================================================
+// Register All Tools
+// ============================================================================
+function registerTools(server) {
+    for (const [name, schema] of Object.entries(toolSchemas)) {
+        // Skip delete tool if not enabled
+        if (name === "memos_delete" && !MEMOS_ENABLE_DELETE) {
+            logger.debug("Delete tool skipped (MEMOS_ENABLE_DELETE=false)");
+            continue;
+        }
+        server.registerTool(name, {
+            description: schema.description,
+            inputSchema: schema.inputSchema,
+        }, async (args) => {
+            try {
+                const result = await dispatchTool(name, args);
+                return {
+                    content: result.map((r) => ({ type: "text", text: r.text })),
+                };
+            }
+            catch (err) {
+                const errStr = String(err);
+                if (errStr.includes("ECONNREFUSED") || errStr.includes("fetch failed")) {
+                    const unreachable = await handleApiUnreachable();
+                    return {
+                        content: unreachable.map((r) => ({ type: "text", text: r.text })),
+                    };
+                }
+                logger.exception("Tool call failed", err);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `❌ [UNEXPECTED_ERROR] ${errStr}`,
+                                "",
+                                "💡 Suggestions:",
+                                "- Check MCP server logs for details",
+                                "- Verify MemOS API is healthy: `curl http://localhost:18000/health/detail`",
+                            ].join("\n"),
+                        },
+                    ],
+                };
+            }
+        });
+    }
+    if (MEMOS_ENABLE_DELETE) {
+        logger.debug("Delete tool enabled (MEMOS_ENABLE_DELETE=true)");
+    }
+}
+// ============================================================================
+// Background Init
+// ============================================================================
+async function backgroundInit() {
+    try {
+        const apiReady = await waitForApiReady();
+        if (apiReady) {
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const [regSuccess, regError] = await ensureCubeRegistered(MEMOS_DEFAULT_CUBE, true);
+                    if (regSuccess) {
+                        logger.debug(`Default cube '${MEMOS_DEFAULT_CUBE}' ready`);
+                        return;
+                    }
+                    logger.warning(`Cube registration attempt ${attempt + 1} failed: ${regError}`);
+                    await sleep(2000);
+                }
+                catch (err) {
+                    logger.warning(`Registration attempt ${attempt + 1} error: ${err}`);
+                    await sleep(2000);
+                }
+            }
+        }
+        else {
+            logger.warning("API not ready, will register cube on first tool call");
+        }
+    }
+    catch (err) {
+        logger.warning(`Background init failed: ${err}`);
+    }
+}
+// ============================================================================
+// Run Server
+// ============================================================================
+export async function runServer() {
+    const server = new McpServer({
+        name: "memos-memory",
+        version: "1.0.0",
+    });
+    registerTools(server);
+    const transport = new StdioServerTransport();
+    // Connect FIRST (completes MCP handshake immediately),
+    // then do background init to prevent Claude Code timeout.
+    await server.connect(transport);
+    // Background init — don't await
+    backgroundInit().catch((err) => {
+        logger.error(`Background init error: ${err}`);
+    });
+    logger.debug("MemOS MCP Server (Node.js) started");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=server.js.map