Content
# Tool List
> A AI Native resume adaptive optimization system based on MCP specification, designed to address the contradiction between customized resumes for each job and the need for rapid reuse in high-frequency job applications.
**Successfully tested in Claude + DeepSeek + VSCode (Cline) integrated environment.**
## Project Background
There exists a core contradiction in job searching: each job description (JD) has different emphases, and highly customized resumes can improve the hit rate, but manual adjustments for each application are time-consuming and difficult to reuse.
This project uses the MCP protocol to toolize the resume rewriting process, constructing an AI Agent system that can stably reuse across different JD scenarios, along with an industrial-grade automated evaluation scaffold (Promptfoo + LangSmith) to ensure the quality of large model outputs is controllable, auditable, and regressible.
## System Architecture
```
User Input JD
│
▼
┌─────────────────────────────────────────┐
│ Web Front-end (UI Entrance) │
└──────────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ MCP Server (server.py) │
│ │
│ Resources │
│ ├── resume://full Full Experience Library │
│ └── resume://current_jd Current Target JD │
│ │
│ Tools │
│ ├── load_jd Load and Persist JD │
│ ├── analyze_jd_match Match Degree Analysis │
│ ├── rewrite_section Section Rewriting │
│ ├── assemble_resume Complete Resume Assembly │
│ └── save_resume_draft Save Draft │
└──────────────────┬──────────────────────┘
│
┌──────────┴──────────┐
▼ ▼
Claude API DeepSeek API
(Tool Invocation Decision) (Content Generation)
│ │
└──────────┬──────────┘
▼
┌─────────────────────────────────────────┐
│ LLM Eval Harness │
│ Promptfoo 5×3 Matrix Evaluation │
│ LangSmith Full-chain Trace │
└─────────────────────────────────────────┘
```
## Core Functions
### 1. Standardized Context Access (MCP Resource)
Through `resume://full` and `resume://current_jd` resources, the resume material library and target JD are automatically mounted to the model context, eliminating the need for manual copying and pasting, and achieving stable context injection across sessions.
### 2. Modularized Rewriting Workflow (Skill)
The unstructured resume rewriting experience is distilled into a four-step standard process:
```
load_jd → analyze_jd_match → rewrite_section → assemble_resume
```
Each experience is categorized into **core match / secondary match / supplementary match** and rewritten in a structured formula: "JD requirement → what I did → result/value".
### 3. Claude + DeepSeek Multi-model Collaboration
| Model | Responsibility |
|------|------|
| Claude | MCP Tool Invocation Decision, Quality Control |
| DeepSeek | Chinese Content Generation (Cost Reduction) |
Through Prompt Engineering, the output format is strongly constrained, and model hallucinations are intercepted to eliminate issues with models carrying over irrelevant content.
### 4. LLM Eval Harness (Evaluation)
#### Promptfoo 5×3 Orthogonal Matrix Evaluation Dataset
A dataset covering:
- **5 Industry Positions**: Science and Technology / Engineering / Agriculture / Medical Care / Law
- **3 Resume Gradients**: Excellent / Medium / Weak Background
Comprising **15 orthogonal test scenarios**.
#### Assertion Evolution from Simple to Complex
Initially using `icontains` simple keyword assertions, but later reconstructed into **fuzzy regular expression matching and JavaScript functional assertions** to reduce misjudgment rates:
```javascript
// Reconstructed: compound assertions combining format constraints and semantic tolerance
function({ output }) {
const lines = output.split('\n').filter(l => l.trim());
// Multi-semantic coverage: passing if any synonym appears
const hasContent = /育种|选育|品种/.test(output) ||
/实验|试验|测试/.test(output);
// Format constraint: line count does not exceed the limit
return lines.length <= 6 && hasContent;
}
```
#### LangSmith Full-chain White-box Tracing
Through `wrap_openai` for DeepSeek SDK, automatic tracking probes are mounted, enabling:
- **Two-layer nested execution tree**: Tool-level invocation (parent layer) + LLM response (child layer)
- **Accurate tracking of Prompt splicing, Token consumption, response delay, and model cost**
## Engineering Directory
```
agent-resume/
├── server.py # MCP Server Core (Resources + Tools)
├── requirements.txt # Python Dependencies
├── .gitignore
├── agent-sessions.code-workspace # VSCode Workspace Configuration
├── .claude/
│ └── agents/
│ └── resume_editor.agent.md # Agent System-level Behavior Specification and Four-step Process
├── data/
│ ├── resume.md # Full Experience Material Library (fill in yourself)
│ └── current_jd.txt # Current Target JD (automatically written by load_jd tool)
├── output/
│ └── *.md # Customized Resume Drafts for Each Position
└── tests/
├── promptfoo/ # 5×3 Matrix Evaluation Configuration + JavaScript Functional Assertions
└── langsmith/ # LangSmith White-box Tracing Driver Script
```
## Quick Start
### Environment Preparation
```bash
# Clone the project
git clone https://github.com/your-username/resume-adjuster.git
cd resume-adjuster
# Create a virtual environment
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
# Install Python dependencies
pip install mcp openai langsmith
# Install Promptfoo
npm install -g promptfoo
```
### Configure API Keys
Fill in your corresponding keys in the project.
DeepSeek Official API Interface Link: https://api-docs.deepseek.com/en/
```bash
# .env
ANTHROPIC_API_KEY=your_anthropic_key # Claude
DEEPSEEK_API_KEY=your_deepseek_key # DeepSeek
LANGSMITH_API_KEY=your_langsmith_key # LangSmith
LANGSMITH_PROJECT=resume_adjuster
LANGSMITH_TRACING=true
LANGSMITH_ENDPOINT=https://api.smith.langchain.com
```
### Fill in Resume Material Library
Fill in your complete experience in `data/resume.md`. The more structured the material, the higher the rewriting quality.
### Launch in VSCode + Cline
1. Start MCP Server:
```bash
python server.py
```
2. Register in Cline's MCP configuration (`.vscode/cline_mcp_config.json`):
```json
{
"mcpServers": {
"resume-adjuster": {
"command": "python",
"args": ["/your/absolute/path/server.py"]
}
}
}
```
3. Reload Cline, paste JD in the conversation, and the Agent will complete the four-step process.
### Run Evaluation
```bash
# Promptfoo 5×3 Matrix Evaluation (--no-cache to avoid old cache pollution)
npx promptfoo eval -c tests/promptfooconfig.yaml --no-cache
# View Evaluation Dashboard
npx promptfoo view
# LangSmith White-box Tracing
python tests/langsmith/run_langsmith_eval.py
```
## Technology Stack
| Category | Technology |
|------|------|
| AI Protocol | MCP (Model Context Protocol) |
| Model | Claude (Anthropic) / DeepSeek |
| Client | Cline + VSCode |
| Evaluation Framework | Promptfoo |
| Link Tracing | LangSmith |
| Backend | Python / asyncio |
| Document Generation | docx.js |
## 📄 License
MIT
