理解MCP

April 13, 2025

前置：LLMs 接口抽象

interface Message {
    role: "system" | "user" | "assistant";
    content: string;
}

interface Context {
    messages: Message[];
}

declare function chatCompletion(context: Context): string;

理解 RAG

RAG 和 Function Call 都是（在无需重新训练模型的情况下）实现 Agent (智能体) 的方式。

由于 LLM 主要依赖其训练数据来生成回答。这会导致：

知识截止 (Knowledge Cutoff): LLM 的知识停留在其训练数据最后更新的时间点，无法了解最新事件或信息。
幻觉 (Hallucination): LLM 可能编造听起来合理但实际上错误的信息，尤其是在其知识库之外或不确定的领域。
领域特定知识缺乏: 对于非常专业或私有的领域（如公司内部文档），通用 LLM 缺乏深入了解。
缺乏溯源性: LLM 通常不会说明信息来源，难以核实。
等等问题。

RAG（Retrieval-Augmented Generation）做的工作显然是通过知识库（Knowledge Base）插入额外的上下文。它做的工作可以抽象为：

// 通过知识库，增强给定上下文
declare function rag(db: Database, context: Context): Context;

interface Database {
    // ?
}

问题其实在于 RAG 是如何插入文本的？关键字是向量嵌入 (Vector Embeddings) 。

将文本转换为向量，这就将文本相似度问题转换为向量相似度问题。
根据下面的演示代码可以发现，关键的文本转换为向量这一过程也是由 LLM 完成的。

import OpenAI from "openai";
const openai = new OpenAI();
const EMBEDDING_MODEL = "text-embedding-3-small"; // 选择嵌入模型
const KNOWLEDGE_BASE = [
    "RAG（Retrieval-Augmented Generation）结合了检索系统和生成模型，以提高回答的准确性和时效性。",
    "微调（Fine-tuning）是指在一个预训练模型的基础上，使用特定任务的数据继续训练模型，使其更适应特定领域。",
    "向量数据库（Vector Database）专门用于存储和高效查询高维向量数据，常用于相似性搜索。",
    "在RAG流程中，首先根据用户查询从知识库检索相关文档片段，然后将这些片段作为上下文提供给LLM生成最终答案。",
    "与微调相比，RAG的主要优势在于能够轻松更新知识库以反映最新信息，且无需重新训练大模型。",
    "常见的向量相似度计算方法包括余弦相似度、点积和欧氏距离。",
];
const TOP_K = 2; // 我们想要检索的最相关的 K 个文档块

// 计算余弦相似度
function cosineSimilarity(vecA: number[], vecB: number[]) {
    let dotProduct = 0;
    let magnitudeA = 0;
    let magnitudeB = 0;
    for (let i = 0; i < vecA.length; i++) {
        dotProduct += vecA[i] * vecB[i];
        magnitudeA += vecA[i] * vecA[i];
        magnitudeB += vecB[i] * vecB[i];
    }
    magnitudeA = Math.sqrt(magnitudeA);
    magnitudeB = Math.sqrt(magnitudeB);
    if (magnitudeA === 0 || magnitudeB === 0) return 0;
    else return dotProduct / (magnitudeA * magnitudeB);
}

// 获取文本嵌入
async function getEmbedding(text: string) {
    const response = await openai.embeddings.create({
        model: EMBEDDING_MODEL,
        input: text,
    });
    return response.data[0].embedding;
}

async function ragExample(userQuery: string) {
    // 在实际应用中，这一步通常是预处理并存储在向量数据库中
    const knowledgeBaseEmbeddings = await Promise.all(
        KNOWLEDGE_BASE.map(async (text) => {
            const embedding = await getEmbedding(text); // 生成嵌入向量
            return { text, embedding };
        }),
    );

    const userQuery = "RAG 和微调有什么不同？";
    const queryEmbedding = await getEmbedding(userQuery);

    //  计算查询向量与知识库向量的相似度
    const similarities = knowledgeBaseEmbeddings.map((kbItem) => ({
        text: kbItem.text,
        similarity: cosineSimilarity(queryEmbedding, kbItem.embedding),
    }));

    // 按相似度降序排序
    similarities.sort((a, b) => b.similarity - a.similarity);

    // 获取 Top-K 结果
    const relevantChunks = similarities.slice(0, TOP_K);

    // 返回最相关的文档片段
    return relevantChunks.map((item) => item.text).join("\n");
}

生产环境下往往可以考虑使用向量数据库优化索引和检索。这些基础设施不在本文考虑的范围之内。

理解 Function Calling

Function Calling 允许 LLM 调用外部函数。这使得 LLM 不仅可以生成文本，还可以与外部世界交互，执行特定任务。

可以抽象为：

interface FunctionDefinition {
    name: string;
    description: string;
    parameters: {
        type: "object";
        properties: { [name: string]: ParameterDefinition };
        required: string[];
    };
}

interface ParameterDefinition {
    type: "string" | "number" | "boolean" | "array" | "object";
    description: string;
    enum?: string[];
}

interface FunctionCallContext extends Context {
    availableFunctions?: { [name: string]: (...args: any[]) => any };
    type?: "function";
    function_call?: {
        name: string;
        arguments: string; // JSON string
    };
}

declare function chatCompletionWithFunctionCall(context: FunctionCallContext): FunctionCallContext;

OpenAI 的 Function calling 机制很显然需要 LLM 的 API 支持。

import { OpenAI } from "openai";

const openai = new OpenAI();
const model = "gpt-4.1";

const tools = [
    {
        type: "function",
        function: {
            name: getWeather.name,
            description: "Get current temperature for provided coordinates in celsius.",
            parameters: {
                type: "object",
                properties: {
                    latitude: { type: "number" },
                    longitude: { type: "number" },
                },
                required: ["latitude", "longitude"],
                additionalProperties: false,
            },
            strict: true,
        },
    },
];

async function getWeather(latitude: number, longitude: number) {
    const response = await fetch(
        `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m`,
    );
    const data = await response.json();
    return data.current.temperature_2m;
}

const messages = [
    {
        role: "user",
        content: "What's the weather like in Paris today?",
    },
];

const completion = await openai.chat.completions.create({
    model,
    messages,
    tools,
    store: true,
});
messages.push(completion.choices[0].message);

const toolCall = completion.choices[0].message.tool_calls[0];
/*{
    "id": "call_12345xyz",
    "type": "function",
    "function": {
      "name": "getWeather",
      "arguments": "{\"latitude\":48.8566,\"longitude\":2.3522}"
    }
}*/
const args = JSON.parse(toolCall.function.arguments);
const result = await getWeather(args.latitude, args.longitude);
messages.push({
    role: "tool",
    tool_call_id: toolCall.id,
    content: result.toString(),
});

const completion2 = await openai.chat.completions.create({
    model,
    messages,
    tools,
    store: true,
});

console.log(completion2.choices[0].message.content);
// -> "The current temperature in Paris is 14°C (57.2°F)."