Phần 9 — Kết Hợp Model Context Protocol (MCP) Và Hybrid RAG (2026)

📖 Bản tiếng Anh (English Edition)

← Chương trước: Phần 8 — Production PromptOps Pipeline (2026) | Mục lục Series

Answer-first: Kết hợp giao thức MCP và Hybrid RAG tạo thành hai đường cấp ngữ cảnh tối ưu: nạp schema công cụ động và truy xuất tài liệu 4 giai đoạn. Quy trình kết hợp tìm kiếm ngữ nghĩa dense, từ khóa sparse, tái xếp hạng cross-encoder và nén token trung thực bằng LLMLingua-2, giảm 60% chi phí token. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

1. Model Context Protocol (MCP) — nạp schema theo intent

Answer-first: System prompt nhồi hàng trăm tool definition vừa lãng phí ngân sách token vừa pha loãng self-attention — MCP tách tool khỏi prompt bằng JSON-RPC client-server, client dò intent runtime và chỉ inject schema liên quan. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

System prompt tĩnh nhúng hàng trăm tool definition làm hai hại cùng lúc: tốn ngân sách token chí mạng và pha loãng self-attention. Model Context Protocol (MCP) là chuẩn mở tách host agent runtime khỏi tool implementation bằng kiến trúc client-server JSON-RPC: client dò intent runtime, chỉ inject schema cần dùng đúng lúc.

Dưới đây là chuỗi discovery và execution giữa agent core, intent classifier và các MCP server:

flowchart TD
    Agent["Agent Client Engine"] -->|"1. User Intent Analysis"| Intent["Intent Classifier"]
    Intent -->|"2. Semantic Search"| MCPReg["MCP Server Registry"]
    MCPReg -->|"3. Return Tool Subset<br/>(≤ ngân sách 15%)"| Agent
    Agent -->|"4. Dynamic MCP Tool Injection"| LLM["LLM Context Stream"]
    LLM -->|"5. JSON-RPC Call"| MCPServer["MCP Server: Database / GitHub / Terminal"]

Tool schema truyền qua kênh JSON-RPC. Payload dưới đây là một MCP tool declaration điển hình với ràng buộc tham số:

{
  "name": "query_database_vector",
  "description": "Executes hybrid vector and keyword search over PostgreSQL pgvector store.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Search query text" },
      "top_k": { "type": "integer", "default": 5 }
    },
    "required": ["query"]
  }
}

Ba kỷ luật kinh tế tool từ bằng chứng Anthropic áp dụng tại điểm injection:

• Consolidate theo nghĩa: một schedule_event thay cho list_users + list_events + create_event — “too many tools or overlapping tools can also distract agents”
• Cap response + concise format: cap 25.000 token mặc định; enum response_format cho 206→72 token mỗi call
• Namespace theo dịch vụ: asana_search vs jira_search — agent chọn đúng tool, không đoán

Và mặt bảo mật của giao thức (không chỉ happy path): confused deputy qua static client IDs, cấm token passthrough, SSRF qua OAuth discovery trỏ internal IP, session hijacking qua shared queue — mỗi vector có mitigation ở mức spec (chi tiết đầy đủ ở Series: MCP Engineering In Production).

2. Đường ống Hybrid Retrieval 4 giai đoạn

Answer-first: RAG naive một lần cosine bỏ sót keyword chính xác (tên hàm, error code) và xếp chunk nhiễu lên cao — 4 giai đoạn đóng dần mỗi lỗ hổng: AST chunk giữ đơn vị logic, hybrid index phủ cả hai mode thất bại, cross-encoder lọc false positive, nén LLMLingua-2 giảm token giữ faithfulness. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

flowchart LR
    Doc["Code / Docs thô"] --> AST["1. AST Chunking<br/>(giữ ranh giới logic)"]
    AST --> Index["2. Hybrid Index<br/>Dense + Sparse"]
    Query["User Query"] --> Index
    Index -->|"Top 100 ứng viên"| Rerank["3. Cross-Encoder<br/>Re-ranker"]
    Rerank -->|"Top 5 snippets"| Comp["4. Nén LLMLingua-2<br/>2x–5x, faithful"]
    Comp --> Context["Context cuối<br/>vào prompt"]

