oh-memos-mcp 1.0.0

package/dist/handlers/graph.js

@@ -0,0 +1,502 @@
+/**
+ * Graph Handlers
+ *
+ * memos_trace_path, memos_get_graph, memos_export_schema, memos_impact
+ */
+import { MEMOS_URL, MEMOS_USER, NEO4J_HTTP_URL, NEO4J_USER, NEO4J_PASSWORD, logger, registeredCubes } from "../config.js";
+import { fetchWithTimeout } from "../api-client.js";
+import { ensureCubeRegistered } from "../cube-manager.js";
+import { detectQueryIntent, extractMemoriesFromResponse, getGraphsForIntent, getIntentDescription, } from "../query-processing.js";
+import { ERR_NEO4J_CONFIG, ERR_PARAM_MISSING, apiErrorResponse, cubeRegistrationError, errorResponse, getCubeIdFromArgs, } from "./utils.js";
+// ============================================================================
+// Neo4j Helper
+// ============================================================================
+function neo4jAuthHeader() {
+    return `Basic ${Buffer.from(`${NEO4J_USER}:${NEO4J_PASSWORD}`).toString("base64")}`;
+}
+async function neo4jQuery(cypher, parameters) {
+    try {
+        const response = await fetchWithTimeout(NEO4J_HTTP_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: neo4jAuthHeader(),
+            },
+            body: JSON.stringify({
+                statements: [{ statement: cypher, parameters }],
+            }),
+            timeoutMs: 15,
+        });
+        const data = await response.json();
+        return { ok: response.ok, data, status: response.status };
+    }
+    catch (err) {
+        logger.error(`Neo4j query error: ${err}`);
+        return { ok: false, data: null, status: 0 };
+    }
+}
+// ============================================================================
+// memos_trace_path
+// ============================================================================
+export async function handleMemosTracePath(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const sourceId = String(arguments_.source_id ?? "");
+    const targetId = String(arguments_.target_id ?? "");
+    const maxDepth = Math.min(Number(arguments_.max_depth ?? 3), 10);
+    if (!sourceId || !targetId) {
+        return errorResponse("Both source_id and target_id are required", ERR_PARAM_MISSING, [
+            "Get node IDs from memos_search or memos_get_graph",
+            '`memos_trace_path(source_id="uuid-1", target_id="uuid-2")`',
+        ]);
+    }
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    try {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/product/graph/trace_path`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_id: MEMOS_USER,
+                source_id: sourceId,
+                target_id: targetId,
+                max_depth: maxDepth,
+                include_all_paths: false,
+                mem_cube_id: cubeId,
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                const traceData = data.data ?? {};
+                const found = traceData.path_found ?? traceData.found ?? false;
+                const paths = traceData.paths ?? [];
+                const sourceNode = traceData.source ?? {};
+                const targetNode = traceData.target ?? {};
+                const results = ["## 🔗 Path Trace Results", ""];
+                if (sourceNode.memory)
+                    results.push(`**Source**: ${String(sourceNode.memory).slice(0, 80)}...`);
+                if (targetNode.memory)
+                    results.push(`**Target**: ${String(targetNode.memory).slice(0, 80)}...`);
+                results.push("");
+                if (!found) {
+                    results.push(`*No path found within ${maxDepth} hops.*`, "");
+                    results.push("Suggestions:");
+                    results.push("- Try increasing max_depth (up to 10)");
+                    results.push("- Verify the node IDs are correct");
+                    results.push("- The nodes may not be connected in the graph");
+                }
+                else {
+                    for (let i = 0; i < paths.length; i++) {
+                        const path = paths[i];
+                        const length = path.length ?? 0;
+                        const nodes = path.nodes ?? [];
+                        const edges = path.edges ?? [];
+                        // If API returns empty nodes, fall back to Neo4j
+                        if (nodes.length === 0 && NEO4J_HTTP_URL && NEO4J_USER && NEO4J_PASSWORD) {
+                            throw new Error("API returned empty path nodes, falling back to Neo4j");
+                        }
+                        results.push(`### Path ${i + 1} (Length: ${length})`, "", "```");
+                        for (let j = 0; j < nodes.length; j++) {
+                            const node = nodes[j];
+                            const nodeMem = String(node.memory ?? "").slice(0, 60);
+                            results.push(`[${j + 1}] ${nodeMem}...`);
+                            if (j < edges.length) {
+                                const edge = edges[j];
+                                results.push("    │");
+                                results.push(`    └── ${edge.type ?? "UNKNOWN"} ──>`);
+                            }
+                        }
+                        results.push("```", "");
+                    }
+                }
+                return [{ type: "text", text: results.join("\n") }];
+            }
+            else {
+                return apiErrorResponse("Trace path", String(data.message ?? "Unknown error"));
+            }
+        }
+        else {
+            throw new Error(`HTTP ${response.status}`);
+        }
+    }
+    catch (err) {
+        logger.warning(`Falling back to direct Neo4j query: ${err}`);
+        if (!NEO4J_HTTP_URL || !NEO4J_USER || !NEO4J_PASSWORD) {
+            return errorResponse("Neo4j configuration missing", ERR_NEO4J_CONFIG, [
+                "Set NEO4J_HTTP_URL, NEO4J_USER, NEO4J_PASSWORD in .env",
+                "Example: NEO4J_HTTP_URL=http://localhost:7474/db/neo4j/tx/commit",
+            ]);
+        }
+        const cypher = `
+      MATCH (source:Memory), (target:Memory)
+      WHERE source.id = $source_id AND target.id = $target_id
+      MATCH path = shortestPath((source)-[*1..${maxDepth}]-(target))
+      RETURN [n IN nodes(path) | {id: n.id, memory: n.memory}] AS nodes,
+             [r IN relationships(path) | {type: type(r)}] AS rels
+      LIMIT 1
+    `;
+        const { ok, data, status } = await neo4jQuery(cypher, { source_id: sourceId, target_id: targetId });
+        const results = ["## 🔗 Path Trace (Direct Query)", ""];
+        if (ok && data) {
+            const rows = data.results?.[0]?.data ?? [];
+            if (rows.length > 0) {
+                const row = rows[0].row ?? [[], []];
+                const nodes = row[0] ?? [];
+                const rels = row[1] ?? [];
+                results.push("```");
+                for (let j = 0; j < nodes.length; j++) {
+                    const nodeMem = String(nodes[j].memory ?? "").slice(0, 60);
+                    results.push(`[${j + 1}] ${nodeMem}...`);
+                    if (j < rels.length) {
+                        results.push(`    └── ${rels[j].type ?? "?"} ──>`);
+                    }
+                }
+                results.push("```");
+            }
+            else {
+                results.push(`*No path found within ${maxDepth} hops.*`);
+            }
+        }
+        else {
+            results.push(`*Neo4j query error: ${status}*`);
+        }
+        return [{ type: "text", text: results.join("\n") }];
+    }
+}
+// ============================================================================
+// memos_get_graph
+// ============================================================================
+export async function handleMemosGetGraph(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const query = String(arguments_.query ?? "");
+    const intent = detectQueryIntent(query);
+    const targetEdgeTypes = getGraphsForIntent(intent);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    if (!NEO4J_HTTP_URL || !NEO4J_USER || !NEO4J_PASSWORD) {
+        return errorResponse("Neo4j configuration missing", ERR_NEO4J_CONFIG, [
+            "Set NEO4J_HTTP_URL, NEO4J_USER, NEO4J_PASSWORD in .env",
+            "Example: NEO4J_HTTP_URL=http://localhost:7474/db/neo4j/tx/commit",
+        ]);
+    }
+    // Search for relevant memories first
+    let memories = [];
+    try {
+        const searchResponse = await fetchWithTimeout(`${MEMOS_URL}/search`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_id: MEMOS_USER,
+                query,
+                install_cube_ids: [cubeId],
+            }),
+        });
+        if (searchResponse.ok) {
+            const data = await searchResponse.json();
+            if (data.code === 200) {
+                memories = extractMemoriesFromResponse(data.data ?? {});
+            }
+            else {
+                // Re-register and retry
+                registeredCubes.delete(cubeId);
+                const [retrySuccess] = await ensureCubeRegistered(cubeId, true);
+                if (retrySuccess) {
+                    const retrySearch = await fetchWithTimeout(`${MEMOS_URL}/search`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ user_id: MEMOS_USER, query, install_cube_ids: [cubeId] }),
+                    });
+                    if (retrySearch.ok) {
+                        const retryData = await retrySearch.json();
+                        if (retryData.code === 200) {
+                            memories = extractMemoriesFromResponse(retryData.data ?? {});
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warning(`Graph search failed: ${err}`);
+    }
+    // Build Cypher query
+    const edgeTypesCypher = targetEdgeTypes.join("|");
+    const memIds = memories
+        .slice(0, 10)
+        .map((m) => m.id ?? m.metadata?.id)
+        .filter(Boolean);
+    let cypher;
+    let params;
+    if (memIds.length > 0) {
+        const idList = memIds.map((id) => `"${id}"`).join(", ");
+        cypher = `
+      MATCH (a)-[r:${edgeTypesCypher}]->(b)
+      WHERE a.id IN [${idList}] OR b.id IN [${idList}]
+      RETURN a.id as source_id, a.memory as source_memory,
+             type(r) as relation_type,
+             b.id as target_id, b.memory as target_memory
+      LIMIT 20
+    `;
+        params = {};
+    }
+    else {
+        const firstWord = query.split(/\s+/)[0] ?? query;
+        cypher = `
+      MATCH (a)-[r:${edgeTypesCypher}]->(b)
+      WHERE a.memory CONTAINS $keyword OR b.memory CONTAINS $keyword
+      RETURN a.id as source_id, a.memory as source_memory,
+             type(r) as relation_type,
+             b.id as target_id, b.memory as target_memory
+      LIMIT 20
+    `;
+        params = { keyword: firstWord };
+    }
+    const { ok, data, status } = await neo4jQuery(cypher, params);
+    const results = [];
+    const intentDesc = getIntentDescription(intent);
+    results.push(`## 🧠 Knowledge Graph: ${cubeId}`);
+    results.push(`Query: \`${query}\` | ${intentDesc}`);
+    results.push(`*Filtering edges: ${targetEdgeTypes.join(", ")}*`);
+    results.push("");
+    if (memories.length > 0) {
+        results.push("### 📝 Related Memories", "");
+        for (let i = 0; i < Math.min(memories.length, 5); i++) {
+            const memory = memories[i].memory ?? "";
+            const firstLine = memory.split("\n")[0].slice(0, 100);
+            results.push(`${i + 1}. ${firstLine}`);
+        }
+        results.push("");
+    }
+    if (ok && data) {
+        const rows = data.results?.[0]?.data ?? [];
+        if (rows.length > 0) {
+            results.push("### 🔗 Relationships", "```");
+            for (const row of rows) {
+                const r = row.row ?? [];
+                if (r.length >= 5) {
+                    const sourceMem = String(r[1] ?? "").slice(0, 50);
+                    const relType = String(r[2] ?? "UNKNOWN");
+                    const targetMem = String(r[4] ?? "").slice(0, 50);
+                    let arrow;
+                    if (relType === "CAUSE")
+                        arrow = "──CAUSE──>";
+                    else if (relType === "RELATE")
+                        arrow = "──RELATE──";
+                    else if (relType === "CONFLICT")
+                        arrow = "══CONFLICT══";
+                    else
+                        arrow = `──${relType}──>`;
+                    results.push(`[${sourceMem}...]`);
+                    results.push(`    ${arrow}`);
+                    results.push(`[${targetMem}...]`);
+                    results.push("");
+                }
+            }
+            results.push("```");
+        }
+        else {
+            results.push("*No relationships found for this query.*");
+        }
+    }
+    else {
+        results.push(`*Neo4j query error: ${status}*`);
+    }
+    return [{ type: "text", text: results.join("\n") }];
+}
+// ============================================================================
+// memos_export_schema
+// ============================================================================
+export async function handleMemosExportSchema(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const sampleSize = Math.min(Math.max(Number(arguments_.sample_size ?? 100), 10), 1000);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    try {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/graph/schema`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_id: MEMOS_USER,
+                mem_cube_id: cubeId,
+                sample_size: sampleSize,
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                const schema = data.data ?? {};
+                const results = [];
+                results.push("## 📊 Knowledge Graph Schema", "");
+                results.push("### Overview");
+                results.push(`- **Total Nodes**: ${schema.total_nodes ?? 0}`);
+                results.push(`- **Total Edges**: ${schema.total_edges ?? 0}`);
+                results.push(`- **Avg Connections/Node**: ${Number(schema.avg_connections_per_node ?? 0).toFixed(2)}`);
+                results.push(`- **Max Connections**: ${schema.max_connections ?? 0}`);
+                results.push(`- **Orphan Nodes**: ${schema.orphan_node_count ?? 0}`);
+                results.push("");
+                const timeRange = schema.time_range ?? {};
+                if (timeRange.earliest || timeRange.latest) {
+                    results.push("### Time Range");
+                    if (timeRange.earliest)
+                        results.push(`- Earliest: ${timeRange.earliest}`);
+                    if (timeRange.latest)
+                        results.push(`- Latest: ${timeRange.latest}`);
+                    results.push("");
+                }
+                const edgeDist = schema.edge_type_distribution ?? {};
+                if (Object.keys(edgeDist).length > 0) {
+                    results.push("### Relationship Types");
+                    for (const [t, c] of Object.entries(edgeDist).sort((a, b) => b[1] - a[1])) {
+                        results.push(`- **${t}**: ${c}`);
+                    }
+                    results.push("");
+                }
+                const memDist = schema.memory_type_distribution ?? {};
+                if (Object.keys(memDist).length > 0) {
+                    results.push("### Memory Types");
+                    for (const [t, c] of Object.entries(memDist).sort((a, b) => b[1] - a[1])) {
+                        results.push(`- ${t}: ${c}`);
+                    }
+                    results.push("");
+                }
+                const tagFreq = schema.tag_frequency ?? {};
+                const tagItems = Object.entries(tagFreq).slice(0, 10);
+                if (tagItems.length > 0) {
+                    results.push("### Top Tags");
+                    for (const [tag, count] of tagItems) {
+                        results.push(`- \`${tag}\`: ${count}`);
+                    }
+                    results.push("");
+                }
+                results.push("### Health Assessment");
+                const totalNodes = Number(schema.total_nodes ?? 0);
+                const orphanCount = Number(schema.orphan_node_count ?? 0);
+                if (totalNodes > 0) {
+                    const orphanRatio = orphanCount / totalNodes;
+                    if (orphanRatio > 0.5)
+                        results.push("⚠️ High orphan ratio - many memories are not connected");
+                    else if (orphanRatio > 0.2)
+                        results.push("📋 Moderate orphan ratio");
+                    else
+                        results.push("✅ Good connectivity - memories are well connected");
+                }
+                const avgConn = Number(schema.avg_connections_per_node ?? 0);
+                if (avgConn < 1)
+                    results.push("⚠️ Low average connections - consider enriching relationships");
+                else if (avgConn > 5)
+                    results.push("✅ Rich relationships - good knowledge graph density");
+                return [{ type: "text", text: results.join("\n") }];
+            }
+            else {
+                return apiErrorResponse("Schema export", String(data.message ?? "Unknown error"));
+            }
+        }
+        else {
+            return apiErrorResponse("Schema export", `HTTP ${response.status}`);
+        }
+    }
+    catch (err) {
+        return apiErrorResponse("Schema export", String(err));
+    }
+}
+// ============================================================================
+// memos_impact
+// ============================================================================
+export async function handleMemosImpact(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const memoryId = String(arguments_.memory_id ?? "");
+    const maxDepth = Math.min(Math.max(Number(arguments_.max_depth ?? 3), 1), 6);
+    if (!memoryId) {
+        return errorResponse("memory_id is required", ERR_PARAM_MISSING, [
+            "Get a memory_id from memos_search or memos_get_graph first",
+            '`memos_impact(memory_id="uuid-here")`',
+        ]);
+    }
+    if (!NEO4J_HTTP_URL || !NEO4J_USER || !NEO4J_PASSWORD) {
+        return errorResponse("Neo4j configuration missing", ERR_NEO4J_CONFIG, [
+            "Set NEO4J_HTTP_URL, NEO4J_USER, NEO4J_PASSWORD in .env",
+            "Example: NEO4J_HTTP_URL=http://localhost:7474/db/neo4j/tx/commit",
+        ]);
+    }
+    const cypher = `
+    MATCH (source:Memory {id: $source_id})-[:CAUSE|FOLLOWS*1..${maxDepth}]->(node:Memory)
+    WITH DISTINCT source, node
+    MATCH path = shortestPath((source)-[:CAUSE|FOLLOWS*1..${maxDepth}]->(node))
+    RETURN node.id AS id, node.key AS key, node.memory AS memory,
+           length(path) AS depth
+    ORDER BY depth ASC
+    LIMIT 30
+  `;
+    try {
+        const { ok, data, status } = await neo4jQuery(cypher, { source_id: memoryId });
+        if (!ok) {
+            return apiErrorResponse("Impact analysis", `Neo4j HTTP ${status}`);
+        }
+        if (!data) {
+            return apiErrorResponse("Impact analysis", "No data returned");
+        }
+        const errors = data.errors ?? [];
+        if (errors.length > 0) {
+            const errMsg = String(errors[0].message ?? "Unknown Neo4j error");
+            return apiErrorResponse("Impact analysis", errMsg);
+        }
+        const rows = data.results?.[0]?.data ?? [];
+        if (rows.length === 0) {
+            return [{ type: "text", text: "No forward impact found — this memory has no CAUSE or FOLLOWS successors." }];
+        }
+        // Group by depth
+        const depthGroups = {};
+        for (const row of rows) {
+            const r = row.row ?? [];
+            if (r.length >= 4) {
+                const depth = Number(r[3]);
+                if (!depthGroups[depth])
+                    depthGroups[depth] = [];
+                depthGroups[depth].push({
+                    id: String(r[0] ?? ""),
+                    key: String(r[1] ?? ""),
+                    memory: String(r[2] ?? ""),
+                });
+            }
+        }
+        const totalCount = Object.values(depthGroups).reduce((sum, items) => sum + items.length, 0);
+        const maxHop = Math.max(...Object.keys(depthGroups).map(Number));
+        const results = [
+            "## Impact Analysis",
+            "",
+            `**Blast Radius: ${totalCount} downstream memories across ${maxHop} hop(s)**`,
+            "",
+        ];
+        const depthLabels = {
+            1: "Direct Impact",
+            2: "Indirect Impact",
+        };
+        for (const depth of Object.keys(depthGroups).map(Number).sort((a, b) => a - b)) {
+            const items = depthGroups[depth];
+            const label = depthLabels[depth] ?? `Downstream (hop ${depth})`;
+            results.push(`### ${label} (${items.length} node${items.length !== 1 ? "s" : ""})`, "");
+            for (let i = 0; i < Math.min(items.length, 8); i++) {
+                const item = items[i];
+                const memPreview = item.memory.split("\n")[0].slice(0, 100);
+                if (item.key) {
+                    results.push(`- **${item.key}**: ${memPreview}`);
+                }
+                else {
+                    results.push(`- ${memPreview}`);
+                }
+            }
+            if (items.length > 8) {
+                results.push(`- ... and ${items.length - 8} more`);
+            }
+            results.push("");
+        }
+        return [{ type: "text", text: results.join("\n") }];
+    }
+    catch (err) {
+        return apiErrorResponse("Impact analysis", String(err));
+    }
+}
+//# sourceMappingURL=graph.js.map

