@ppdocs/mcp 2.6.31 → 2.7.1

package/dist/storage/httpClient.d.ts

@@ -54,6 +54,20 @@ export declare class PpdocsApiClient {
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
     getRulesApi(ruleType: string): Promise<string[]>;
     saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
+    vectorSearch(query: string, limit: number, mode: string): Promise<Array<{
+        id: string;
+        title: string;
+        score: number;
+        match_type: string;
+        keyword_score: number;
+        semantic_score: number;
+    }>>;
+    vectorStats(): Promise<{
+        model_downloaded: boolean;
+        model_loaded: boolean;
+        model_path: string;
+        index_count: number;
+    }>;
 }
 export declare function initClient(apiUrl: string): void;
 export declare function listNodes(_projectId: string, filter?: ListNodesFilter): Promise<NodeData[]>;
@@ -96,3 +110,23 @@ export declare function addTaskLog(_projectId: string, taskId: string, logType:
 export declare function completeTask(_projectId: string, taskId: string, experience: TaskExperience): Promise<Task | null>;
 export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
 export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;
+/** 向量搜索结果 */
+export interface VectorSearchResult {
+    id: string;
+    title: string;
+    score: number;
+    match_type: string;
+    keyword_score: number;
+    semantic_score: number;
+}
+/** 向量索引状态 */
+export interface VectorStats {
+    model_downloaded: boolean;
+    model_loaded: boolean;
+    model_path: string;
+    index_count: number;
+}
+/** 混合搜索 (关键词 + 语义) */
+export declare function vectorSearch(_projectId: string, query: string, limit: number, mode: 'hybrid' | 'keyword' | 'semantic'): Promise<VectorSearchResult[]>;
+/** 获取向量索引状态 */
+export declare function vectorStats(_projectId: string): Promise<VectorStats>;

package/dist/storage/httpClient.js

@@ -360,6 +360,16 @@ export class PpdocsApiClient {
             return false;
         }
     }
+    // ============ 向量搜索 API ============
+    async vectorSearch(query, limit, mode) {
+        return this.request('/vector/search', {
+            method: 'POST',
+            body: JSON.stringify({ query, limit, mode })
+        });
+    }
+    async vectorStats() {
+        return this.request('/vector/stats');
+    }
 }
 // ============ 模块级 API (兼容现有 tools/index.ts) ============
 let client = null;
