@tencentcloud/sdk-mcp 1.7.2 → 1.7.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## Version 1.7.3 @2026.08.17
+
+### 新增
+- 新增 RoomKit 多端集成、录制、白板、网络代理、AI 降噪与字幕翻译等知识库资源，扩充 Room 产品域知识覆盖。
+- 新增错误码、日志级别、屏幕分享自动停止及微信小程序报错排查等最佳实践文档。
+- 新增通用加性 rerank 模块，实现锚点选择与短语提取，并集成到搜索重排逻辑，提升召回排序准确率。
+
+### 变更
+- 优化 BM25 索引为无原型对象，提升索引结构的隔离性与稳定性。
+
+### 修复
+- 修复 BM25 打分受原型键污染导致的异常，增加原型键守卫，避免打分污染与 NaN 问题。
+
 ## Version 1.7.2 @2026.08.13
 
 ### 变更

package/README.md

@@ -59,6 +59,19 @@ npx -y @tencentcloud/sdk-mcp
 
 > 仅展示最近更新，完整历史请查看 `CHANGELOG.md`。
 
+## Version 1.7.3 @2026.08.17
+
+### 新增
+- 新增 RoomKit 多端集成、录制、白板、网络代理、AI 降噪与字幕翻译等知识库资源，扩充 Room 产品域知识覆盖。
+- 新增错误码、日志级别、屏幕分享自动停止及微信小程序报错排查等最佳实践文档。
+- 新增通用加性 rerank 模块，实现锚点选择与短语提取，并集成到搜索重排逻辑，提升召回排序准确率。
+
+### 变更
+- 优化 BM25 索引为无原型对象，提升索引结构的隔离性与稳定性。
+
+### 修复
+- 修复 BM25 打分受原型键污染导致的异常，增加原型键守卫，避免打分污染与 NaN 问题。
+
 ## Version 1.7.1 @2026.08.11
 
 ### 新增
@@ -82,8 +95,3 @@ npx -y @tencentcloud/sdk-mcp
 
 #### 修复
 - 修复复杂问法下部分检索结果偏题的问题，降低高分误召回概率。
-
-### Version 1.6.6 @2026.07.18
-
-#### 新增
-- 支持 `get_native_live_uikit_integration` 工具，支持 LiveKit(Android/iOS) 含 UI 集成。

package/knowledge/bm25.js