Phân tích từng giai đoạn

1. AST & Structure-Aware Chunking: tách văn bản bằng parser ngôn ngữ (Tree-sitter cho code, structural Markdown parser) thay vì đếm ký tự tùy ý — giữ nguyên ranh giới logic như class, function, không cắt dở câu lệnh.
2. Hybrid Vector & Keyword Indexing: query chạy song song trên dense embedding (text-embedding-3-large) cho ý nghĩa ngữ nghĩa và sparse BM25/SPLADE cho keyword chính xác — hai mode thất bại của naive search được phủ bằng hai loại index.
3. Cross-Encoder Re-ranking: 50–100 ứng viên chấm lại qua cross-encoder sâu (bge-reranker-v2-m3 hoặc Cohere Rerank v3) — không như bi-encoder (encode độc lập rồi so cosine), cross-encoder tính joint attention trên cặp query-document, lọc false positive mà bi-encoder xếp cao.
4. Context Pruning & Token Compression: token dư thừa và boilerplate được nén bằng thuật toán giảm token. Số liệu kiểm chứng từ LLMLingua-2 (Pan et al., ACL 2024 Findings): mô hình nén nhỏ (XLM-RoBERTa-large/mBERT) học từ data distillation từ LLM, coi nén prompt là bài toán token classification “to guarantee the faithfulness of the compressed prompt to the original” — đạt compression ratio 2x–5x, nhanh hơn 3–6x các phương pháp nén trước đó, và giảm end-to-end latency 1.6x–2.9x.

Ghi chú hiệu chỉnh (Gate 7): bản cũ của chương này (và bản tiếng Anh) claim “cắt giảm 70% token” — không có nguồn sơ cấp nào cho con số đó. Số đã kiểm chứng là 2x–5x từ LLMLingua-2, và ratio là một dial xoay được với faithfulness là ràng buộc chất lượng — không phải hằng số.

3. Cài đặt Production: MCP Client & Re-Ranker

Answer-first: Pipeline production hợp nhất hai đường: lọc tool schema theo intent keyword, rerank chunk bằng cross-encoder, assemble thành XML blocks có provenance — code là ngôn ngữ trung tính, nguyên vẹn từ bản đặc tả tiếng Anh. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

import json
from typing import List, Dict, Any
from sentence_transformers import CrossEncoder

class MCPContextPipeline:
    def __init__(self, mcp_client, reranker_model_name: str = "BAAI/bge-reranker-v2-m3"):
        self.mcp_client = mcp_client
        self.reranker = CrossEncoder(reranker_model_name)

    def dynamic_tool_injection(self, user_query: str, available_mcp_tools: List[Dict[str, Any]]) -> str:
        """Lọc MCP tool schema theo intent keyword để tiết kiệm prompt token."""
        relevant_tools = []
        query_lower = user_query.lower()
        for tool in available_mcp_tools:
            keywords = tool.get("keywords", [])
            if any(kw in query_lower for kw in keywords):
                relevant_tools.append(tool["schema"])
        return json.dumps(relevant_tools, indent=2)

    def hybrid_rerank_context(self, query: str, candidate_chunks: List[str], top_k: int = 3) -> List[str]:
        """Cross-encoder joint attention scoring để re-rank chunk ứng viên."""
        if not candidate_chunks:
            return []
        pairs = [[query, chunk] for chunk in candidate_chunks]
        scores = self.reranker.predict(pairs)
        ranked_pairs = sorted(zip(scores, candidate_chunks), key=lambda x: x[0], reverse=True)
        return [chunk for _, chunk in ranked_pairs[:top_k]]

    def assemble_mcp_rag_context(self, query: str, raw_docs: List[str], tools: List[Dict[str, Any]]) -> str:
        """Assemble payload tối ưu token: tools + docs đã rerank, XML delimiters tách control/data."""
        injected_tools = self.dynamic_tool_injection(query, tools)
        reranked_docs = self.hybrid_rerank_context(query, raw_docs, top_k=3)

        context_blocks = []
        context_blocks.append(f"<active_mcp_tools>\n{injected_tools}\n</active_mcp_tools>")
        doc_str = "\n".join([f"<doc index='{idx}'>\n{doc}\n</doc>" for idx, doc in enumerate(reranked_docs, 1)])
        context_blocks.append(f"<retrieved_context>\n{doc_str}\n</retrieved_context>")

        return "\n\n".join(context_blocks)

