Modular RAG MCP Server

A pluggable, observable modular RAG (Retrieval-Augmented Generation) service framework that exposes tool interfaces externally through the MCP (Model Context Protocol), supporting direct invocation by AI assistants such as Copilot / Claude. It is also a practical project and companion teaching resource designed for learning and interview preparation for LLM-related positions.

📖 Table of Contents

• Project Overview

• Branch Guide

• Quick Start

• Who Should Use This Project & How

• Resume Reference

• FAQ

• Next Steps

Related MCP server: mcp-rag-agent

🏗️ Project Overview

What This Project Is

This project connects the most common core components in RAG interviews — Retrieval (Hybrid Search + Rerank), Multimodal Vision Processing (Image Captioning), RAG Evaluation (Ragas + Custom), Generation (LLM Response) — together with the currently popular application protocol MCP (Model Context Protocol) into a complete, runnable engineering project.

One of the project's biggest highlights is how easily it can be adapted to your own business. Thanks to the fully pluggable architecture across the entire pipeline, you can quickly integrate it into your existing projects. No matter your background or needs, there is a way to use it that fits you. Specific usage strategies are detailed later in Who Should Use This Project & How.

More Than a Project — A Complete Way of Thinking

Even more valuable than the project itself is the complete engineering mindset behind it:

• How to write a DEV_SPEC (development specification document) to drive development

• How to use a Skill to automatically write code based on the Spec

• How to use Skill for automated testing, packaging, and environment configuration

• How to extend based on a pluggable architecture (for example, extending to an Agent)

Once you learn the mindset, you can build entirely new projects and extensions on your own. Each of these steps, along with the design rationale, has corresponding video explanations in the notes — we recommend watching them alongside the project.

Core Capabilities at a Glance

Technical Highlights

🔌 Fully Pluggable Architecture Across the Pipeline: Every core component — LLM / Embedding / Reranker / Splitter / VectorStore / Evaluator — defines an abstract interface, supporting "Lego-brick-style" replacement. Switch backends with a single configuration file, with zero code changes.

🔍 Hybrid Search + Reranking: BM25 sparse retrieval handles exact matching for proper nouns, while Dense Embedding handles semantic matching for synonyms. After RRF fusion, optional Cross-Encoder / LLM Rerank fine-ranks the results, balancing recall and precision.

🖼️ Multimodal Image Processing: Uses an Image-to-Text strategy, leveraging a Vision LLM to automatically generate image descriptions and stitch them into chunks. Reusing the pure-text RAG pipeline, you can "search text and get images".

📡 MCP Ecosystem Integration: Follows the Model Context Protocol standard and can be directly connected to MCP clients such as GitHub Copilot and Claude Desktop — zero front-end development, build once, use everywhere.

📊 Visual Management + Automated Evaluation: The Streamlit Dashboard provides complete data management and pipeline tracing capabilities, integrates evaluation frameworks such as Ragas, and establishes a data-driven iterative feedback loop.

🧪 Three-Layer Testing System: Unit / Integration / E2E layered testing covers independent module logic, inter-module interactions, and complete pipelines (MCP Client / Dashboard).

🤖 Skill-Driven Full Workflow: Built-in Agent Skills include auto-coder (automatic coding), qa-tester (automatic testing), package (cleanup and packaging), and setup (one-click configuration), covering the complete development lifecycle from code writing to testing, packaging, and deployment. Each Skill's usage and design philosophy are covered by explanatory videos in the project section of the notes.

📖 For detailed architecture design, module descriptions, and task scheduling, please refer to DEV_SPEC.md

📂 Branch Guide

This project provides three branches for different use cases. Choose based on your needs:

main — The Cleanest, Complete Code

• Always has only 1 commit, containing the latest complete code of the project

• Who it's for:

  • Students who want to quickly experience the project's full functionality

  • Students who are short on time and need to quickly get a project for interviews, skipping the intermediate development process

  • Students who want to build secondary extensions directly on top of this project

• How to use: After cloning, simply run the Setup Skill to try it out

dev — Retains the Complete Development History

• Code is exactly the same as main, but retains the full commit history