@@ -61,28 +61,29 @@ export function tokenize(text) {
     return tokens;
 }
 export function buildBM25Index(documents) {
-    const postings = {};
-    const docLengths = {};
-    const docFreq = {};
+    // 用无原型对象，杜绝 term/id 为 'constructor'/'__proto__' 等原型键时的污染。
+    const postings = Object.create(null);
+    const docLengths = Object.create(null);
+    const docFreq = Object.create(null);
     let totalLength = 0;
     for (const doc of documents) {
         const tokens = tokenize(doc.text);
         docLengths[doc.id] = tokens.length;
         totalLength += tokens.length;
-        const termFreq = {};
+        const termFreq = Object.create(null);
         for (const token of tokens) {
             termFreq[token] = (termFreq[token] ?? 0) + 1;
         }
         for (const [term, freq] of Object.entries(termFreq)) {
             if (!postings[term])
-                postings[term] = {};
+                postings[term] = Object.create(null);
             postings[term][doc.id] = freq;
             docFreq[term] = (docFreq[term] ?? 0) + 1;
         }
     }
     const n = documents.length;
     const avgDocLength = n > 0 ? totalLength / n : 0;
-    const idf = {};
+    const idf = Object.create(null);
     for (const [term, df] of Object.entries(docFreq)) {
         idf[term] = Math.log(1 + (n - df + 0.5) / (df + 0.5));
     }
@@ -96,15 +97,23 @@ export function buildBM25Index(documents) {
 }
 export function scoreBM25(query, chunkId, index) {
     const tokens = tokenize(query);
-    const docLength = index.docLengths[chunkId] ?? 0;
-    if (docLength === 0)
+    // Object.prototype 污染防护：postings/idf/docLengths 来自 JSON.parse 的普通对象，
+    // term 可能是 'constructor'/'toString'/'__proto__' 等原型键，直接 [] 取值会命中
+    // 原型链上的函数（如 Object.prototype.constructor），污染打分为 NaN。用 hasOwn 守卫。
+    const docLength = Object.hasOwn(index.docLengths, chunkId) ? index.docLengths[chunkId] : 0;
+    if (!docLength || Number.isNaN(docLength))
         return 0;
     let score = 0;
     for (const term of tokens) {
-        const tf = index.postings[term]?.[chunkId] ?? 0;
-        if (tf === 0)
+        if (!Object.hasOwn(index.postings, term) || !Object.hasOwn(index.idf, term))
+            continue;
+        const posting = index.postings[term];
+        const tf = Object.hasOwn(posting, chunkId) ? posting[chunkId] : 0;
+        if (!tf || Number.isNaN(tf))
+            continue;
+        const idf = index.idf[term];
+        if (Number.isNaN(idf))
             continue;
-        const idf = index.idf[term] ?? 0;
         const numerator = tf * (K1 + 1);
         const denominator = tf + K1 * (1 - B + B * (docLength / (index.avgDocLength || 1)));
         score += idf * (numerator / denominator);

package/knowledge/search/generic-rerank.js

@@ -0,0 +1,123 @@
+/**
+ * 通用加性 rerank：数据驱动的高 IDF 锚点命中 + 连续短语命中。
+ *
+ * 设计约束（零衰减 + 通用）：
+ * - 纯加性：只往 boosts 加正数，无 penalty；无信号（无锚点且无短语命中）时返回空 map，
+ *   排序数学上完全等于现状 → 已有功能零衰减。
+ * - 量纲受控：单 chunk 上限 = W_ANCHOR + W_PHRASE，远低于 exact-lookup 的 +200~+300，
+ *   只在 BM25 平局区间起微调，不翻转既有精确命中。
+ * - 零硬编码：锚点门槛来自运行时 index.idf 分位、短语来自 query 结构，
+ *   不含任何具体词 / product / 文件名 → 对任意产品成立。
+ *
+ * 治两个诊断确认的真病根：
+ * - A（锚点命中）：对抗「CJK unigram 被拆多份 × 高 tf 堆分」——稀有锚点命中给加权，
+ *   把靠通用词堆分的长文档区分开。
+ * - B（连续短语）：用原始字符串连续匹配抓「组合稀有」（如 WebSocket is not a constructor），
+ *   同时天然排除 tokenize 产生的跨词垃圾 bigram（如「错怎」——它在原 query 里虽连续，
+ *   但作为连续串在无关文档正文中不命中，不会被误加分）。
+ */
+// ── 超参（唯一可调项，均可回归验证）──────────────────────────────
+/** 锚点门槛：取当前检索子库 IDF 分布的分位阈值，IDF ≥ 此值的 query term 视为锚点 */
+const IDF_PERCENTILE = 0.75;
+/** 锚点数上限，防止长 query 稀释权重 */
+const MAX_ANCHORS = 6;
+/** 锚点命中权重（与 BM25 top 分 20~50 同量级，低于 exact-lookup boost 量级） */
+const W_ANCHOR = 40;
+/** 连续短语命中权重 */
+const W_PHRASE = 30;
+/**
+ * 从 query term 中选出锚点：IDF ≥ 子库分位阈值的 term，按 IDF 降序取 top-K。
+ * 门槛完全由 index.idf 的运行时分布决定（数据驱动），不写死任何词。
+ */
+function selectAnchors(queryTerms, index) {
+    const allIdf = Object.values(index.idf);
+    if (allIdf.length === 0)
+        return [];
+    const sorted = [...allIdf].sort((a, b) => a - b);
+    const threshold = sorted[Math.floor(sorted.length * IDF_PERCENTILE)] ?? 0;
+    const seen = new Set();
+    const anchors = [];
+    for (const term of queryTerms) {
+        if (seen.has(term))
+            continue;
+        seen.add(term);
+        // Object.prototype 污染防护：term 可能是 'constructor' 等原型键。
+        if (!Object.hasOwn(index.idf, term))
+            continue;
+        const idf = index.idf[term];
+        if (typeof idf !== 'number' || Number.isNaN(idf) || idf < threshold)
+            continue;
+        anchors.push({ term, idf });
+    }
+    anchors.sort((a, b) => b.idf - a.idf);
+    return anchors.slice(0, MAX_ANCHORS);
+}
+/**
+ * 从原始 query 抽取连续短语（不经 tokenize，避免分词假象）：
+ * - 英文：相邻词对（连续两个 ≥2 长度的英文/数字 token）
+ * - 中文：连续 ≥2 字的中文片段（整段，不切分）
+ */
+function extractPhrases(prompt) {
+    const phrases = [];
+    const enWords = prompt.toLowerCase().match(/[a-z0-9_]{2,}/g) ?? [];
+    for (let i = 0; i < enWords.length - 1; i += 1) {
+        phrases.push(`${enWords[i]} ${enWords[i + 1]}`);
+    }
+    for (const seg of prompt.match(/[\u4e00-\u9fff]{2,}/g) ?? []) {
+        phrases.push(seg);
+    }
+    return [...new Set(phrases)].filter((p) => p.replace(/\s/g, '').length >= 2);
+}
+/**
+ * 计算通用加性 boost。返回 chunkId -> 正分。
+ * 无锚点且无短语时返回空 map（排序退化为原始，零衰减）。
+ */
+export function computeGenericAnchorBoosts(prompt, pool, index, tokenizeFn) {
+    const result = {};
+    const anchors = selectAnchors(tokenizeFn(prompt), index);
+    const phrases = extractPhrases(prompt);
+    // 门槛：既无锚点也无短语 → 直接返回空，排序完全等于原来。
+    if (anchors.length === 0 && phrases.length === 0)
+        return result;
+    const maxIdf = Math.max(1, ...anchors.map((a) => a.idf));
+    for (const chunk of pool) {
+        // ── 信号 A：命中锚点，按 IDF 归一化累加命中强度 ──
+        let anchorStrength = 0;
+        let anchorHits = 0;
+        for (const { term, idf } of anchors) {
+            // Object.prototype 污染防护：term 可能是 'constructor' 等原型键。
+            if (!Object.hasOwn(index.postings, term))
+                continue;
+            const posting = index.postings[term];
+            if ((Object.hasOwn(posting, chunk.id) ? posting[chunk.id] : 0) > 0) {
+                anchorStrength += idf / maxIdf;
+                anchorHits += 1;
+            }
+        }
+        // ── 信号 B：连续短语在 title / key_phrases / 正文原始串命中 ──
+        const haystack = [
+            chunk.title,
+            ...(chunk.key_phrases ?? []),
+            chunk.content,
+        ].filter(Boolean).join(' ').toLowerCase();
+        let phraseHits = 0;
+        for (const phrase of phrases) {
+            if (haystack.includes(phrase.toLowerCase())) {
+                phraseHits += 1;
+            }
+        }
+        // 该 chunk 无任何信号 → 不加分（保持原分）。
+        if (anchorHits === 0 && phraseHits === 0)
+            continue;
+        const boostA = anchors.length > 0
+            ? W_ANCHOR * (anchorStrength / anchors.length) // 归一化到 [0, W_ANCHOR]
+            : 0;
+        const boostB = phrases.length > 0
+            ? W_PHRASE * Math.min(1, phraseHits / phrases.length) // [0, W_PHRASE]
+            : 0;
+        const total = boostA + boostB;
+        if (total > 0)
+            result[chunk.id] = total;
+    }
+    return result;
+}

package/knowledge/search/search-pass.js

@@ -1,9 +1,10 @@
 import { attachPoolContent } from '../content-loader.js';
 import { buildReferences } from '../doc-url-resolver.js';
-import { rankSubsetWithIndex } from '../bm25.js';
+import { rankSubsetWithIndex, tokenize } from '../bm25.js';
 import { getProductsBM25Index } from '../bm25-cache.js';
 import { filterPool } from './filter-pool.js';
 import { runExactLookup } from './exact-lookup.js';
+import { computeGenericAnchorBoosts } from './generic-rerank.js';
 import { applyRankMultipliers, computeApiNameCoverage, computeMissingApiTokens, isUrlMappingSource, postProcess, } from './search-core.js';
 function isBestPracticeSource(source) {
     return /\/best-practice\//i.test(source);
@@ -379,6 +380,12 @@ export function runSearchPass(params) {
     const productIndex = getProductsBM25Index(allChunks, passNorm.product);
     const poolWithContent = attachPoolContent(pool);
     const chunksById = new Map(poolWithContent.map((chunk) => [chunk.id, chunk]));
+    // 通用加性 rerank：数据驱动的高 IDF 锚点命中 + 连续短语命中。
+    // 纯加性、只加不减、无信号时返回空 map → 排序退化为原始，已有功能零衰减。
+    const genericBoosts = computeGenericAnchorBoosts(effectivePassNorm.prompt, poolWithContent, productIndex, tokenize);
+    for (const [id, amount] of Object.entries(genericBoosts)) {
+        boosts[id] = (boosts[id] ?? 0) + amount;
+    }
     const ranked = rankSubsetWithIndex(effectivePassNorm.prompt, pool.map((chunk) => chunk.id), productIndex, boosts);
     const rankedWithMultipliers = applyRankMultipliers(ranked, chunksById, {
         product: passNorm.product,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencentcloud/sdk-mcp",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Tencent Cloud MCP Server for SDK",
   "type": "module",
   "main": "index.js",

package/resource/_schema/query-normalization.yaml

@@ -7,3 +7,9 @@ word:
   meeting: ["会议", "roomkit", "conference"]
   room: ["会议", "roomkit", "conference"]
   roomkit: ["会议", "roomkit", "conference"]
+  # 症状词 → 规范词：桌面版微信小程序运行 IM SDK 报 WebSocket is not a constructor / tencent_cloud_im_csig_flutter_for_web_25F_cy undefined。
+  # 用户常贴"AppService 逻辑层没有原生 WebSocket 构造函数"这类现象描述，与目标文档
+  # "桌面版微信 + 包名版本升级"词汇体系字面不重合，靠此映射补齐规范词，拉高召回重合度。
+  "WebSocket is not a constructor": ["桌面版微信", "小程序", "SDK 版本", "升级"]
+  AppService: ["桌面版微信", "小程序"]
+  "Cannot read properties of undefined (reading 'tencent_cloud_im_csig_flutter_for_web_25F_cy')": ["桌面版微信", "小程序", "SDK 版本"]