Ba ghi chú trung thực về code này:

• Filter injection là substring matching — không xử lý paraphrase, không hiểu phủ định (“đừng dùng tool database”) — đây là hạn chế đã biết; nâng cấp lên intent classifier thật nằm ở series MCP.
• top_k=3 là dial ngân sách — ánh xạ trực tiếp vào dòng 40% RAG của bảng phân bổ bên dưới, không phải hằng số magic.
• Pipeline cần golden set riêng — retrieval precision và injection precision là metric eval được; kỷ luật Phần 4 áp dụng cho chính hệ truy xuất.

4. Phân bổ ngân sách token cho context động

Answer-first: 128,000 token chia theo 6 dòng chức năng với upper bound cứng — RAG chiếm dòng lớn nhất (40%) và chính là thứ 4 giai đoạn phải nhét vừa; nén là cách nhét thêm tín hiệu mỗi token. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

+-----------------------------------------------------------------------------------+
|                        TỔNG NGÂN SÁCH TOKEN (128,000 Tokens)                      |
+-----------------------------------------------------------------------------------+
| System & Role Identity  | Guardrail Policies  | Dynamic MCP Tools | Dynamic RAG    |
| (Static - KV Cache)     | (Static - KV Cache) | (On-Demand Schema)| (Cross-Ranked) |
| [5% ~ 6.4k Tokens]      | [10% ~ 12.8k]       | [15% ~ 19.2k]     | [40% ~ 51.2k] |
+-------------------------+---------------------+-------------------+----------------+
| Conversation History & Memory Compaction | Active User Query & Output Schema       |
| (Sliding Window + Summarized Memory)    | (Un-cached Payload)                       |
| [20% ~ 25.6k Tokens]                     | [10% ~ 12.8k Tokens]                      |
+------------------------------------------+----------------------------------------+

(Phần trăm là thiết kế tham khảo của series, không phải số vendor — hiệu chỉnh theo workload.)

Nếu bạn làm kế toán, hãy đọc chương này theo bộ quen thuộc:

• MCP = biểu mẫu liên phòng ban: mỗi phòng tự điền phần của mình theo chuẩn chung — agent chỉ “lấy đúng biểu mẫu” của intent hiện tại
• Hybrid RAG + rerank = rút hồ sơ rồi đối soát chéo: first-pass recall là ghi sổ, cross-encoder rerank là xác minh trước khi lên bàn — không hồ sơ nào lên bàn chưa đối
• Nén 2x–5x = tóm tắt hồ sơ giữ nguyên số liệu gốc: LLMLingua-2 không cắt thông tin — nó học từ LLM cái gì là “số liệu gốc” (token classification bảo đảm faithfulness)
• Ngân sách 128k = materiality: không phải mọi tài liệu vào báo cáo, chỉ phần trọng yếu — và phần trăm phân bổ là thiết kế tham khảo, hiệu chỉnh theo workload thực tế của bạn

Production failure: index stale và filter “thông minh”

Answer-first: Hai mode thất bại của pipeline truy xuất: index stale (tài liệu nguồn đổi, index giữ bản cũ — output nhại nội dung lỗi thời) và filter keyword quá rộng (mọi query “database” kéo cả 20 tool schema vào — ngân sách 15% nổ, RAG bị ép cục bộ còn lại). Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