• Records every step of building the project from scratch, including many intermediate milestones

• Who it's for: Students who want to understand how the project was built step by step from zero, and can trace the development thinking through the commit history

clean-start — A Clean Starting Point, From Zero

• Contains only the project skeleton (Agent Skills + DEV_SPEC), with all task progress reset to zero

• Retains the complete Skill configuration so you can use Agents to assist development

• Who it's for:

  • Students with plenty of time who want to develop from scratch (strongly recommended)

  • Students who want to experience the complete workflow: write Spec → break down tasks → write code → write tests → iterate and optimize

  • You can even redesign the architecture based on your own understanding, implement it with your own approach, and gain a deep understanding of every module

  • Use all the corresponding ideas we teach (Spec-driven development, test-first, pluggable architecture, etc.) to complete the entire project

• Core philosophy: The code for this entire project is automatically generated by AI based on the DEV_SPEC — you don't need to write code by hand. The AI reads the task definitions, architecture design, and interface specifications in the Spec through Skills, and automatically generates code that conforms to the spec. For this approach, please refer to the corresponding video in the notes: 5.1 Project Skills Usage: How to Make AI Use Skills to Follow the DEV_SPEC to Complete Code.

🚀 Quick Start

1. Clone the Project

git clone <repo-url>
cd Modular-RAG-MCP-Server

2. One-Click Configuration (Setup Skill)

This project provides a Setup Skill to complete all environment configuration in one click, including: Provider selection → API Key configuration → dependency installation → configuration file generation → Dashboard startup.

Open the project in VS Code and enter the following in the Copilot / Claude dialog:

setup

The Agent will automatically guide you through the entire configuration process.

💡 If you are not familiar with how to use Skills, please watch the Setup Skill Usage video in the companion notes.

🎯 Who Should Use This Project & How

Everyone has a different background — some are campus recruiting, some are experienced hires; and different foundations — some have AI project experience, some are switching directions. Therefore, the strategy for using this project should also differ. Please use it flexibly and avoid rigidly copying and pasting.

But one thing is universal: the thinking behind the whole project — how to write a Spec to quickly spin up a project, how to use Skills to drive AI to automatically code and test — these engineering methodologies apply to any project and are worth learning for everyone.

For the project itself, I'll provide some specific examples of usage strategies in different scenarios, based on my own personal experience — if it were me, how would I use this project in different situations — as a reference for everyone.

1. Pure RAG Learning — Use the Project as Learning Material for the Complete RAG Workflow

This project is itself a complete RAG system and can serve as a hands-on companion project for learning RAG.

When I first started learning RAG, I read this book: 《Large Model RAG in Practice: RAG Principles, Applications, and System Construction》 (written by AI experts including Wang Peng, Gu Qingshui, Bian Longpeng, etc.). You can absolutely use this book to learn RAG. The typical components covered in the book — retrieval, generation, vector databases, chunking strategies, reranking, etc. — are actually the same core content you'll find in any RAG-related book.

This project connects all those steps together, so it can be used as a general full-pipeline RAG project to learn the entire process. You can pair it with this book, and I believe you can pair it with other RAG books as well, because the workflow is the same. RAG interviews are essentially about these processes, their principles, and the real-world difficulties and optimizations encountered.

2. Short on Time — Need a Project for Interviews

If you don't have an AI-related project right now and urgently need one for interviews, you can:

1. Use this project directly — clone the main branch and run it with the Setup Skill

2. Use the Resume Writer Skill to write your resume (the Skill will generate a customized project description based on your background)

3. Try to understand the project, run through the core workflow, and go to interviews using the interview questions I've compiled for this project

4. Deepen your understanding and expand the project as interviews progress — interviews themselves are the best learning motivator

For example, if it's March now and you need to find a summer internship, time is tight — put it on your resume first, learn while interviewing, and expand when you have time. This solves the urgent problem of needing a project for interviews. The approach is: put it on your resume → go to interviews → improve the project based on interview feedback.