package/dist/handlers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tool Handler Dispatcher
+ */
+import type { TextContent } from "../types.js";
+export declare function dispatchTool(name: string, arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleApiUnreachable(): Promise<TextContent[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/index.js

@@ -0,0 +1,71 @@
+/**
+ * Tool Handler Dispatcher
+ */
+import { handleMemosSave, handleMemosList, handleMemosGet, handleMemosGetStats } from "./memory.js";
+import { handleMemosSearch, handleMemosSearchContext, handleMemosSuggest, handleMemosContextResume } from "./search.js";
+import { handleMemosTracePath, handleMemosGetGraph, handleMemosExportSchema, handleMemosImpact } from "./graph.js";
+import { handleMemosCalendar } from "./calendar.js";
+import { handleMemosListCubes, handleMemosRegisterCube, handleMemosCreateUser, handleMemosValidateCubes, handleMemosDelete, } from "./admin.js";
+import { MEMOS_URL } from "../config.js";
+import { errorResponse } from "./utils.js";
+export async function dispatchTool(name, arguments_) {
+    switch (name) {
+        // Memory tools
+        case "memos_save":
+            return handleMemosSave(arguments_);
+        case "memos_list_v2":
+            return handleMemosList(arguments_);
+        case "memos_get":
+            return handleMemosGet(arguments_);
+        case "memos_get_stats":
+            return handleMemosGetStats(arguments_);
+        // Search tools
+        case "memos_search":
+            return handleMemosSearch(arguments_);
+        case "memos_search_context":
+            return handleMemosSearchContext(arguments_);
+        case "memos_suggest":
+            return handleMemosSuggest(arguments_);
+        case "memos_context_resume":
+            return handleMemosContextResume(arguments_);
+        // Graph tools
+        case "memos_trace_path":
+            return handleMemosTracePath(arguments_);
+        case "memos_get_graph":
+            return handleMemosGetGraph(arguments_);
+        case "memos_export_schema":
+            return handleMemosExportSchema(arguments_);
+        case "memos_impact":
+            return handleMemosImpact(arguments_);
+        // Calendar
+        case "memos_calendar":
+            return handleMemosCalendar(arguments_);
+        // Admin tools
+        case "memos_list_cubes":
+            return handleMemosListCubes(arguments_);
+        case "memos_register_cube":
+            return handleMemosRegisterCube(arguments_);
+        case "memos_create_user":
+            return handleMemosCreateUser(arguments_);
+        case "memos_validate_cubes":
+            return handleMemosValidateCubes(arguments_);
+        case "memos_delete":
+            return handleMemosDelete(arguments_);
+        default:
+            return errorResponse(`Unknown tool: ${name}`);
+    }
+}
+export async function handleApiUnreachable() {
+    return [{
+            type: "text",
+            text: [
+                `❌ [API_UNREACHABLE] Cannot connect to MemOS API at ${MEMOS_URL}`,
+                "",
+                "💡 Suggestions:",
+                "- Check if MemOS API is running: `curl http://localhost:18000/health`",
+                "- Start with: `scripts/local/start.bat`",
+                "- Check port availability",
+            ].join("\n"),
+        }];
+}
+//# sourceMappingURL=index.js.map

package/dist/handlers/memory.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Memory Handlers
+ *
+ * memos_save, memos_list_v2, memos_get, memos_get_stats
+ */
+import type { TextContent, MemoryNode, SearchData } from "../types.js";
+export declare function handleMemosSave(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosList(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosGet(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosGetStats(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function extractMemoriesFromData(data: SearchData): MemoryNode[];
+//# sourceMappingURL=memory.d.ts.map