@@ -429,3 +439,11 @@ export async function getRules(_projectId, ruleType) {
 export async function saveRules(_projectId, ruleType, rules) {
     return getClient().saveRulesApi(ruleType, rules);
 }
+/** 混合搜索 (关键词 + 语义) */
+export async function vectorSearch(_projectId, query, limit, mode) {
+    return getClient().vectorSearch(query, limit, mode);
+}
+/** 获取向量索引状态 */
+export async function vectorStats(_projectId) {
+    return getClient().vectorStats();
+}

package/dist/tools/helpers.d.ts

@@ -24,33 +24,6 @@ export declare function fetchRelations(projectId: string, nodeId: string, maxDep
     outgoing: RelationItem[];
     incoming: RelationItem[];
 }>;
-interface SearchResultItem {
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    score: string;
-    matchType: 'hybrid' | 'semantic' | 'keyword';
-}
-/**
- * 融合关键词和语义搜索结果
- */
-export declare function mergeSearchResults(keywordResults: Array<{
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    score: number;
-}>, semanticResults: Array<{
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    similarity: number;
-}>, mode: 'hybrid' | 'keyword' | 'semantic', limit: number): SearchResultItem[];
 /**
  * 格式化节点为 Markdown 输出
  */

package/dist/tools/helpers.js

@@ -40,62 +40,6 @@ export async function fetchRelations(projectId, nodeId, maxDepth) {
     await recurse(nodeId, 1, 'both');
     return { outgoing, incoming };
 }
-/**
- * 融合关键词和语义搜索结果
- */
-export function mergeSearchResults(keywordResults, semanticResults, mode, limit) {
-    const scoreMap = new Map();
-    // 合并关键词结果
-    for (const r of keywordResults) {
-        scoreMap.set(r.id, {
-            id: r.id,
-            title: r.title,
-            tags: r.tags,
-            status: r.status,
-            summary: r.summary,
-            keywordScore: r.score,
-            semanticScore: 0
-        });
-    }
-    // 合并语义结果
-    for (const r of semanticResults) {
-        const existing = scoreMap.get(r.id);
-        if (existing) {
-            existing.semanticScore = r.similarity;
-        }
-        else {
-            scoreMap.set(r.id, {
-                id: r.id,
-                title: r.title,
-                tags: r.tags,
-                status: r.status,
-                summary: r.summary,
-                keywordScore: 0,
-                semanticScore: r.similarity
-            });
-        }
-    }
-    // 计算综合得分并排序
-    const combined = Array.from(scoreMap.values()).map(item => {
-        // 混合权重: 语义 0.6 + 关键词 0.4
-        const finalScore = mode === 'keyword' ? item.keywordScore
-            : mode === 'semantic' ? item.semanticScore
-                : item.semanticScore * 0.6 + item.keywordScore * 0.4;
-        return { ...item, finalScore };
-    });
-    combined.sort((a, b) => b.finalScore - a.finalScore);
-    const topResults = combined.slice(0, limit);
-    return topResults.map(r => ({
-        id: r.id,
-        title: r.title,
-        tags: r.tags,
-        status: r.status,
-        summary: r.summary,
-        score: `${Math.round(r.finalScore * 100)}%`,
-        matchType: (r.keywordScore > 0 && r.semanticScore > 0 ? 'hybrid'
-            : r.semanticScore > 0 ? 'semantic' : 'keyword')
-    }));
-}
 // ==================== 节点格式化 ====================
 /**
  * 格式化节点为 Markdown 输出

package/dist/tools/index.js

@@ -1,9 +1,8 @@
 import { z } from 'zod';
 import * as storage from '../storage/httpClient.js';
 import { decodeUnicodeEscapes, decodeObjectStrings, getRules, RULE_TYPE_LABELS } from '../utils.js';
-import * as vector from '../vector/index.js';
-// vectorManager 已弃用，向量索引由 Tauri 后端自动维护
-import { wrap, fetchRelations, mergeSearchResults, formatNodeMarkdown, formatRelationsMarkdown, buildDirectoryTree, formatTreeText, countTreeNodes } from './helpers.js';
+// 向量搜索已迁移至 Tauri 后端，通过 HTTP API 调用
+import { wrap, fetchRelations, formatNodeMarkdown, formatRelationsMarkdown, buildDirectoryTree, formatTreeText, countTreeNodes } from './helpers.js';
 export function registerTools(server, projectId, _user) {
     // 1. 创建节点
     server.tool('kg_create_node', '创建知识节点。type: logic=逻辑/函数, data=数据结构, intro=概念介绍。⚠️ tags至少提供3个分类标签', {
@@ -168,55 +167,40 @@ export function registerTools(server, projectId, _user) {
             }));
             return wrap(`${JSON.stringify(output, null, 2)}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情`);
         }
-        // 获取关键词结果
-        let keywordResults = [];
-        if (mode === 'hybrid' || mode === 'keyword') {
-            const kResults = await storage.searchNodes(projectId, args.keywords, limit * 2);
-            keywordResults = kResults.map(r => ({
+        // 调用 Tauri 后端混合搜索 API
+        try {
+            const results = await storage.vectorSearch(projectId, query, limit, mode);
+            // 补全节点信息 (tags, status, summary)
+            const output = [];
+            for (const r of results) {
+                const node = await storage.getNode(projectId, r.id);
+                output.push({
+                    id: r.id,
+                    title: r.title,
+                    tags: node?.categories || [],
+                    status: node?.status || 'incomplete',
+                    summary: node?.summary || '',
+                    score: `${Math.round(r.score)}%`,
+                    matchType: r.match_type
+                });
+            }
+            const json = JSON.stringify(output, null, 2);
+            return wrap(`${json}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情\n🔍 搜索模式: ${mode}`);
+        }
+        catch (e) {
+            // 后端搜索失败，降级为关键词搜索
+            console.warn('[kg_search] Vector search failed, fallback to keyword:', e);
+            const results = await storage.searchNodes(projectId, args.keywords, limit);
+            const output = results.map(r => ({
                 id: r.node.id,
                 title: r.node.title,
                 tags: r.node.categories || [],
                 status: r.node.status,
                 summary: r.node.summary || '',
-                score: r.score / 100
+                hitRate: `${Math.round(r.score)}%`
             }));
+            return wrap(`${JSON.stringify(output, null, 2)}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情\n⚠️ 语义搜索不可用，已降级为关键词搜索`);
         }
-        // 获取语义结果 (需补全节点信息)
-        let semanticResults = [];
-        if (mode === 'hybrid' || mode === 'semantic') {
-            try {
-                // 向量索引由 Tauri 后端自动维护，MCP 直接读取
-                const rawSemantic = await vector.semanticSearch(projectId, query, limit * 2);
-                // 补全节点信息 (关键词结果中已有的复用，没有的获取)
-                const keywordMap = new Map(keywordResults.map(r => [r.id, r]));
-                for (const r of rawSemantic) {
-                    const existing = keywordMap.get(r.id);
-                    if (existing) {
-                        semanticResults.push({ ...existing, similarity: r.similarity });
-                    }
-                    else {
-                        const node = await storage.getNode(projectId, r.id);
-                        if (node) {
-                            semanticResults.push({
-                                id: r.id,
-                                title: r.title,
-                                tags: node.categories || [],
-                                status: node.status,
-                                summary: node.summary || '',
-                                similarity: r.similarity
-                            });
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                console.warn('[kg_search] Semantic search failed:', e);
-            }
-        }
-        // 融合排序
-        const output = mergeSearchResults(keywordResults, semanticResults, mode, limit);
-        const json = JSON.stringify(output, null, 2);
-        return wrap(`${json}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情\n🔍 搜索模式: ${mode}`);
     });
     // 6. 路径查找
     server.tool('kg_find_path', '查找两节点间的依赖路径', {
@@ -406,10 +390,22 @@ export function registerTools(server, projectId, _user) {
     // 注意: 向量索引由 Tauri 后端自动维护，MCP 只提供只读查询
     // 16. 查看索引状态 (只读)
     server.tool('kg_index_stats', '查看向量索引状态', {}, async () => {
-        const stats = await vector.getIndexStats(projectId);
-        return wrap(JSON.stringify({
-            ...stats,
-            tip: '向量索引由软件端自动维护，节点增删改时自动更新'
-        }, null, 2));
+        try {
+            const stats = await storage.vectorStats(projectId);
+            return wrap(JSON.stringify({
+                model_downloaded: stats.model_downloaded,
+                model_loaded: stats.model_loaded,
+                model_path: stats.model_path,
+                index_count: stats.index_count,
+                tip: '向量索引由软件端自动维护，节点增删改时自动更新'
+            }, null, 2));
+        }
+        catch (e) {
+            return wrap(JSON.stringify({
+                error: '无法获取索引状态',
+                message: String(e),
+                tip: '请确保软件端已启动'
+            }, null, 2));
+        }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ppdocs/mcp",
-  "version": "2.6.31",
+  "version": "2.7.1",
   "description": "ppdocs MCP Server - Knowledge Graph for Claude",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,6 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@xenova/transformers": "^2.17.2",
     "proper-lockfile": "^4.1.2",
     "zod": "^4.1.13"
   },