Summer internships usually have opportunities from March to July. Once you land an internship and gain large-model project experience, use it as a springboard to keep learning — from July to October for fall recruiting, or even to next March for spring recruiting, you'll have plenty of time to keep accumulating. It may seem a bit late to start now, but it's actually not. If you can maintain a consistent learning pace from now until next March — a full year of learning — there's absolutely no problem landing a full-time position in the LLM direction. The key is whether you can sustain your learning momentum for that long.

3. Relatively Ample Time — Use This Project as a Starting Point for Expansion

You can treat this project as a starting point and expand it in a targeted way based on your development direction. The DEV_SPEC also lists expansion directions; here are a few common ones:

• Want to add Agent knowledge: Implement the Agent side yourself, adding context handling, Tool Calling, and ReAct logic, and use this project as a module and capability of the Agent — turning it into an Agent + RAG project

• Want to showcase backend engineering skills: Add backend deployment capabilities, write a Dockerfile, build CI/CD pipelines, and add monitoring and log collection

• Want to go deeper into RAG: Expand to advanced forms such as Agentic RAG or Graph RAG, or run more optimization experiments on retrieval strategies

Everyone's development direction is different — just like the Resume Writer Skill included with the project, which asks about your background and situation before writing a resume. Whether you're targeting a role as an LLM Application Development Engineer, RAG Engineer, or Full-Stack Engineer, and whether you're in campus recruiting or experienced hiring, the requirements are all different (you can see the introductions to different LLM positions and tech stacks in the LLM Positions Overview section of the notes), so you need to expand in a targeted way yourself.

Strong recommendation: No matter your background or how you expand, you will most likely need to write your resume around your own business context. So at least try it — drop in documents from your own domain (finance, law, healthcare, or your business documents) and see how retrieval performs. If the results aren't good, adjust and improve. The process itself is the best learning, and it's the most convincing practical experience you can talk about in interviews.

4. Plenty of Time — Experience the Complete Workflow From Zero

If you have enough time, I recommend starting from the clean-start branch — or even removing the DEV_SPEC on top of clean-start and starting from document design, experiencing step by step:

Document design → AI writes code → improve and iterate → test → deploy

Along the way, you'll learn the methodology of the entire process. How to write the DEV_SPEC, how to design Skills, and so on, are all explained in the corresponding videos in the project section of the notes. You can redesign the documents, improve them, or even go directly in an Agent direction to complete the full workflow.

By doing this, you'll learn the complete way of thinking for developing a project. The biggest advantage of this methodology is that the bar is extremely low — almost anyone can design it and complete the entire project. This way, you learn the thinking, you learn the process, and the project can be highly customized. Many friends in the community have already done exactly this.

5. Integrating Into an Existing Project — Add RAG Capabilities to Your Current Project

This is actually another good strategy, and it's one I might use myself. Let me speak from personal experience:

When I was job hunting before, I already had 2 Agent projects, but the RAG flow in them was very rudimentary. My resume roughly said "the Agent project did X, which involved some RAG knowledge." During interviews, interviewers would inevitably ask about RAG. I would explain it to them, but because my previous projects' RAG system was very shallow — basically just basic embedding vector matching, with no coarse recall, reranking, or other strategies — the interviewers quickly saw it was shallow.

After building this project, one approach is to integrate this project's RAG capabilities into my previous Agent project, and describe it on the resume not as a standalone project but as part of the Agent project. For example:

"...In the project, a self-developed modular RAG system was used for knowledge retrieval, employing BM25 + Dense Embedding hybrid recall with RRF fusion ranking, combined with Cross-Encoder reranking to improve Top-K precision; it supports multimodal document processing (PDF parsing + Image Captioning), and exposes standardized tool interfaces through the MCP protocol for Agent invocation. It integrates the Ragas evaluation framework, establishes a Golden Test Set regression testing mechanism, and continuously optimizes retrieval quality..."

This way, your original Agent project gains RAG depth, and when interviewers ask about it, you'll have plenty to talk about.

6. Product Managers — Yes, You Read That Right, PMs Can Use This Project Too

LLM product manager interviews increasingly test RAG knowledge, and some companies even require product managers to build a POC (Proof of Concept) themselves before handing it to development. This project and the methodology behind it can absolutely help you do that.

