@cchez/memory-mcp 1.0.0

package/db/docker-compose.yml

@@ -0,0 +1,33 @@
+version: "3.8"
+
+services:
+  qdrant:
+    image: qdrant/qdrant:latest
+    ports:
+      - "6333:6333"
+      - "6334:6334"
+    volumes:
+      - ./qdrant_data:/qdrant/storage
+    restart: always
+    environment:
+      - QDRANT__SERVICE__GRPC_PORT=6334
+
+  ollama:
+    image: ollama/ollama:latest
+    ports:
+      - "11434:11434"
+    volumes:
+      - ./ollama_data:/root/.ollama
+    restart: always
+    # Pull bge-m3 on first start if not already cached
+    entrypoint: >
+      sh -c "ollama serve &
+             sleep 5 &&
+             ollama pull bge-m3 &&
+             wait"
+    healthcheck:
+      test: ["CMD", "curl", "-sf", "http://localhost:11434/api/tags"]
+      interval: 10s
+      timeout: 5s
+      retries: 12
+      start_period: 60s

package/dist/embedding.js

@@ -0,0 +1,54 @@
+import OpenAI from "openai";
+export class OpenAIEmbeddingProvider {
+    client;
+    model;
+    constructor(apiKey = process.env.OPENAI_API_KEY, model = "text-embedding-3-small") {
+        if (!apiKey)
+            throw new Error("OPENAI_API_KEY is required");
+        this.client = new OpenAI({ apiKey });
+        this.model = model;
+    }
+    async embed(text) {
+        const response = await this.client.embeddings.create({
+            model: this.model,
+            input: text,
+        });
+        return response.data[0].embedding;
+    }
+}
+export class OllamaEmbeddingProvider {
+    baseUrl;
+    model;
+    constructor(baseUrl = process.env.OLLAMA_BASE_URL ?? "http://localhost:11434", model = process.env.OLLAMA_MODEL ?? "nomic-embed-text") {
+        this.baseUrl = baseUrl;
+        this.model = model;
+    }
+    async embed(text) {
+        const response = await fetch(`${this.baseUrl}/api/embeddings`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: this.model, prompt: text }),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Ollama embedding failed: ${response.status} — ${body}`);
+        }
+        const data = (await response.json());
+        return data.embedding;
+    }
+}
+let _provider = null;
+export function getEmbeddingProvider() {
+    if (!_provider) {
+        const providerName = process.env.EMBEDDING_PROVIDER ?? "openai";
+        if (providerName === "ollama") {
+            _provider = new OllamaEmbeddingProvider();
+            console.error(`[embedding] Using Ollama: ${process.env.OLLAMA_MODEL ?? "nomic-embed-text"}`);
+        }
+        else {
+            _provider = new OpenAIEmbeddingProvider();
+            console.error("[embedding] Using OpenAI");
+        }
+    }
+    return _provider;
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { storeMemorySchema, storeMemory } from "./tools/store.js";
+import { searchMemorySchema, searchMemoryTool } from "./tools/search.js";
+import { deleteMemorySchema, deleteMemoryTool } from "./tools/delete.js";
+import { listMemoriesSchema, listMemoriesTool } from "./tools/list.js";
+import { correctMemorySchema, correctMemoryTool } from "./tools/correct.js";
+import { captureEpisodeSchema, captureEpisodeTool } from "./tools/episode.js";
+import { initCollections } from "./qdrant.js";
+async function main() {
+    await initCollections();
+    const server = new McpServer({
+        name: "knowledge-base",
+        version: "1.0.0",
+    });
+    server.tool("store_memory", "将知识内容向量化并存入知识库。根据 memory_type 自动路由到对应 collection：rule/decision/preference → coding，fact/summary → workspace。内容相同时自动去重。返回 id 和 collection。", storeMemorySchema.shape, async (args) => {
+        const result = await storeMemory(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    });
+    server.tool("search_memory", "混合搜索知识库。默认同时搜 coding + workspace 两个 collection，并融合向量相似度、关键词匹配、recency 和 MMR 去重。支持 source/tags/memory_type/status 过滤和 score_threshold 阈值。", searchMemorySchema.shape, async (args) => {
+        const results = await searchMemoryTool(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        };
+    });
+    server.tool("delete_memory", "按 ID 删除指定记忆条目。需同时提供 collection 名称（coding 或 workspace）。", deleteMemorySchema.shape, async (args) => {
+        const result = await deleteMemoryTool(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    });
+    server.tool("list_memories", "列出指定 collection 中的 active 记忆条目，支持分页和 source/memory_type 过滤。可设置 include_inactive 审计 superseded/deprecated 条目。", listMemoriesSchema.shape, async (args) => {
+        const results = await listMemoriesTool(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        };
+    });
+    server.tool("correct_memory", "根据用户纠正或新事实修订一条记忆：写入新 active 记忆，并把旧记忆标记为 superseded，保留 supersedes/superseded_by 修订链。", correctMemorySchema.shape, async (args) => {
+        const result = await correctMemoryTool(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    });
+    server.tool("capture_episode", "Opt-in 捕获任务/调试 episode 的结构化总结和可复用观察。只保存调用方提供的摘要和 observations，不自动保存 raw conversation/tool trace。", captureEpisodeSchema.shape, async (args) => {
+        const result = await captureEpisodeTool(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[knowledge-base] MCP server started (stdio)");
+}
+main().catch((err) => {
+    console.error("[knowledge-base] Fatal error:", err);
+    process.exit(1);
+});

package/dist/qdrant.js

@@ -0,0 +1,349 @@
+import { QdrantClient } from "@qdrant/js-client-rest";
+const QDRANT_URL = process.env.QDRANT_URL ?? "http://localhost:6333";
+const VECTOR_SIZE = parseInt(process.env.EMBEDDING_DIMENSIONS ?? "1536", 10);
+// coding: rules, architecture decisions, technical constraints, tool preferences
+// workspace: slack summaries, confluence pages, meeting notes, team facts
+export const COLLECTIONS = {
+    coding: process.env.CODING_COLLECTION ?? "coding",
+    workspace: process.env.WORKSPACE_COLLECTION ?? "workspace",
+};
+// Auto-routing: memory_type → collection
+const MEMORY_TYPE_COLLECTION = {
+    rule: "coding",
+    decision: "coding",
+    preference: "coding",
+    fact: "workspace",
+    summary: "workspace",
+};
+export function collectionForType(memoryType) {
+    return MEMORY_TYPE_COLLECTION[memoryType];
+}
+const client = new QdrantClient({ url: QDRANT_URL });
+export async function initCollections() {
+    const existing = await client.getCollections();
+    const existingNames = new Set(existing.collections.map((c) => c.name));
+    for (const [key, name] of Object.entries(COLLECTIONS)) {
+        if (!existingNames.has(name)) {
+            await client.createCollection(name, {
+                vectors: { size: VECTOR_SIZE, distance: "Cosine" },
+            });
+            console.error(`[qdrant] Created collection: ${name} (${key})`);
+        }
+        else {
+            console.error(`[qdrant] Collection exists: ${name} (${key})`);
+        }
+    }
+}
+export async function upsertMemory(id, vector, payload) {
+    const col = COLLECTIONS[collectionForType(payload.memory_type)];
+    const now = new Date().toISOString();
+    await client.upsert(col, {
+        points: [
+            {
+                id,
+                vector,
+                payload: {
+                    ...payload,
+                    status: payload.status ?? "active",
+                    updated_at: payload.updated_at ?? now,
+                },
+            },
+        ],
+    });
+}
+export async function deleteMemory(id, collection) {
+    await client.delete(COLLECTIONS[collection], { points: [id] });
+}
+function buildFilter(sourceFilter, tagsFilter, memoryTypeFilter, includeInactive = false) {
+    const mustClauses = [];
+    const mustNotClauses = [];
+    if (sourceFilter !== undefined) {
+        mustClauses.push({ key: "source", match: { value: sourceFilter } });
+    }
+    if (tagsFilter && tagsFilter.length > 0) {
+        for (const tag of tagsFilter) {
+            mustClauses.push({ key: "tags", match: { value: tag } });
+        }
+    }
+    if (memoryTypeFilter !== undefined) {
+        mustClauses.push({ key: "memory_type", match: { value: memoryTypeFilter } });
+    }
+    if (!includeInactive) {
+        mustNotClauses.push({ key: "status", match: { value: "superseded" } });
+        mustNotClauses.push({ key: "status", match: { value: "deprecated" } });
+    }
+    if (mustClauses.length === 0 && mustNotClauses.length === 0) {
+        return undefined;
+    }
+    return {
+        ...(mustClauses.length > 0 ? { must: mustClauses } : {}),
+        ...(mustNotClauses.length > 0 ? { must_not: mustNotClauses } : {}),
+    };
+}
+function payloadToSearchResult(id, payload, collection, score, vectorScore, keywordScore, recencyScore) {
+    return {
+        id,
+        content: payload.content,
+        source: payload.source,
+        memory_type: payload.memory_type,
+        collection,
+        tags: payload.tags,
+        score,
+        vector_score: vectorScore,
+        keyword_score: keywordScore,
+        recency_score: recencyScore,
+        status: payload.status ?? "active",
+        created_at: payload.created_at,
+        updated_at: payload.updated_at,
+        supersedes: payload.supersedes,
+        superseded_by: payload.superseded_by,
+        correction_reason: payload.correction_reason,
+        confidence: payload.confidence,
+        episode_id: payload.episode_id,
+        related_ids: payload.related_ids,
+        valid_until: payload.valid_until,
+        last_verified_at: payload.last_verified_at,
+    };
+}
+function payloadToListResult(id, payload, collection) {
+    return {
+        id,
+        content: payload.content,
+        source: payload.source,
+        memory_type: payload.memory_type,
+        collection,
+        tags: payload.tags,
+        status: payload.status ?? "active",
+        created_at: payload.created_at,
+        updated_at: payload.updated_at,
+        supersedes: payload.supersedes,
+        superseded_by: payload.superseded_by,
+        correction_reason: payload.correction_reason,
+        confidence: payload.confidence,
+        episode_id: payload.episode_id,
+        related_ids: payload.related_ids,
+        valid_until: payload.valid_until,
+        last_verified_at: payload.last_verified_at,
+    };
+}
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .match(/[\p{L}\p{N}_./:#-]+/gu) ?? [];
+}
+function keywordScore(query, payload) {
+    const queryTerms = Array.from(new Set(tokenize(query)));
+    if (queryTerms.length === 0)
+        return 0;
+    const searchable = [
+        payload.content,
+        payload.source,
+        payload.memory_type,
+        ...(payload.tags ?? []),
+        payload.episode_id ?? "",
+    ]
+        .join(" ")
+        .toLowerCase();
+    const searchableTerms = tokenize(searchable);
+    const termCount = new Map();
+    for (const term of searchableTerms) {
+        termCount.set(term, (termCount.get(term) ?? 0) + 1);
+    }
+    let score = 0;
+    for (const term of queryTerms) {
+        const exactCount = termCount.get(term) ?? 0;
+        if (exactCount > 0) {
+            score += 1 + Math.log1p(exactCount);
+        }
+        else if (searchable.includes(term)) {
+            score += 0.35;
+        }
+    }
+    if (searchable.includes(query.toLowerCase())) {
+        score += 1;
+    }
+    return Math.min(1, score / (queryTerms.length * 1.6));
+}
+function recencyScore(payload) {
+    if (payload.memory_type === "rule" || payload.memory_type === "decision") {
+        return 1;
+    }
+    const timestamp = Date.parse(payload.last_verified_at ?? payload.updated_at ?? payload.created_at);
+    if (Number.isNaN(timestamp))
+        return 0.5;
+    const ageDays = Math.max(0, (Date.now() - timestamp) / 86_400_000);
+    const halfLifeDays = payload.memory_type === "preference" ? 180 : 90;
+    return Math.pow(0.5, ageDays / halfLifeDays);
+}
+function combineScore(vectorScore, keywordScoreValue, recencyScoreValue, mode, useRecency) {
+    const recencyWeight = useRecency ? 0.1 : 0;
+    if (mode === "keyword") {
+        return keywordScoreValue * (1 - recencyWeight) + recencyScoreValue * recencyWeight;
+    }
+    if (mode === "vector") {
+        return vectorScore * (1 - recencyWeight) + recencyScoreValue * recencyWeight;
+    }
+    return vectorScore * 0.65 + keywordScoreValue * 0.25 + recencyScoreValue * recencyWeight;
+}
+function textSimilarity(a, b) {
+    const left = new Set(tokenize(`${a.content} ${(a.tags ?? []).join(" ")}`));
+    const right = new Set(tokenize(`${b.content} ${(b.tags ?? []).join(" ")}`));
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const term of left) {
+        if (right.has(term))
+            intersection += 1;
+    }
+    return intersection / (left.size + right.size - intersection);
+}
+function mmrRank(results, limit) {
+    const remaining = [...results].sort((a, b) => b.score - a.score);
+    const selected = [];
+    while (selected.length < limit && remaining.length > 0) {
+        let bestIndex = 0;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (let index = 0; index < remaining.length; index += 1) {
+            const candidate = remaining[index];
+            const maxSimilarity = selected.length === 0
+                ? 0
+                : Math.max(...selected.map((item) => textSimilarity(candidate, item)));
+            const mmrScore = candidate.score * 0.8 - maxSimilarity * 0.2;
+            if (mmrScore > bestScore) {
+                bestScore = mmrScore;
+                bestIndex = index;
+            }
+        }
+        selected.push(remaining.splice(bestIndex, 1)[0]);
+    }
+    return selected;
+}
+async function scrollKeywordCandidates(collection, filter, limit) {
+    const result = await client.scroll(COLLECTIONS[collection], {
+        limit,
+        filter,
+        with_payload: true,
+        with_vector: false,
+    });
+    return result.points.map((p) => {
+        const payload = p.payload;
+        return payloadToListResult(String(p.id), payload, collection);
+    });
+}
+export async function searchMemory(options) {
+    const { vector, query, collections, limit = 5, sourceFilter, scoreThreshold, tagsFilter, memoryTypeFilter, includeInactive = false, mode = "hybrid", useRecency = true, useMmr = true, } = options;
+    const filter = buildFilter(sourceFilter, tagsFilter, memoryTypeFilter, includeInactive);
+    const perCollection = Math.ceil(limit / collections.length);
+    const candidates = new Map();
+    if (mode !== "keyword") {
+        if (!vector) {
+            throw new Error("vector is required for vector and hybrid search modes");
+        }
+        const vectorResults = (await Promise.all(collections.map(async (col) => {
+            const results = await client.search(COLLECTIONS[col], {
+                vector,
+                limit: mode === "hybrid" ? Math.max(perCollection * 3, 10) : perCollection,
+                filter,
+                score_threshold: mode === "vector" ? scoreThreshold : undefined,
+                with_payload: true,
+            });
+            return results.map((r) => {
+                const payload = r.payload;
+                const keywordScoreValue = keywordScore(query, payload);
+                const recencyScoreValue = recencyScore(payload);
+                const finalScore = combineScore(r.score, keywordScoreValue, recencyScoreValue, mode, useRecency);
+                return payloadToSearchResult(String(r.id), payload, col, finalScore, r.score, keywordScoreValue, recencyScoreValue);
+            });
+        }))).flat();
+        for (const result of vectorResults) {
+            candidates.set(`${result.collection}:${result.id}`, result);
+        }
+    }
+    if (mode !== "vector") {
+        const keywordCandidateLimit = parseInt(process.env.KEYWORD_CANDIDATE_LIMIT ?? "200", 10);
+        const keywordResults = (await Promise.all(collections.map(async (col) => {
+            const results = await scrollKeywordCandidates(col, filter, keywordCandidateLimit);
+            return results
+                .map((result) => {
+                const payload = {
+                    content: result.content,
+                    source: result.source,
+                    memory_type: result.memory_type,
+                    tags: result.tags,
+                    created_at: result.created_at,
+                    updated_at: result.updated_at,
+                    status: result.status,
+                    supersedes: result.supersedes,
+                    superseded_by: result.superseded_by,
+                    correction_reason: result.correction_reason,
+                    confidence: result.confidence,
+                    episode_id: result.episode_id,
+                    related_ids: result.related_ids,
+                    valid_until: result.valid_until,
+                    last_verified_at: result.last_verified_at,
+                };
+                const keywordScoreValue = keywordScore(query, payload);
+                const recencyScoreValue = recencyScore(payload);
+                const existing = candidates.get(`${result.collection}:${result.id}`);
+                const vectorScoreValue = existing?.vector_score ?? 0;
+                const finalScore = combineScore(vectorScoreValue, keywordScoreValue, recencyScoreValue, mode, useRecency);
+                return payloadToSearchResult(result.id, payload, result.collection, finalScore, vectorScoreValue, keywordScoreValue, recencyScoreValue);
+            })
+                .filter((result) => result.keyword_score !== undefined && result.keyword_score > 0);
+        }))).flat();
+        for (const result of keywordResults) {
+            const key = `${result.collection}:${result.id}`;
+            const existing = candidates.get(key);
+            if (!existing || result.score > existing.score) {
+                candidates.set(key, result);
+            }
+        }
+    }
+    const allResults = Array.from(candidates.values())
+        .filter((result) => scoreThreshold === undefined || result.score >= scoreThreshold)
+        .sort((a, b) => b.score - a.score);
+    return useMmr ? mmrRank(allResults, limit) : allResults.slice(0, limit);
+}
+export async function listMemories(collection, limit = 20, offset = 0, sourceFilter, memoryTypeFilter, includeInactive = false) {
+    const filter = buildFilter(sourceFilter, undefined, memoryTypeFilter, includeInactive);
+    const result = await client.scroll(COLLECTIONS[collection], {
+        limit,
+        offset,
+        filter,
+        with_payload: true,
+        with_vector: false,
+    });
+    return result.points.map((p) => {
+        const payload = p.payload;
+        return payloadToListResult(String(p.id), payload, collection);
+    });
+}
+function extractVector(vector) {
+    return Array.isArray(vector) && vector.every((value) => typeof value === "number")
+        ? vector
+        : undefined;
+}
+export async function getMemory(id, collection, withVector = false) {
+    const records = await client.retrieve(COLLECTIONS[collection], {
+        ids: [id],
+        with_payload: true,
+        with_vector: withVector,
+    });
+    const record = records[0];
+    if (!record?.payload)
+        return null;
+    const payload = record.payload;
+    return {
+        ...payloadToListResult(String(record.id), payload, collection),
+        vector: extractVector(record.vector),
+    };
+}
+export async function updateMemoryPayload(id, collection, payload) {
+    await client.setPayload(COLLECTIONS[collection], {
+        points: [id],
+        payload: {
+            ...payload,
+            updated_at: new Date().toISOString(),
+        },
+    });
+}

package/dist/server.js

@@ -0,0 +1,67 @@
+import express from "express";
+import { z } from "zod";
+import { storeMemory, storeMemorySchema } from "./tools/store.js";
+import { initCollections } from "./qdrant.js";
+const app = express();
+app.use(express.json());
+const INGEST_API_KEY = process.env.INGEST_API_KEY;
+const PORT = parseInt(process.env.PORT ?? "3000", 10);
+function authMiddleware(req, res, next) {
+    if (!INGEST_API_KEY) {
+        res.status(500).json({ error: "INGEST_API_KEY not configured" });
+        return;
+    }
+    const auth = req.headers.authorization;
+    if (!auth || auth !== `Bearer ${INGEST_API_KEY}`) {
+        res.status(401).json({ error: "Unauthorized" });
+        return;
+    }
+    next();
+}
+const ingestBodySchema = z.object({
+    memories: z
+        .array(storeMemorySchema)
+        .min(1),
+});
+app.post("/ingest", authMiddleware, async (req, res) => {
+    const parsed = ingestBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: parsed.error.flatten() });
+        return;
+    }
+    const { memories } = parsed.data;
+    const succeeded = [];
+    const failed = [];
+    await Promise.allSettled(memories.map(async (memory, index) => {
+        try {
+            const result = await storeMemory(memory);
+            succeeded.push({ index, id: result.id, collection: result.collection });
+        }
+        catch (err) {
+            failed.push({
+                index,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }));
+    const statusCode = failed.length === 0 ? 200 : succeeded.length === 0 ? 500 : 207;
+    res.status(statusCode).json({
+        stored: succeeded.length,
+        failed: failed.length,
+        succeeded,
+        ...(failed.length > 0 ? { errors: failed } : {}),
+    });
+});
+app.get("/health", (_req, res) => {
+    res.json({ status: "ok" });
+});
+async function startServer() {
+    await initCollections();
+    app.listen(PORT, () => {
+        console.log(`[knowledge-base] HTTP ingest server listening on port ${PORT}`);
+    });
+}
+startServer().catch((err) => {
+    console.error("[knowledge-base] Server startup error:", err);
+    process.exit(1);
+});

package/dist/tools/correct.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { getMemory, updateMemoryPayload } from "../qdrant.js";
+import { MEMORY_TYPES, storeMemory } from "./store.js";
+export const correctMemorySchema = z.object({
+    id: z.string().min(1).describe("要修订的旧记忆 ID"),
+    collection: z
+        .enum(["coding", "workspace"])
+        .describe("旧记忆所在 collection：coding 或 workspace"),
+    corrected_content: z.string().min(1).describe("修订后的新记忆内容"),
+    correction_reason: z.string().min(1).describe("为什么需要修订旧记忆"),
+    source: z.string().optional().describe("新记忆来源，默认沿用旧记忆 source"),
+    memory_type: z
+        .enum(MEMORY_TYPES)
+        .optional()
+        .describe("新记忆类型，默认沿用旧记忆 memory_type"),
+    tags: z.array(z.string()).optional().describe("新记忆 tags，默认沿用旧记忆 tags"),
+    confidence: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .default(0.9)
+        .describe("修订后记忆可信度，默认 0.9"),
+});
+export async function correctMemoryTool(input) {
+    const oldMemory = await getMemory(input.id, input.collection);
+    if (!oldMemory) {
+        throw new Error(`Memory not found: ${input.collection}/${input.id}`);
+    }
+    if (oldMemory.content.trim() === input.corrected_content.trim()) {
+        throw new Error("corrected_content must differ from the existing memory content");
+    }
+    const result = await storeMemory({
+        content: input.corrected_content,
+        source: input.source ?? oldMemory.source,
+        memory_type: input.memory_type ?? oldMemory.memory_type,
+        tags: input.tags ?? oldMemory.tags,
+        status: "active",
+        confidence: input.confidence,
+        supersedes: input.id,
+        related_ids: [input.id, ...(oldMemory.related_ids ?? [])],
+        correction_reason: input.correction_reason,
+        last_verified_at: new Date().toISOString(),
+    });
+    await updateMemoryPayload(input.id, input.collection, {
+        status: "superseded",
+        superseded_by: result.id,
+        correction_reason: input.correction_reason,
+    });
+    return {
+        corrected: true,
+        old_id: input.id,
+        old_collection: input.collection,
+        new_id: result.id,
+        new_collection: result.collection,
+    };
+}

package/dist/tools/delete.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { deleteMemory } from "../qdrant.js";
+export const deleteMemorySchema = z.object({
+    id: z.string().min(1).describe("要删除的记忆 ID（由 store_memory 返回）"),
+    collection: z
+        .enum(["coding", "workspace"])
+        .describe("所在 collection：coding=技术记忆, workspace=团队记忆"),
+});
+export async function deleteMemoryTool(input) {
+    await deleteMemory(input.id, input.collection);
+    return { deleted: true, id: input.id, collection: input.collection };
+}