@cjsqbn/resume-screening-mcp 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Resume Screening MCP
+
+这是为“简历初筛执行器”准备的 MCP 服务。它把简历结构化、岗位匹配、可信度检测、综合评分、候选人排序和报告生成封装成工具，减少 agent 提示词中的复杂规则。
+
+## 工具列表
+
+| 工具名 | 作用 |
+|---|---|
+| `parse_jd` | 解析岗位 JD，提取年限、技能、行业和加分项 |
+| `analyze_candidate` | 分析单个候选人，输出结构化信息、可信度、匹配度和综合得分 |
+| `screen_resumes` | 批量分析多份简历，输出淘汰名单、晋级榜、疑点追问和报告 |
+| `generate_report` | 将结构化筛选结果转换为中文 Markdown 报告 |
+
+## 在平台中的服务信息
+
+服务名称：
+
+```text
+简历初筛MCP
+```
+
+描述：
+
+```text
+为简历初筛执行器提供岗位JD解析、简历结构化、岗位匹配度计算、可信度检测、综合评分、候选人排序和中文报告生成能力。Agent负责对话和流程调度，MCP负责稳定的规则计算和结构化输出。
+```
+
+## MCP 服务配置
+
+如果你已经把这个包发布到 npm，使用：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+如果你先在本机测试，使用本地 Node 路径运行：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "node",
+      "args": [
+        "C:\\Users\\Lenovo\\Documents\\Codex\\2026-09-18\\ge-m\\outputs\\resume-screening-mcp\\src\\index.js"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+如果你的平台只支持 `npx`，但还没有发布 npm 包，可以先把本项目上传到 GitHub，然后使用类似配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "github:你的用户名/resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+## 关键输入示例
+
+调用 `screen_resumes`：
+
+```json
+{
+  "resumes": [
+    {
+      "file_name": "张三.pdf",
+      "text": "姓名：张三\n本科 清华大学\n5年 Java Spring Boot MySQL Redis 互联网经验，负责订单系统，提升效率30%。"
+    }
+  ],
+  "job_description": "招聘 Java 后端工程师，要求3年以上经验，熟悉 Java、Spring Boot、MySQL，有互联网经验优先。",
+  "config": {
+    "trust_threshold": 60,
+    "match_weight": 0.6,
+    "competitiveness_weight": 0.4
+  }
+}
+```
+
+## 本地测试
+
+```bash
+npm run test:smoke
+```
+
+## 接入建议
+
+原 agent 提示词不需要再写完整评分公式和七步流程，只需要规定：
+
+1. 何时复用已解析简历文本；
+2. 何时索要 JD；
+3. 何时调用 `screen_resumes`；
+4. 不允许绕过 MCP 自行打分；
+5. 按 MCP 返回结果整理中文报告。
+
+新版提示词见 `agent-prompt.md`。

package/agent-prompt.md

@@ -0,0 +1,165 @@
+# 简历初筛执行器新版完整提示词
+
+## 角色定位
+
+你是 RTS 简历初筛助手（Resume Trust Scanner），专门帮助 HR 快速处理批量简历，完成简历可信度评估、岗位匹配分析、综合评分和候选人排序。
+
+你只做招聘辅助分析，不做最终录用决定。所有判断都必须保守、可解释、可复核。
+
+## 核心原则
+
+1. 只基于用户提供的简历真实文本、文件解析结果和岗位 JD 进行分析。
+2. 禁止编造、猜测或虚构任何候选人信息，包括姓名、学校、公司、年限、项目、数字成果和技能。
+3. 每个风险判断都应尽量保留依据，使用“疑似”“可能存在”“建议核实”等表达，不得武断定性。
+4. 本系统只做初筛辅助，最终结论应以面试核实、作品验证和背景调查为准。
+5. 默认使用中文输出；用户明确要求英文时再使用英文。
+
+## 会话状态复用规则
+
+1. 收到用户消息后，先检查本次会话中是否已经成功获得过简历文本。
+2. 如果本次会话已经解析过简历文本，后续用户只补充 JD、修改 JD 或要求重新分析时，必须复用已有简历文本，不要重复解析文件。
+3. 只有用户明确上传新 PDF、Word 或其他简历文件时，才触发新的文件解析流程。
+4. 新文件解析成功后，应与会话中已有简历文本合并处理，支持多份简历批量筛选。
+5. 如果用户本轮只发送 JD 或文字分析指令，不要调用文件解析工具。
+6. 如果无法读取附件内容，必须提示：“无法读取附件内容，请重新上传文件或直接粘贴简历文本。”不得在没有真实文本的情况下继续分析。
+
+## 输入处理规则
+
+用户可能提供以下输入：
+
+1. 多份简历文件；
+2. 一份简历文件；
+3. 多份粘贴的简历文本；
+4. 岗位 JD；
+5. 简历文本和 JD 同时提供；
+6. 已有简历文本后，后续补充 JD。
+
+处理要求：
+
+1. 如果已有简历文本但没有 JD，应主动要求用户补充岗位 JD。
+2. 如果已有 JD 但没有简历文本，应要求用户上传简历文件或粘贴简历文本。
+3. 如果简历文本和 JD 都已具备，应调用 MCP 工具进行分析。
+4. 如果用户只要求单份简历可信度分析，可以调用单候选人分析工具。
+
+## MCP 工具调用规则
+
+你可以使用简历初筛 MCP。核心工具包括：
+
+1. `parse_jd`：解析岗位 JD。
+2. `analyze_candidate`：分析单个候选人。
+3. `screen_resumes`：批量分析多份简历并排序。
+4. `generate_report`：根据结构化结果生成中文报告。
+
+当用户同时提供简历文本和岗位 JD 后，必须优先调用 `screen_resumes`。
+
+不要绕过 MCP 自行计算以下内容：
+
+1. 岗位匹配度；
+2. 简历可信度；
+3. 综合得分；
+4. 淘汰名单；
+5. 晋级排序；
+6. 推荐标签；
+7. 面试追问清单。
+
+MCP 返回结果后，你只能对结果进行中文整理和展示，不得擅自改动 MCP 返回的分数、排序、标签和疑点结论。
+
+## screen_resumes 调用格式
+
+调用 `screen_resumes` 时，使用以下 JSON 结构：
+
+```json
+{
+  "resumes": [
+    {
+      "file_name": "候选人简历.pdf",
+      "text": "真实简历文本"
+    }
+  ],
+  "job_description": "岗位 JD 文本",
+  "config": {
+    "trust_threshold": 60,
+    "match_weight": 0.6,
+    "competitiveness_weight": 0.4
+  }
+}
+```
+
+字段说明：
+
+1. `resumes`：候选人简历数组，每一项必须包含真实简历文本。
+2. `file_name`：文件名或候选人标识，没有文件名时可以使用“候选人1”“候选人2”。
+3. `text`：简历真实文本，不能为空。
+4. `job_description`：岗位 JD 文本，不能为空。
+5. `trust_threshold`：可信度淘汰线，默认 60。
+6. `match_weight`：匹配度在综合分中的权重，默认 0.6。
+7. `competitiveness_weight`：竞争力在综合分中的权重，默认 0.4。
+
+## 单份简历分析规则
+
+当用户只要求分析一份简历，且没有明确要求排序时，可以调用 `analyze_candidate`。
+
+如果没有 JD，则只输出结构化信息、可信度、疑点和追问，不输出岗位匹配度和综合排序。
+
+如果有 JD，则输出该候选人的完整分析结果。
+
+## 输出结构
+
+完整批量筛选报告按以下结构输出：
+
+```markdown
+## 淘汰名单（可信度低于阈值，不参与排序）
+
+| 候选人 | 可信度 | 淘汰理由 |
+|---|---:|---|
+
+## 晋级排序榜（按综合得分从高到低）
+
+| 排名 | 候选人 | 综合得分 | 匹配度 | 可信度 | 建议标签 |
+|---:|---|---:|---:|---:|---|
+
+## 疑点与追问清单
+
+- 原文依据或风险说明 -> 疑点类型 -> 判定依据 -> 面试追问
+
+## 竞争加分明细
+
+- 加分项 -> 分值 -> 依据
+
+## 评估说明
+
+- 本分析基于简历文本特征与规则引擎生成，仅供招聘初筛参考，不构成最终录用决定。
+- 关键数据请以面试核实、作品验证和背景调查为准。
+```
+
+如果 MCP 已返回 `markdown_report`，可以优先使用该报告，再根据用户需求做轻微排版整理。
+
+## 建议标签解释
+
+输出建议标签时，保持 MCP 返回结果，不自行重新计算。标签含义如下：
+
+1. `优先联系`：候选人匹配度和可信度较高，可优先推进。
+2. `可推进面试`：候选人整体符合要求，可进入面试。
+3. `建议核实`：候选人具备一定匹配度，但存在需要追问或验证的信息。
+4. `暂不联系`：综合表现一般，可放入待定池。
+5. `淘汰`：可信度低于阈值或不适合进入排序。
+
+## 防幻觉要求
+
+以下情况必须停止分析并要求用户补充信息：
+
+1. 没有真实简历文本；
+2. 没有岗位 JD，但用户要求岗位匹配或排序；
+3. 文件解析失败；
+4. 简历文本明显为空或乱码；
+5. 用户要求你判断未提供的信息。
+
+你不能为了完成报告而补写不存在的经历、公司、学校、技能或成果。
+
+## 固定结尾说明
+
+每次完整报告结尾都要包含：
+
+```text
+本分析基于简历文本特征与规则引擎生成，仅供招聘初筛参考，不构成最终录用决定。关键数据请以面试核实、作品验证和背景调查为准。
+```

package/index.js

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+
+const SERVER_NAME = "resume-screening-mcp";
+const SERVER_VERSION = "0.1.0";
+
+const DEFAULT_CONFIG = {
+  trust_threshold: 60,
+  high_trust_threshold: 80,
+  final_score_priority_threshold: 70,
+  final_score_interview_threshold: 50,
+  match_weight: 0.6,
+  competitiveness_weight: 0.4,
+};
+
+const SKILLS = [
+  "JavaScript", "TypeScript", "Python", "Java", "C++", "C#", "Go", "Rust", "PHP",
+  "SQL", "MySQL", "PostgreSQL", "Redis", "MongoDB", "Oracle",
+  "React", "Vue", "Angular", "Node.js", "Express", "Spring", "Spring Boot",
+  "Django", "Flask", "FastAPI", "Linux", "Docker", "Kubernetes", "Git",
+  "AWS", "Azure", "GCP", "Spark", "Hadoop", "Flink", "TensorFlow", "PyTorch",
+  "NLP", "LLM", "RAG", "Agent", "MCP", "Excel", "Tableau", "Power BI",
+  "数据分析", "数据挖掘", "机器学习", "深度学习", "自然语言处理", "大模型",
+  "产品设计", "用户研究", "原型设计", "项目管理", "需求分析", "测试", "自动化测试",
+  "销售", "运营", "内容运营", "新媒体", "电商", "财务", "人力资源", "招聘"
+];
+
+const INDUSTRIES = [
+  "互联网", "软件", "人工智能", "大数据", "金融", "银行", "证券", "保险",
+  "电商", "教育", "医疗", "制造", "汽车", "游戏", "物流", "零售", "房地产",
+  "咨询", "人力资源", "招聘", "SaaS", "ToB", "ToC"
+];
+
+const TOP_SCHOOLS = [
+  "清华大学", "北京大学", "复旦大学", "上海交通大学", "浙江大学", "南京大学",
+  "中国科学技术大学", "哈尔滨工业大学", "西安交通大学", "中国人民大学",
+  "同济大学", "北京航空航天大学", "北京理工大学", "武汉大学", "华中科技大学",
+  "中山大学", "四川大学", "南开大学", "天津大学", "东南大学", "985", "211", "双一流"
+];
+
+const BIG_COMPANIES = [
+  "阿里", "腾讯", "百度", "字节", "美团", "京东", "华为", "小米", "网易",
+  "滴滴", "快手", "拼多多", "蚂蚁", "微软", "Google", "Amazon", "Meta",
+  "Apple", "IBM", "Oracle", "SAP"
+];
+
+const POSITIVE_ACTIONS = [
+  "主导", "负责", "搭建", "设计", "优化", "落地", "推动", "交付", "管理",
+  "提升", "降低", "增长", "完成", "上线", "实现", "建设"
+];
+
+const VAGUE_WORDS = [
+  "丰富经验", "熟悉相关", "若干", "多个", "大量", "较强", "良好", "优秀",
+  "等", "参与相关", "一定经验", "较为熟练"
+];
+
+const EXAGGERATION_WORDS = [
+  "精通", "专家", "顶级", "全栈全能", "全面负责", "核心负责人", "从0到1",
+  "千万级", "亿级", "行业领先", "最佳", "第一"
+];
+
+function normalizeText(value) {
+  return String(value || "").replace(/\r\n/g, "\n").trim();
+}
+
+function unique(values) {
+  return Array.from(new Set(values.filter(Boolean)));
+}
+
+function clamp(value, min = 0, max = 100) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+
+function containsAny(text, terms) {
+  return terms.filter((term) => text.toLowerCase().includes(term.toLowerCase()));
+}
+
+function evidenceAround(text, keyword, size = 36) {
+  const index = text.toLowerCase().indexOf(String(keyword).toLowerCase());
+  if (index < 0) return "";
+  const start = Math.max(0, index - size);
+  const end = Math.min(text.length, index + String(keyword).length + size);
+  return text.slice(start, end).replace(/\s+/g, " ").trim();
+}
+
+function extractYears(text) {
+  const years = [];
+  const patterns = [
+    /(\d+(?:\.\d+)?)\s*年(?:以上|左右|经验|工作经验|开发经验|从业经验)?/g,
+    /(\d+(?:\.\d+)?)\s*\+\s*年/g,
+    /(\d+(?:\.\d+)?)\s*(?:years?|yrs?)/gi,
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const value = Number(match[1]);
+      if (value > 0 && value <= 50) years.push(value);
+    }
+  }
+  return years.length ? Math.max(...years) : 0;
+}
+
+function extractName(text, fileName = "") {
+  const namePatterns = [
+    /(?:姓名|候选人)[:：\s]*([\u4e00-\u9fa5]{2,5}|[A-Za-z][A-Za-z\s]{1,40})/,
+    /^([\u4e00-\u9fa5]{2,5})\s*$/m,
+  ];
+  for (const pattern of namePatterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) return match[1].trim();
+  }
+  const fromFile = String(fileName || "").replace(/\.(pdf|docx?|txt|md)$/i, "").trim();
+  return fromFile || "未知候选人";
+}
+
+function extractEducation(text) {
+  const degreeOrder = ["博士", "硕士", "研究生", "本科", "大专", "专科", "高中"];
+  const degree = degreeOrder.find((item) => text.includes(item)) || "";
+  const schoolMatch = text.match(/([\u4e00-\u9fa5A-Za-z]{2,30}(?:大学|学院|学校|University|College))/);
+  return {
+    education: degree || "未识别",
+    school: schoolMatch ? schoolMatch[1] : "",
+    is_top_school: containsAny(text, TOP_SCHOOLS).length > 0,
+  };
+}
+
+function extractNumbers(text) {
+  const matches = text.match(/(?:提升|增长|降低|减少|节省|转化率|留存率|GMV|营收|成本|效率|用户|订单|访问量|QPS|DAU|MAU|ROI)?[^。；;\n]{0,18}\d+(?:\.\d+)?\s*(?:%|万|亿|k|K|人|次|元|天|小时|个月|年)?/g);
+  return unique(matches || []).slice(0, 20);
+}
+
+function extractCurrentPosition(text) {
+  const patterns = [
+    /(?:当前岗位|应聘岗位|职位|岗位)[:：\s]*([^\n，。；;]{2,30})/,
+    /(工程师|开发|产品经理|项目经理|运营|销售|设计师|数据分析师|算法工程师|测试工程师|HR|招聘专员)/,
+  ];
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) return match[1].trim();
+  }
+  return "";
+}
+
+function parseJd({ job_description }) {
+  const text = normalizeText(job_description);
+  if (!text) throw new Error("job_description 不能为空");
+  const requiredSkills = unique(containsAny(text, SKILLS));
+  const requiredIndustry = unique(containsAny(text, INDUSTRIES));
+  const years = extractYears(text);
+  const preferredItems = [];
+  if (/985|211|双一流|名校/.test(text)) preferredItems.push("名校背景");
+  if (/大厂|头部公司|知名互联网|大型企业/.test(text)) preferredItems.push("大厂或大型企业经历");
+  if (/从0到1|高并发|海量|千万级|亿级|复杂系统/.test(text)) preferredItems.push("稀缺或复杂项目经历");
+  if (/管理|带团队|负责人|Leader|主管/.test(text)) preferredItems.push("团队管理或负责人经历");
+
+  const responsibilities = unique(
+    text
+      .split(/[。；;\n]/)
+      .map((line) => line.trim())
+      .filter((line) => line.length >= 8 && /(负责|参与|完成|推动|建设|设计|开发|运营|管理)/.test(line))
+  ).slice(0, 8);
+
+  return {
+    required_years: years,
+    required_skills: requiredSkills,
+    required_industry: requiredIndustry,
+    preferred_items: preferredItems,
+    responsibilities,
+  };
+}
+
+function parseResume({ resume }) {
+  const fileName = resume?.file_name || resume?.name || "";
+  const text = normalizeText(resume?.text);
+  if (!text) throw new Error("resume.text 不能为空");
+
+  const education = extractEducation(text);
+  const skills = unique(containsAny(text, SKILLS));
+  const industries = unique(containsAny(text, INDUSTRIES));
+  const verbs = unique(containsAny(text, POSITIVE_ACTIONS));
+  const numberClaims = extractNumbers(text);
+  const bigCompanies = unique(containsAny(text, BIG_COMPANIES));
+
+  return {
+    file_name: fileName,
+    name: extractName(text, fileName),
+    total_years: extractYears(text),
+    current_position: extractCurrentPosition(text),
+    education: education.education,
+    school: education.school,
+    is_top_school: education.is_top_school,
+    skills,
+    industries,
+    big_companies: bigCompanies,
+    work_experiences: extractWorkExperiences(text),
+    key_achievements: numberClaims.slice(0, 8),
+    all_verbs: verbs,
+    number_claims: numberClaims,
+  };
+}
+
+function extractWorkExperiences(text) {
+  const lines = text
+    .split(/\n+/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const expLines = lines.filter((line) =>
+    /公司|工作经历|项目经历|实习|负责|主导|参与|任职|20\d{2}|19\d{2}/.test(line)
+  );
+  return expLines.slice(0, 12).map((line) => ({
+    raw: line.slice(0, 220),
+    duration_months: inferDurationMonths(line),
+    verbs: containsAny(line, POSITIVE_ACTIONS),
+    numbers: extractNumbers(line),
+  }));
+}
+
+function inferDurationMonths(line) {
+  const range = line.match(/(20\d{2}|19\d{2})[./年-]?\s*(\d{1,2})?.{0,6}(20\d{2}|19\d{2})?[./年-]?\s*(\d{1,2})?/);
+  if (!range) return 0;
+  const startYear = Number(range[1]);
+  const startMonth = Number(range[2] || 1);
+  const endYear = Number(range[3] || new Date().getFullYear());
+  const endMonth = Number(range[4] || 12);
+  const months = (endYear - startYear) * 12 + (endMonth - startMonth);
+  return months > 0 && months < 600 ? months : 0;
+}
+
+function matchResumeToJd(candidateInfo, jdInfo) {
+  const requiredYears = Number(jdInfo.required_years || 0);
+  let yearsScore = 100;
+  if (requiredYears > 0) {
+    yearsScore = clamp((Number(candidateInfo.total_years || 0) / requiredYears) * 100);
+  }
+
+  const requiredSkills = jdInfo.required_skills || [];
+  const matchedSkills = requiredSkills.filter((skill) =>
+    (candidateInfo.skills || []).some((candidateSkill) => candidateSkill.toLowerCase() === skill.toLowerCase())
+  );
+  const skillsScore = requiredSkills.length ? (matchedSkills.length / requiredSkills.length) * 100 : 70;
+
+  const requiredIndustry = jdInfo.required_industry || [];
+  const matchedIndustry = requiredIndustry.filter((industry) => (candidateInfo.industries || []).includes(industry));
+  const industryScore = requiredIndustry.length ? (matchedIndustry.length / requiredIndustry.length) * 100 : 70;
+
+  const matchScore = round1(yearsScore * 0.4 + skillsScore * 0.4 + industryScore * 0.2);
+  return {
+    match_score: matchScore,
+    detail: {
+      years_score: round1(yearsScore),
+      skills_score: round1(skillsScore),
+      industry_score: round1(industryScore),
+      required_years: requiredYears,
+      candidate_years: candidateInfo.total_years,
+      matched_skills: matchedSkills,
+      missing_skills: requiredSkills.filter((skill) => !matchedSkills.includes(skill)),
+      matched_industry: matchedIndustry,
+    },
+    conclusion:
+      matchScore >= 80 ? "岗位匹配度较高" :
+      matchScore >= 60 ? "岗位匹配度中等，建议结合面试核实" :
+      "岗位匹配度偏低",
+  };
+}
+
+function checkResumeTrust(candidateInfo, text) {
+  const flags = [];
+  let deduction = 0;
+
+  const exaggerations = unique(containsAny(text, EXAGGERATION_WORDS));
+  const exaggerationEvidence = exaggerations
+    .map((word) => evidenceAround(text, word))
+    .filter(Boolean)
+    .slice(0, 3);
+  if (exaggerations.length) {
+    const points = Math.min(24, exaggerations.length * 8);
+    deduction += points;
+    flags.push({
+      type: "疑似夸大表达",
+      deduction: points,
+      evidence: exaggerationEvidence,
+      reason: "出现强结论或高量级描述，建议结合项目细节核实。",
+      questions: ["请说明该成果的个人职责边界、数据来源和验证方式。"],
+    });
+  }
+
+  const vagueWords = unique(containsAny(text, VAGUE_WORDS));
+  if (vagueWords.length >= 2) {
+    deduction += 10;
+    flags.push({
+      type: "信息表述偏模糊",
+      deduction: 10,
+      evidence: vagueWords.slice(0, 4).map((word) => evidenceAround(text, word)).filter(Boolean),
+      reason: "存在较多泛化表述，缺少可验证的任务、范围或结果。",
+      questions: ["请举一个最能代表能力的具体项目，并说明目标、行动和结果。"],
+    });
+  }
+
+  if ((candidateInfo.skills || []).length >= 14 && (candidateInfo.number_claims || []).length <= 2) {
+    deduction += 10;
+    flags.push({
+      type: "技能堆砌信号",
+      deduction: 10,
+      evidence: [`识别到技能数量 ${candidateInfo.skills.length} 个，但量化成果较少。`],
+      reason: "技能列表较长但缺少成果支撑，建议核实真实熟练度。",
+      questions: ["请按熟练程度对简历中的技能排序，并说明最近一次实际使用场景。"],
+    });
+  }
+
+  if ((candidateInfo.total_years || 0) <= 2 && /高级|资深|专家|负责人|架构师/.test(text)) {
+    deduction += 12;
+    flags.push({
+      type: "年限与职级疑似不匹配",
+      deduction: 12,
+      evidence: [`识别工作年限约 ${candidateInfo.total_years || 0} 年，同时出现较高职级描述。`],
+      reason: "较短年限与高职级描述之间存在需核实之处。",
+      questions: ["请说明获得该职级或负责人角色的时间、团队规模和评估标准。"],
+    });
+  }
+
+  const trustScore = clamp(100 - deduction);
+  const trustLevel = trustScore >= 80 ? "高可信" : trustScore >= 60 ? "中可信" : "低可信";
+  return {
+    trust_score: trustScore,
+    trust_level: trustLevel,
+    trust_status: trustScore >= 60 ? "可进入排序" : "建议淘汰",
+    flags,
+    deduction_detail: flags.map((flag) => ({ type: flag.type, deduction: flag.deduction, reason: flag.reason })),
+    questions: flags.flatMap((flag) => flag.questions),
+  };
+}
+
+function scoreCompetitiveness(candidateInfo) {
+  const details = [];
+  let score = 50;
+
+  if ((candidateInfo.key_achievements || []).length >= 2) {
+    score += 10;
+    details.push({ item: "高含金量成就", points: 10, evidence: candidateInfo.key_achievements.slice(0, 3) });
+  }
+  if (/(高并发|大模型|推荐系统|风控|支付|搜索|分布式|复杂系统)/.test(JSON.stringify(candidateInfo))) {
+    score += 8;
+    details.push({ item: "稀缺经历", points: 8, evidence: ["识别到复杂系统或稀缺技术关键词"] });
+  }
+  if (candidateInfo.is_top_school) {
+    score += 5;
+    details.push({ item: "名校背景", points: 5, evidence: [candidateInfo.school || "简历包含名校相关描述"] });
+  }
+  if ((candidateInfo.big_companies || []).length) {
+    score += 5;
+    details.push({ item: "大厂背景", points: 5, evidence: candidateInfo.big_companies.slice(0, 3) });
+  }
+  if (/初级|中级|高级|资深|负责人|主管|经理|总监/.test(JSON.stringify(candidateInfo))) {
+    score += 5;
+    details.push({ item: "职级递进", points: 5, evidence: ["简历包含职级或职责递进描述"] });
+  }
+
+  return { competitiveness_score: clamp(score), bonus_details: details };
+}
+
+function recommendationLabel(trustScore, finalScore) {
+  if (trustScore < 60) return "淘汰";
+  if (trustScore >= 80 && finalScore >= 70) return "优先联系";
+  if (trustScore >= 80 && finalScore >= 50) return "可推进面试";
+  if (trustScore >= 60 && finalScore >= 70) return "建议核实（能力优秀，重点追问疑点）";
+  if (trustScore >= 60 && finalScore >= 50) return "建议核实";
+  return "暂不联系";
+}
+
+function analyzeCandidate({ resume, job_description = "", jd_info = null, config = {} }) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...(config || {}) };
+  const text = normalizeText(resume?.text);
+  if (!text) throw new Error("resume.text 不能为空");
+  const candidateInfo = parseResume({ resume });
+  const jdInfo = jd_info || (job_description ? parseJd({ job_description }) : null);
+  const matchResult = jdInfo ? matchResumeToJd(candidateInfo, jdInfo) : null;
+  const checkResult = checkResumeTrust(candidateInfo, text);
+  const competitiveness = scoreCompetitiveness(candidateInfo);
+
+  let finalScore = null;
+  let label = checkResult.trust_score < mergedConfig.trust_threshold ? "淘汰" : "待补充 JD 后评分";
+  if (matchResult && checkResult.trust_score >= mergedConfig.trust_threshold) {
+    finalScore = round1(
+      matchResult.match_score * mergedConfig.match_weight +
+      competitiveness.competitiveness_score * mergedConfig.competitiveness_weight
+    );
+    label = recommendationLabel(checkResult.trust_score, finalScore);
+  }
+
+  return {
+    candidate_info: candidateInfo,
+    match_result: matchResult,
+    check_result: checkResult,
+    competitiveness,
+    final_score: finalScore,
+    recommendation_label: label,
+  };
+}
+
+function screenResumes({ resumes, job_description, config = {} }) {
+  if (!Array.isArray(resumes) || resumes.length === 0) throw new Error("resumes 必须是非空数组");
+  if (!normalizeText(job_description)) throw new Error("job_description 不能为空");
+
+  const mergedConfig = { ...DEFAULT_CONFIG, ...(config || {}) };
+  const jdInfo = parseJd({ job_description });
+  const analyzed = resumes.map((resume) => analyzeCandidate({
+    resume,
+    jd_info: jdInfo,
+    config: mergedConfig,
+  }));
+
+  const eliminated = analyzed
+    .filter((item) => item.check_result.trust_score < mergedConfig.trust_threshold)
+    .map((item) => ({
+      candidate: item.candidate_info.name,
+      file_name: item.candidate_info.file_name,
+      trust_score: item.check_result.trust_score,
+      reason: item.check_result.flags.map((flag) => flag.type).join("；") || "可信度低于阈值",
+      evidence: item.check_result.flags.flatMap((flag) => flag.evidence).slice(0, 5),
+    }));
+
+  const rankedCandidates = analyzed
+    .filter((item) => item.check_result.trust_score >= mergedConfig.trust_threshold)
+    .sort((a, b) => {
+      if ((b.final_score || 0) !== (a.final_score || 0)) return (b.final_score || 0) - (a.final_score || 0);
+      return b.check_result.trust_score - a.check_result.trust_score;
+    })
+    .map((item, index) => ({
+      rank: index + 1,
+      candidate: item.candidate_info.name,
+      file_name: item.candidate_info.file_name,
+      total_years: item.candidate_info.total_years,
+      final_score: item.final_score,
+      match_score: item.match_result?.match_score,
+      trust_score: item.check_result.trust_score,
+      trust_level: item.check_result.trust_level,
+      recommendation_label: item.recommendation_label,
+      matched_skills: item.match_result?.detail?.matched_skills || [],
+      missing_skills: item.match_result?.detail?.missing_skills || [],
+    }));
+
+  const result = {
+    version: SERVER_VERSION,
+    config: mergedConfig,
+    jd_info: jdInfo,
+    eliminated,
+    ranked_candidates: rankedCandidates,
+    risk_questions: analyzed.map((item) => ({
+      candidate: item.candidate_info.name,
+      questions: item.check_result.questions,
+      flags: item.check_result.flags,
+    })).filter((item) => item.questions.length || item.flags.length),
+    bonus_details: analyzed.map((item) => ({
+      candidate: item.candidate_info.name,
+      details: item.competitiveness.bonus_details,
+    })).filter((item) => item.details.length),
+    raw_analysis: analyzed,
+  };
+  result.summary = `共分析 ${analyzed.length} 份简历，晋级 ${rankedCandidates.length} 人，淘汰 ${eliminated.length} 人。`;
+  result.markdown_report = generateReport({ screening_result: result }).markdown;
+  return result;
+}
+
+function generateReport({ screening_result }) {
+  const result = screening_result || {};
+  const eliminated = result.eliminated || [];
+  const ranked = result.ranked_candidates || [];
+  const riskQuestions = result.risk_questions || [];
+  const bonusDetails = result.bonus_details || [];
+
+  const lines = [];
+  lines.push("## 淘汰名单（可信度低于阈值，不参与排序）");
+  if (!eliminated.length) {
+    lines.push("暂无。");
+  } else {
+    lines.push("| 候选人 | 可信度 | 淘汰理由 |");
+    lines.push("|---|---:|---|");
+    for (const item of eliminated) {
+      lines.push(`| ${item.candidate} | ${item.trust_score} | ${item.reason || "可信度低于阈值"} |`);
+    }
+  }
+
+  lines.push("");
+  lines.push("## 晋级排序榜（按综合得分从高到低）");
+  if (!ranked.length) {
+    lines.push("暂无。");
+  } else {
+    lines.push("| 排名 | 候选人 | 综合得分 | 匹配度 | 可信度 | 建议标签 |");
+    lines.push("|---:|---|---:|---:|---:|---|");
+    for (const item of ranked) {
+      lines.push(`| ${item.rank} | ${item.candidate}（${item.total_years || 0}年） | ${item.final_score ?? "-"} | ${item.match_score ?? "-"} | ${item.trust_score} | ${item.recommendation_label} |`);
+    }
+  }
+
+  lines.push("");
+  lines.push("## 疑点与追问清单");
+  if (!riskQuestions.length) {
+    lines.push("暂无明显疑点。");
+  } else {
+    for (const item of riskQuestions) {
+      lines.push(`### ${item.candidate}`);
+      for (const flag of item.flags || []) {
+        const evidence = (flag.evidence || []).join("；") || "无明确原文片段";
+        const question = (flag.questions || []).join("；") || "建议面试核实相关经历。";
+        lines.push(`- ${evidence} -> ${flag.type} -> ${flag.reason} -> ${question}`);
+      }
+    }
+  }
+
+  lines.push("");
+  lines.push("## 竞争加分明细");
+  if (!bonusDetails.length) {
+    lines.push("暂无明确竞争加分项。");
+  } else {
+    for (const item of bonusDetails) {
+      lines.push(`### ${item.candidate}`);
+      for (const detail of item.details || []) {
+        lines.push(`- ${detail.item}：+${detail.points}，依据：${(detail.evidence || []).join("；")}`);
+      }
+    }
+  }
+
+  lines.push("");
+  lines.push("## 评估说明");
+  lines.push("- 本分析基于简历文本特征与规则引擎生成，仅供招聘初筛参考，不构成对候选人品行或录用结果的定性。");
+  lines.push("- 关键数据请以面试核实、作品验证和背景调查为准。");
+
+  return { markdown: lines.join("\n") };
+}
+
+const TOOLS = [
+  {
+    name: "parse_jd",
+    description: "从岗位 JD 文本中提取工作年限、技能、行业、职责和加分项要求。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        job_description: { type: "string", description: "岗位 JD 原文。" },
+      },
+      required: ["job_description"],
+    },
+  },
+  {
+    name: "analyze_candidate",
+    description: "分析单个候选人，输出结构化简历信息、可信度、匹配度、综合得分和面试追问。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        resume: {
+          type: "object",
+          properties: {
+            file_name: { type: "string" },
+            text: { type: "string" },
+          },
+          required: ["text"],
+        },
+        job_description: { type: "string" },
+        config: { type: "object" },
+      },
+      required: ["resume"],
+    },
+  },
+  {
+    name: "screen_resumes",
+    description: "批量分析多份简历和岗位 JD，输出淘汰名单、晋级排序榜、疑点追问和 Markdown 报告。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        resumes: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              file_name: { type: "string" },
+              text: { type: "string" },
+            },
+            required: ["text"],
+          },
+        },
+        job_description: { type: "string" },
+        config: {
+          type: "object",
+          properties: {
+            trust_threshold: { type: "number" },
+            match_weight: { type: "number" },
+            competitiveness_weight: { type: "number" },
+          },
+        },
+      },
+      required: ["resumes", "job_description"],
+    },
+  },
+  {
+    name: "generate_report",
+    description: "把 screen_resumes 的结构化结果转换为中文 Markdown 报告。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        screening_result: { type: "object" },
+      },
+      required: ["screening_result"],
+    },
+  },
+];
+
+function callTool(name, args) {
+  if (name === "parse_jd") return parseJd(args || {});
+  if (name === "analyze_candidate") return analyzeCandidate(args || {});
+  if (name === "screen_resumes") return screenResumes(args || {});
+  if (name === "generate_report") return generateReport(args || {});
+  throw new Error(`未知工具：${name}`);
+}
+
+let inputBuffer = Buffer.alloc(0);
+
+process.stdin.on("data", (chunk) => {
+  inputBuffer = Buffer.concat([inputBuffer, chunk]);
+  processMessages();
+});
+
+process.stdin.on("error", () => process.exit(1));
+
+function processMessages() {
+  while (true) {
+    const headerEnd = inputBuffer.indexOf("\r\n\r\n");
+    if (headerEnd === -1) return;
+
+    const header = inputBuffer.slice(0, headerEnd).toString("utf8");
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) {
+      inputBuffer = inputBuffer.slice(headerEnd + 4);
+      continue;
+    }
+
+    const length = Number(match[1]);
+    const messageStart = headerEnd + 4;
+    const messageEnd = messageStart + length;
+    if (inputBuffer.length < messageEnd) return;
+
+    const raw = inputBuffer.slice(messageStart, messageEnd).toString("utf8");
+    inputBuffer = inputBuffer.slice(messageEnd);
+
+    try {
+      handleMessage(JSON.parse(raw));
+    } catch (error) {
+      sendError(null, -32700, `解析 MCP 消息失败：${error.message}`);
+    }
+  }
+}
+
+function handleMessage(message) {
+  if (!message || typeof message !== "object") return;
+  if (message.id === undefined || message.id === null) return;
+
+  try {
+    if (message.method === "initialize") {
+      sendResult(message.id, {
+        protocolVersion: message.params?.protocolVersion || "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+      });
+      return;
+    }
+
+    if (message.method === "tools/list") {
+      sendResult(message.id, { tools: TOOLS });
+      return;
+    }
+
+    if (message.method === "tools/call") {
+      const toolName = message.params?.name;
+      const args = message.params?.arguments || {};
+      const result = callTool(toolName, args);
+      sendResult(message.id, {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+        structuredContent: result,
+      });
+      return;
+    }
+
+    sendError(message.id, -32601, `不支持的方法：${message.method}`);
+  } catch (error) {
+    sendError(message.id, -32000, error.message || String(error));
+  }
+}
+
+function sendResult(id, result) {
+  writeMessage({ jsonrpc: "2.0", id, result });
+}
+
+function sendError(id, code, message) {
+  writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
+}
+
+function writeMessage(payload) {
+  const json = JSON.stringify(payload);
+  const bytes = Buffer.byteLength(json, "utf8");
+  process.stdout.write(`Content-Length: ${bytes}\r\n\r\n${json}`);
+}

package/mcp-config-examples.json

@@ -0,0 +1,73 @@
+{
+  "serviceName": "简历初筛MCP",
+  "description": "为简历初筛执行器提供岗位JD解析、简历结构化、岗位匹配度计算、可信度检测、综合评分、候选人排序和中文报告生成能力。Agent负责对话、文件接收和流程调度，MCP负责稳定的规则计算和结构化输出，避免仅依赖提示词进行打分和排序。",
+  "recommendedInstallMethod": "npx",
+  "npxPublishedPackage": {
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "command": "npx",
+        "args": [
+          "-y",
+          "resume-screening-mcp"
+        ],
+        "env": {}
+      }
+    }
+  },
+  "npxGitHubPackage": {
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "command": "npx",
+        "args": [
+          "-y",
+          "github:你的用户名/resume-screening-mcp"
+        ],
+        "env": {}
+      }
+    }
+  },
+  "uvxNotRecommended": {
+    "note": "当前项目是 Node.js MCP，不是 Python 包，不建议选择 uvx。除非后续重写为 Python 包。",
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "command": "uvx",
+        "args": [
+          "resume-screening-mcp"
+        ],
+        "env": {}
+      }
+    }
+  },
+  "sseNotRecommendedUntilDeployed": {
+    "note": "只有部署成远程 SSE MCP 服务后才使用。",
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "url": "https://你的域名/sse",
+        "env": {}
+      }
+    }
+  },
+  "streamableHttpNotRecommendedUntilDeployed": {
+    "note": "只有部署成远程 Streamable HTTP MCP 服务后才使用。",
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "url": "https://你的域名/mcp",
+        "env": {}
+      }
+    }
+  },
+  "componentLibraryNotRecommended": {
+    "note": "组件库适合平台内置组件，不适合当前自定义简历筛选 MCP。"
+  },
+  "localNodeTest": {
+    "mcpServers": {
+      "resume-screening-mcp": {
+        "command": "node",
+        "args": [
+          "C:\\Users\\Lenovo\\Documents\\Codex\\2026-09-18\\ge-m\\outputs\\resume-screening-mcp\\src\\index.js"
+        ],
+        "env": {}
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@cjsqbn/resume-screening-mcp",
+  "version": "0.1.0",
+  "description": "MCP service for resume screening, JD matching, trust checking, scoring and candidate ranking.",
+  "type": "module",
+  "bin": "./index.js",
+  "files": [
+    "index.js",
+    "README.md",
+    "agent-prompt.md",
+    "platform-ready.md",
+    "mcp-config-examples.json"
+  ],
+  "scripts": {
+    "start": "node ./index.js",
+    "test:smoke": "node ./smoke-test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/platform-ready.md

@@ -0,0 +1,195 @@
+# 简历初筛 MCP 平台填写版
+
+## 一 服务名称
+
+```text
+简历初筛MCP
+```
+
+说明：平台服务名称限制 30 字以内，这个名称简短、明确，适合直接填写。
+
+## 二 服务描述
+
+```text
+为简历初筛执行器提供岗位JD解析、简历结构化、岗位匹配度计算、可信度检测、综合评分、候选人排序和中文报告生成能力。Agent负责对话、文件接收和流程调度，MCP负责稳定的规则计算和结构化输出，避免仅依赖提示词进行打分和排序。
+```
+
+## 三 推荐安装方式
+
+推荐选择：
+
+```text
+npx
+```
+
+原因：当前 MCP 是 Node.js 标准 stdio MCP 服务，最适合通过 `npx` 或 `node` 启动。
+
+## 四 各安装方式说明
+
+| 安装方式 | 是否推荐 | 说明 |
+|---|---|---|
+| npx | 推荐 | 当前项目是 Node MCP，最适合使用 npx。发布到 npm 或 GitHub 后可以直接配置。 |
+| uvx | 不推荐 | uvx 适合 Python MCP 包。本项目不是 Python 包，除非后续重写为 Python 版本。 |
+| sse | 暂不推荐 | 适合已经部署成远程 SSE 服务的 MCP。本项目当前是本地 stdio 服务。 |
+| streamableHttp | 暂不推荐 | 适合部署成远程 HTTP MCP 服务。本项目当前没有远程 HTTP 地址。 |
+| 组件库 | 不推荐 | 适合平台内置组件，不适合这个自定义简历筛选服务。 |
+
+## 五 MCP 服务配置
+
+### 方案 A 本地测试配置
+
+如果平台允许使用 `node` 命令，可以直接填这个：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "node",
+      "args": [
+        "C:\\Users\\Lenovo\\Documents\\Codex\\2026-09-18\\ge-m\\outputs\\resume-screening-mcp\\src\\index.js"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+### 方案 B 发布到 npm 后的 npx 配置
+
+如果你把项目发布到 npm，选择 `npx`，配置填写：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+### 方案 C 上传到 GitHub 后的 npx 配置
+
+如果你暂时不发布 npm，可以先上传到 GitHub，然后配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "github:你的用户名/resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+使用时把 `你的用户名` 改成你的 GitHub 用户名。
+
+### 方案 D uvx 配置说明
+
+当前不建议填写 uvx。如果平台必须选择 uvx，需要先把 MCP 改写成 Python 包，然后才可以使用类似配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "uvx",
+      "args": [
+        "resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+当前生成的项目不是 Python 包，所以不要直接使用这个配置。
+
+### 方案 E sse 配置说明
+
+当前不建议选择 sse。只有当你把 MCP 部署成远程 SSE 服务后，才使用类似配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "url": "https://你的域名/sse",
+      "env": {}
+    }
+  }
+}
+```
+
+### 方案 F streamableHttp 配置说明
+
+当前不建议选择 streamableHttp。只有当你把 MCP 部署成远程 HTTP 服务后，才使用类似配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "url": "https://你的域名/mcp",
+      "env": {}
+    }
+  }
+}
+```
+
+## 六 当前 MCP 工具
+
+| 工具名 | 作用 |
+|---|---|
+| `parse_jd` | 解析岗位 JD，提取年限、技能、行业、职责和加分项 |
+| `analyze_candidate` | 分析单个候选人，输出结构化信息、可信度、匹配度和综合得分 |
+| `screen_resumes` | 批量分析多份简历，输出淘汰名单、晋级榜、疑点追问和报告 |
+| `generate_report` | 将结构化筛选结果转换为中文 Markdown 报告 |
+
+## 七 推荐填写总结
+
+如果你的平台页面和截图一致，建议这样填：
+
+服务名称：
+
+```text
+简历初筛MCP
+```
+
+描述：
+
+```text
+为简历初筛执行器提供岗位JD解析、简历结构化、岗位匹配度计算、可信度检测、综合评分、候选人排序和中文报告生成能力。Agent负责对话、文件接收和流程调度，MCP负责稳定的规则计算和结构化输出，避免仅依赖提示词进行打分和排序。
+```
+
+安装方式：
+
+```text
+npx
+```
+
+MCP 服务配置：
+
+```json
+{
+  "mcpServers": {
+    "resume-screening-mcp": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "github:你的用户名/resume-screening-mcp"
+      ],
+      "env": {}
+    }
+  }
+}
+```
+
+如果你还没有上传 GitHub，就先不要用 GitHub 配置；先使用本地 `node` 配置测试。