Why PMs can use it:

1. Interviews require it: LLM product roles test the basic principles and workflow of RAG. Through this project, you can intuitively experience the entire RAG process — from document ingestion, chunking, vectorization, retrieval, reranking, to final generation — and build a product-level understanding

2. POC capability: You can completely use this methodology to build an entire project — write the documentation (DEV_SPEC), or simply use the existing documentation, then use Skills to let AI generate the code for you. In an interview, you talk about your thinking and product design; the code was written by AI. That's completely reasonable in today's context

3. No need to worry about technical details: A product manager doesn't need to care about how every line of code is written, but by running through this workflow, you can think about pain points from a product perspective — such as how to define metrics when retrieval is inaccurate, how to design feedback mechanisms in the user experience, and how data quality affects RAG results

How to do it specifically:

• Clone the main branch, run it with the Setup Skill, and experience the complete workflow

• Drop in documents from your own business domain, observe retrieval results, and think about optimization directions from a product perspective

• In interviews, talk about your product thinking and design considerations, and explain that the technical implementation was completed with AI assistance

💡 The notes also provide Vibe Coding tutorials (such as Tina Huang's explanations), which are very suitable for students without a technical background to reference when rapidly building prototypes with AI.

About "The Project Is Shallow"

Finally, I want to raise one point on its own (this applies to all the situations above):

No project's in-depth optimization happens in one step.

If you're switching careers and built all your projects yourself, you'll likely encounter interviewers who think your projects are shallow. I've mentioned this before, but don't be afraid:

1. Project depth is not a necessary condition for entering the industry. Last year I received 6 offers, including from major tech companies. Even so, some interviewers still thought my projects were shallow. Interviews consider many other factors — theoretical foundation, algorithmic ability, background fit, breadth of knowledge, and so on. Don't think you can't make the transition just because you feel your projects are shallow.

2. Projects are continuously optimized and deepened. If an interviewer says your project is shallow, listen to their feedback — you'll definitely be able to tell why they think it's shallow. For example, if they think your data isn't complex enough, create more complex data; if they think your image processing is too simple, expand your multimodal strategy. I myself kept adding things to my projects during the interview process: for the Agent project I built earlier, as interviews progressed, I added deployment, training, reflection data, and evaluation modules — the whole process went hand in hand with interviewing.

Give yourself extra interview time, and improve and deepen your project while interviewing. This brings us back to the overall methodology of this project — once you learn these ways of thinking, you can keep expanding, and the barrier to expansion is very low. After all, it's just coming up with ideas and letting AI write the code. So there's no need to be afraid.

Here's a real data point: This project took me about 2 months of after-work time from inception to completion. During that period, I also had a full-time job, ran my self-media channels, and had other content to produce. So I hope you won't treat this project as something that's already extremely deep without any expansion on your part — especially if you're an experienced hire. But think about it the other way — if all this was built in two months of after-work time, how fast could you expand on your own once you've learned this methodology?

The methodology is all here — every plan, process, and record is documented and explained in videos. Ultimately, it's up to you to expand and iterate, and turn it into the project that fits you best.

📝 Resume Reference

⚠️ Strong recommendation: Please use the Resume Writer Skill included with the project to generate your resume's project experience, rather than directly copying the examples below.

Resume project experience must be tailored — it needs to be customized based on your own business background, target position, and technical focus. The examples below are only meant to demonstrate the Skill's output and how to write for different scenarios. Blindly copying them is meaningless.

How to use the Resume Writer Skill: In VS Code, enter write resume or resume in the Copilot / Claude dialog. The Skill will guide you through profile collection and automatically generate a four-part resume. For specific usage and design philosophy, please refer to the video explanations in the project section of the notes.

How the Resume Writer Skill Works

The Skill uses a triangle model of "Writing Principles + Project Highlights + User Profile = Customized Resume", with the following workflow:

1. Profile Collection: The Skill asks about your target position (RAG Engineer / Backend / Agent, etc.), business background, technical focus, and special requirements

2. Highlight Matching: Based on your target direction, it selects 3-5 of the project's 10 major technical highlights that best match and writes them into bullet points

3. Four-Part Generation: Strictly outputs in the Context → Goal → Process → Result structure, with each bullet following "verb-led opening + technical detail + quantified outcome"

4. Interview Follow-up Prediction: Automatically generates 3-5 likely follow-up questions from interviewers so you can prepare in advance

Example 1: Campus Recruiting · RAG Engineer Direction

Below is an example output generated by the Skill based on "campus recruiting, RAG direction, general framework pattern":

Intelligent Knowledge Retrieval & Q&A System | 2024.09 - 2025.02 | Independently Designed & Developed

Context: Targeting the common pain points in enterprise knowledge base scenarios — scattered documents, insufficient retrieval precision, and difficulty integrating private knowledge into AI applications — designed and implemented a modular RAG retrieval framework.

Goal: Build an intelligent knowledge Q&A system based on hybrid retrieval + MCP protocol, enabling precise semantic retrieval and direct invocation of private knowledge bases by AI Agents, raising document Q&A accuracy to above 90%.

Process:

• Designed a BM25 + Dense Embedding hybrid recall architecture, balancing recall and precision through RRF fusion ranking, combined with Cross-Encoder reranking to improve Top-10 hit rate by approximately 25%

• Built an end-to-end Ingestion Pipeline (PDF parsing → Markdown → semantic chunking → Metadata enrichment → Embedding → Upsert), integrated a Vision LLM to automatically generate image descriptions and stitch them into chunks, enabling "search text, get images" by reusing the pure-text pipeline

• Implemented a fully pluggable architecture across LLM / Embedding / Reranker / VectorStore, defined unified abstract interfaces, and enabled one-click backend Provider switching via configuration files, supporting zero-code switching across 4+ LLM Providers

• Integrated a dual evaluation system of Ragas + Custom, established a Golden Test Set regression testing mechanism covering Faithfulness / Relevancy / Recall dimensions, rejecting "tuning by feel"

• Drove the full development workflow with Skills, covering coding, testing, configuration, and packaging through 5 major Agent Skills including auto-coder / qa-tester / setup / package, completing all 68 subtasks in 2 months of spare time

Result: The system supports real-time semantic retrieval across 5,000+ documents, achieving a retrieval accuracy (Hit Rate@10) of 92%, end-to-end query latency controlled within 800ms, and a three-layer testing system (Unit / Integration / E2E) covering 1,200+ test cases.

Tech Stack: Python / LangChain / ChromaDB / BM25 / Cross-Encoder / MCP Protocol / Streamlit / Ragas / Azure OpenAI

Example 2: Experienced Hire · Already Has an Agent Project, Adding RAG Depth

Below is an example output generated by the Skill based on "experienced hiring, Agent direction, Windows platform development business background" (integrating RAG capabilities into an existing Agent project):

Windows Platform Intelligent Knowledge Assistant | 2024.06 - 2025.02 | Core Developer

Context: In a Windows platform development team, version release information (Release Notes, change logs, patch announcements, compatibility notes, etc.) is scattered across multiple Wikis, documentation repositories, and internal systems. Engineers troubleshooting version differences or answering customer questions had to search across systems, and existing keyword search could not understand semantics, leading to low retrieval efficiency and frequent information gaps.

Goal: Build an intelligent knowledge assistant based on an Agent + RAG architecture for the team, enabling semantic retrieval and automatic Q&A across system documents, integrating it into engineers' daily toolchains (VS Code / Claude Desktop) via the MCP protocol, and reducing document search time by more than 60%.

Process:

• Designed an Agent + RAG layered architecture, where the Agent side handles intent recognition and Tool Calling, and the RAG side provides a two-stage retrieval capability of BM25 + Dense Embedding hybrid recall + Cross-Encoder fine reranking, exposed as standardized tool interfaces for Agent invocation via the MCP protocol

• Built an end-to-end Ingestion Pipeline supporting PDF / Markdown multi-format document parsing, integrated a Vision LLM to automatically generate image descriptions (architecture diagrams, screenshots, etc.), solving the multimodal retrieval need of "search text, get images"

• Built a pluggable backend architecture where LLM / Embedding / Reranker / VectorStore all define abstract interfaces, supporting one-click switching between Azure OpenAI ↔ DeepSeek ↔ Ollama to adapt to the team's different network environments

• Built a Streamlit Dashboard management platform with six functional pages: data browsing, Ingestion tracing, query tracing, and evaluation panel, achieving full-pipeline white-box observability

• Integrated the Ragas evaluation framework + Golden Test Set regression testing, continuously monitoring retrieval quality across version iterations, with Faithfulness scores stably above 0.85

• Adopted a Skill-driven full development workflow, writing a DEV_SPEC specification document to drive auto-coder for automatic coding, qa-tester for automatic testing and fixing, and setup for one-click environment configuration. 5 major Agent Skills covered the complete development lifecycle, delivering all 68 subtasks in 2 months of spare time

Result: The system covers 8,000+ technical documents for the team. Engineers' daily document search time dropped from 15 minutes to 3 minutes, retrieval accuracy (Hit Rate@10) reached 90%, the system has been integrated into 3 internal AI tools via the MCP protocol, and has processed 20,000+ queries in total.

Tech Stack: Python / Agent / Tool Calling / RAG / BM25 / Dense Retrieval / Cross-Encoder / MCP Protocol / ChromaDB / Streamlit / Ragas / Skill-Driven Development / Azure OpenAI

Example 3: Experienced Hire · Backend Engineer Transitioning to AI

Below is an example output generated by the Skill based on "experienced hire transitioning to AI, backend/architecture direction, financial compliance business background":

Compliance Intelligent Document Retrieval System | 2024.10 - 2025.02 | Design & Lead Development

Background: In the compliance department of a financial institution, regulatory documents and internal policy documents grew to tens of thousands in scale. The compliance team needed to quickly locate specific clauses in review and consultation scenarios, but the existing full-text search system could only match keywords exactly, unable to understand semantic near-synonyms like "anti-money laundering" and "AML," resulting in inefficient clause retrieval.

Goal: Design and implement a modular RAG retrieval system to bring semantic retrieval capabilities into the compliance document management workflow, supporting synonym and cross-language clause matching, with the target of raising compliance clause retrieval accuracy to over 90%.

Process:

• Led system architecture design, adopting a fully pluggable end-to-end architecture. LLM / Embedding / Reranker / Splitter / VectorStore all define abstract interfaces with factory patterns, allowing one-click backend switching via YAML configuration with zero code changes to adapt to different deployment environments

• Implemented a hybrid recall strategy combining BM25 sparse retrieval + Dense Embedding semantic retrieval, using RRF fusion ranking to balance exact matching of proper nouns with semantic near-synonym matching, improving retrieval accuracy by 22% over pure vector approaches

• Built a complete data ingestion pipeline supporting PDF parsing → semantic chunking → Chunk Refinement → Metadata Enrichment → vectorized storage, with idempotent DocumentManager management to ensure data consistency during document updates

• Established a three-tier testing system (Unit / Integration / E2E) covering 1200+ test cases, integrated the Ragas evaluation framework to build automated regression mechanisms, ensuring retrieval quality does not degrade through iteration cycles

• Exposed standardized tool interfaces based on the MCP protocol, supporting direct invocation by AI assistants such as GitHub Copilot / Claude Desktop, achieving "develop once, call from anywhere" service-oriented deployment

• Practiced a Skill-driven full-process engineering methodology, using DEV_SPEC specification documents to drive AI Agents to automatically complete coding (auto-coder), testing (qa-tester), environment configuration (setup), and cleanup/packaging (package), with all 68 subtasks delivered by Agents, compressing the development cycle to 2 months of spare-time work

Results: After launch, the system supports real-time semantic retrieval across 12,000+ compliance documents, raising clause retrieval accuracy from 68% to 91%, keeping single-query latency under 700ms, and improving the compliance team's document review efficiency by approximately 50%.

Tech Stack: Python / Pluggable Architecture / Factory Pattern / BM25 / Dense Retrieval / RRF / Cross-Encoder / ChromaDB / MCP Protocol / Streamlit / Ragas / Skill-Driven Development / Azure OpenAI

💡 Usage Reminders & Important Notes:

1. About the amplification strategy: The Resume Writer Skill includes an amplification strategy I designed — AI will package and amplify your project experience within reasonable bounds (e.g., quantified metrics, business scale). This is something I allow, and it's normal practice in resume writing. But this means: after generating your resume, you must think through what an interviewer might ask about each point and how you'd answer. The Skill automatically provides 3-5 predicted interview follow-up questions alongside the resume — please prepare for these seriously.

2. Treat the resume as a practice checklist: Every technical point written on your resume, you should actually try out. For example, if the resume says "retrieval accuracy improved by XX%" — then you should run it on your own data to see the actual results, what problems you encountered along the way, and how you tuned and solved them. These hands-on experiences are what truly carry weight in interviews and are the real learning process. For parts not covered in the resume (e.g., you haven't tried multimodal or run evaluations), you can use this as an opportunity to run code experiments.

3. What's generated is a draft — be sure to revise based on your own situation: The resume generated by the Skill is a draft, not a final version. You need to adjust it according to your actual situation — which technologies you've genuinely used in depth, which you only know superficially, and which metrics need to be replaced with your own data. There's an iron rule in resume writing: anything on your resume, you must be able to talk about. Even if a point is amplified, you need to think through how an interviewer might ask about it and how you'd justify it. If you can't explain something clearly, it's better to leave it off — anything you write must withstand follow-up questioning.

4. Method matters more than templates: The entire resume-writing approach is mine — including the amplification strategy, the four-part structure (Background → Goal → Process → Results → Tech Stack), and the highlight-matching logic — all of which are embedded in the Resume Writer Skill. If you have a resume template you trust more, or if you've extended or modified the project, you're fully welcome to modify the Skill itself to fit. Learning this logic of "using Skills to codify methodology and letting AI execute by rules" is more valuable than the resume itself — this approach can be reused for resume writing in any future project.

5. Strongly recommend including Skill-driven full-process development: My personal opinion is that the Skill-driven full-process development loop is suitable for anyone's resume. Skill is a very hot direction right now, already a must-ask topic in interviews, and many companies are internally researching how to use Skills to accelerate project construction. Explaining clearly how you used Skills to complete the entire closed loop from coding → testing → fixing → configuration → packaging is itself a relatively innovative and cutting-edge highlight that will impress interviewers. I'll also provide some examples later on how to talk about Skill-related content in interviews and how to answer follow-up questions.

❓ FAQ

1. How do I switch Providers (e.g., to Qwen / DeepSeek / Ollama)?

Very simple — just ask AI to do it for you.

The project uses a Factory Pattern in its architecture design, making Provider extension and switching very convenient. Once you understand the internal principles, you'll see that different APIs are essentially similar HTTP requests — most even follow OpenAI's request format — so switching is especially easy.

There are two specific ways to do it:

1. Use the Setup Skill (recommended): Run the one-click Setup Skill, and AI will proactively ask which Provider you want to use, guide you through entering your API Key, then automatically complete the code adaptation and configuration generation.

2. Just ask AI to change it directly: Tell AI which Provider you want to switch to (e.g., "help me switch to Qwen" or "configure DeepSeek for me"), and AI can automatically complete the code changes based on the factory pattern architecture.

How it works: The LLM, Embedding, Reranker and other modules under the project's src/libs/ directory all use the factory pattern. Adding a new Provider only requires: ① adding a new Provider class; ② registering it in the factory; ③ updating the settings.yaml configuration. AI can fully automate these steps.

2. The Custom Evaluator and Cross-Encoder Reranker parts

The framework code for these two modules is already in place but has not been fully tested. Those interested can complete them on their own:

AI can write all of this for you. Describe your requirements clearly, and AI can help you implement the evaluation methods, prepare the data, download the models, and complete integration testing. Completing these extensions is also a plus for interviews, demonstrating your ability to extend independently.

3. What if the project throws errors / has bugs?

This is not a production-grade project that has been widely tested — it's an interview-oriented hands-on project. Encountering errors is normal.

• Impact on interviews: Project bugs have almost no impact on interviews — interviewers won't actually run your project; they care about your understanding of the architecture, principles, and design decisions.

• How to fix: The simplest way is to paste the error message directly to AI — AI can fix the vast majority of issues.

• Reference resources: The Tina Huang video recommended in the notes also covers this method of using AI to quickly fix errors.

4. What if I want to ingest document formats other than PDF (Word / Markdown / HTML, etc.)?

Just ask AI to extend it for you.

The project's Loader layer uses a pluggable abstract design (BaseLoader), with the PDF Loader currently implemented by default. If you need to support other formats like Word, Markdown, or HTML, the overall architecture already has extension points designed in — just have AI add a corresponding Loader implementation.

For example, tell AI: "Add a Word document Loader for me, referencing the existing PDF Loader implementation" — AI can handle it completely.

5. How do I integrate it into AI tools (Copilot / Cursor / Claude Code, etc.)?

This project is an MCP Server that can be integrated into any AI tool and Agent supporting the MCP protocol. In my demo, I've integrated it into GitHub Copilot and Cursor, and you can equally integrate it into Claude Code or other tools supporting the MCP framework.

How to integrate? Very simple — ask AI.

Essentially, it's just writing an MCP configuration file for each tool:

• Copilot (VS Code): Just have AI generate the MCP configuration file

• Cursor: Import the project directly, and Cursor will recognize it automatically

• Claude Code / other frameworks: Ask AI how to configure it — each tool's configuration method is slightly different, but the principle is the same

Of course, I also recommend understanding the MCP protocol itself — how the Server and Client communicate, and how Tools are registered and invoked. These are also plus points in interviews.

6. General advice: make good use of AI

Most of the issues above (Provider switching, module extension, bug fixes, architecture understanding) AI can handle:

• 🔧 Code level: Have AI switch Providers, implement evaluation methods, and fix bugs for you

• 📖 Knowledge level: Architecture questions and design pattern questions can all be explained by asking AI

• 🚀 Extension level: If you want to add new features or adapt to new scenarios, describe your requirements clearly and let AI implement them

Ask AI more — let it guide you. This is also one of the core ideas this project aims to convey — learning to collaborate with AI in development.

📌 What's Next

✅ Will do

• Compilation of project-related questions and FAQ organization

• Compilation of high-frequency interview questions with reference answers

• Technical key-point explanations (RAG core knowledge, architecture design, etc.)

• Resume packaging suggestions and demonstrations

• Personal interview practice: I'll take this project to real interviews and summarize the questions I encounter and how I answered them into the documentation

• Contributions welcome: If you use this project in your interviews, you can send me the interview recording, and I'll help analyze project-related questions and write them into the documentation, while also listening for overall improvement suggestions. This way we can all improve together, collectively summarizing and refining this project's interview Q&A

❌ Will not do

• Will not continue extending new features

• Will not handle bug fixes, design optimizations, etc.

  • For bugs and design improvements, please fix and optimize them in your own project

  • Future extensions and fixes must be done by yourself — and with AI, these are all very easy to accomplish

  • This itself is a great learning opportunity and interview plus point

  • Independently extending based on understanding of the project is what truly demonstrates ability

📝 Personal plans

I'll be moving on to study large model algorithms and training, and will summarize some notes and ideas in my notes. Therefore, for this project, I won't endlessly extend features or fix bugs, but I'm very happy to continue doing:

• Summarizing the questions this project encounters in interviews

• Organizing ideas on how to answer and how to iterate and optimize

• Distilling interview Q&A into documentation for everyone's reference

📚 Companion Resources

This project comes with complete companion learning resources, including:

• 🎬 Video walkthroughs: Project architecture design, Skill usage, DEV_SPEC writing, full development process demos

• 📝 Interview notes: Large model interview preparation, RAG core knowledge points

• ❓ Interview question references: Real questions this project has encountered in interviews with reference answers

• 📖 Fundamentals compilation: High-frequency interview questions on large models / RAG / NLP

👉 Follow Xiaohongshu: 不转到大模型不改名 to access all the above resources.