Scenario 1 — index stale: chatbot nội bộ trả lời theo quy trình cũ đã bị thay thế 2 tháng trước. Root cause: index chưa re-index sau khi tài liệu nguồn đổi; hoặc tệ hơn, không ai biết index cũ bao nhiêu ngày tuổi. Bài học: pipeline truy xuất cần kỷ luật eval y như Phần 8 — re-index theo cadence, và metadata mỗi chunk mang ngày index.

Scenario 2 — filter quá rộng: keyword “query” khớp 8/20 tool, mỗi schema ~800 token — injection chiếm 6.4k token thay vì 1.9k dự kiến, RAG bị ép cục bộ. Bài học: đo injection precision trong golden set của pipeline; filter nên theo intent + scope, không theo substring.

Và ghi chú cuối về failure containment: pipeline fail thì degrade có kiểm soát — không tool được inject (agent hỏi lại), không doc truy xuất được (agent nói rõ thiếu context) — không bao giờ fabricate; Fallback block của Phần 2 kéo dài đến tận assembly.

Ý chính cần nhớ

Answer-first: MCP và hybrid RAG là hai đường cấp của context budget — schema theo intent, tài liệu theo relevance, cả hai dưới ngân sách, cả hai có security và fallback; nén 2x–5x đã kiểm chứng là cách nhét thêm tín hiệu vào mỗi token. Điều kiện tiên quyết: Hiểu giao thức JSON-RPC 2.0 / SSE của MCP, thuật toán Reciprocal Rank Fusion (RRF), và mô hình nén LLMLingua-2.

Ba con số mang đi (đều có nguồn):

• 2x–5x — compression ratio của LLMLingua-2, với faithfulness làm ràng buộc (ACL 2024)
• 25.000 — token cap mặc định cho tool response (Claude Code)
• 15% / 40% — hai dòng ngân sách mà hai đường cấp này phải nhét vừa trong cửa sổ 128k

Hai đường này là deep-dive hạ tầng của Phần 6 — trụ cột MCP và trụ cột RAG giờ có số liệu, security model, và code production đứng sau.

Đây là chương cuối của series. Quay lại Mục lục Series cho toàn bộ lộ trình — hoặc đọc bản tiếng Anh của chương này cho góc độ enterprise: MCP and Hybrid RAG.

🔗 Đọc thêm các chuyên đề liên quan:

• Phần 6 — Từ Prompting sang Context Engineering (2026) — trụ cột mà chương này đào sâu
• Phần 8 — Production PromptOps Pipeline (2026) — eval pipeline truy xuất cũng như eval prompt
• Series: MCP Engineering In Production — hạ tầng MCP chuẩn doanh nghiệp
• Series: Enterprise AI Data Pipeline & GraphRAG Architecture
• Xây dựng Custom Vector Database Engine trong Go

❓ Câu Hỏi Thường Gặp (FAQ)

📚 Nguồn nghiên cứu (verification anchors)

Bản nghiên cứu đầy đủ (dossier kép Ch9+Ch10): reports/research-prompt-standard-part-8-part-9-final-100-rounds.{md,json} (mirror cả 2 repo). Ghi chú grounding Ch10: 55% external / 41% series-internal / 4% labeled. Ghi chú hiệu chỉnh (Gate 7): claim “cắt giảm 70% token” ở bản cũ đã được thay bằng 2x–5x đã kiểm chứng — không có nguồn sơ cấp nào cho 70%. Ghi chú phiên bản: các con số LLMLingua-2 (2x–5x, 3–6x, 1.6–2.9x) là phép đo của bài báo ACL 2024 trên MeetingBank, LongBench, ZeroScrolls, GSM8K, BBH với các model thời 2024 — trích như kết quả đo của paper, không phải cam kết cho mọi model hiện hành; reranker và embedding nêu theo tên (bge-reranker-v2-m3, Cohere Rerank v3, text-embedding-3-large) là lựa chọn tham khảo của series, thay thế tương đương được khi eval trên golden set của bạn chứng minh.

← Chương trước: Phần 8 — Production PromptOps Pipeline (2026) | Mục lục Series