LLM 工具调用面试专题

工具调用是 Agent 从"嘴上说说"到"动手做事"的关键能力。主线：Function Calling 原理 → MCP 标准化 → Skill/A2A 生态 → 通信协议选型 → 网关工程化。

Q1: 什么是 Function Calling？原理是什么？「🟢 校招/初级」

考察点：Function Calling 的基本概念和工作原理。

参考答案：

Function Calling 是让大模型能够识别用户意图，选择合适的预定义函数（工具），并生成结构化的调用参数，由外部代码执行后把结果返回给模型继续推理。

核心原理：

1. 开发者预定义工具（函数签名 + 描述）
2. 用户提问 → LLM 判断是否需要调用工具
3. LLM 生成结构化调用（不是执行！）
4. 外部代码执行函数，拿到结果
5. 结果回传给 LLM → 生成最终回答

python

import openai, json

# 1. 定义工具
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "查询指定城市的天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名"},
                "date": {"type": "string", "description": "日期"}
            },
            "required": ["city"]
        }
    }
}]

# 2. 第一次调用：LLM 决定调用哪个工具
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "北京明天天气怎么样？"}],
    tools=tools
)

# 3. LLM 返回工具调用请求（不执行，只生成调用参数）
tool_call = response.choices[0].message.tool_calls[0]

# 4. 开发者执行函数
args = json.loads(tool_call.function.arguments)
result = get_weather(**args)

# 5. 结果回传，LLM 生成最终回答
final = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "北京明天天气怎么样？"},
        response.choices[0].message,
        {"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)}
    ]
)

关键点：LLM 不直接执行函数，只输出"调用意图"和"参数"；实际执行由外部代码完成；结果回传后 LLM 可继续多轮推理。

追问延伸：

如果 LLM 生成的参数格式不对怎么办？（参数校验 + 错误回传让 LLM 修正）
一个请求可以同时调用多个函数吗？（可以，Parallel Function Calling）

Q2: LLM 是如何学会调用外部工具的？「🟡 中级」

考察点：理解 LLM 工具调用能力的训练过程。

参考答案：

LLM 学会工具调用是一个从预训练到后训练的全链路过程：

预训练阶段: 学习代码、API 文档、JSON 格式（GitHub 代码 + 技术文档）
    ↓
SFT 阶段: 学习工具调用的基本模式（输入：问题+工具描述 → 输出：工具调用 JSON）
    ↓
RLHF 阶段: 优化工具选择和参数质量（奖励：选对工具+参数正确+结果有用）
    ↓
能力对齐: 支持标准化的工具调用格式（OpenAI: tool_call, Anthropic: tool_use）

SFT 数据构造示例：

json

{
  "messages": [
    {"role": "user", "content": "帮我查一下上海到北京的航班"},
    {"role": "assistant", "tool_calls": [
      {"name": "search_flights", "arguments": {"from": "上海", "to": "北京", "date": "2024-01-15"}}
    ]},
    {"role": "tool", "content": "{\"flights\": [{\"flight\": \"MU5101\", \"time\": \"08:00\"}]}"},
    {"role": "assistant", "content": "为您找到航班 MU5101，08:00 起飞，上海→北京。"}
  ]
}

追问延伸：

没有微调过的开源模型能做 Function Calling 吗？（可以，通过 Prompt Engineering 模拟，但效果差）
如何评估模型的工具调用能力？（Berkeley Function-Calling Leaderboard, BFCL）

Q3: 大模型的 Function Call 能力是怎么训练出来的？「🔴 高级」

考察点：深入理解 FunctionCalling 训练的技术细节。

参考答案：

1. SFT 阶段：指令跟随 + 工具调用格式

训练目标：让模型学会"看到工具描述 → 输出正确调用格式"

数据增强策略：工具描述改写（提高泛化）、参数变体（参数鲁棒性）、多工具选择（工具选择能力）、负样本（避免过度调用）、多轮调用（复杂任务处理）。

2. RLHF 阶段：优化调用质量

python

def compute_reward(trajectory):
    reward = 0
    if selected_tool == correct_tool: reward += 0.3        # 工具选择正确
    if all_required_params_present: reward += 0.2           # 参数完整性
    if param_values_reasonable: reward += 0.2               # 参数值正确
    if call_timing_correct: reward += 0.2                   # 调用时机
    if final_answer_helpful: reward += 0.1                  # 回答质量
    return reward

3. 特殊能力训练

Parallel Function Calling：一次性并行调用多个独立工具
Nested Function Calling：工具 A 的结果作为工具 B 的参数
Error Recovery：工具调用失败后自动修正重试
Tool Selection from Large Pool：从数百个工具中选择正确的（RAG 辅助）

追问延伸：

为什么有些模型支持 Function Calling 但不支持 MCP？（MCP 需要额外的协议层适配）
如何提高从大量工具中选择的准确率？（工具检索 + 分层选择）

Q4: 什么是 MCP（模型上下文协议）？讲讲它的核心内容？「🟡 中级」

考察点：MCP 协议的基本概念和核心设计。

参考答案：

MCP（Model Context Protocol，模型上下文协议） 是 Anthropic 于 2024 年 11 月开源的开放协议，旨在标准化大模型应用与外部数据源/工具之间的连接方式。

核心理念：像 USB-C 统一了硬件接口一样，MCP 统一了 AI 应用与外部资源的接口。

┌──────────┐     MCP Protocol     ┌──────────┐
│  MCP     │ ◄──────────────────► │  MCP     │
│  Client  │   JSON-RPC 2.0       │  Server  │
│ (宿主端)  │   stdio / SSE       │ (工具端)  │
└────┬─────┘                      └────┬─────┘
     │                                 │
│ LLM 应用  │                    │ 外部资源   │
│ (Claude   │                    │ - 数据库   │
│  Cursor   │                    │ - 文件系统  │
│  等)      │                    │ - API     │
└──────────┘                    │ - Git     │
                                └──────────┘

三大核心能力：

能力	说明	示例
Resources	暴露只读数据源	文件内容、数据库记录、API 返回
Tools	暴露可执行的操作	执行 SQL、调用 API、操作文件
Prompts	暴露预设的提示词模板	代码审查模板、文档生成模板

python

from mcp.server import Server
from mcp.types import Tool, TextContent

server = Server("my-tools")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [Tool(
        name="search_docs",
        description="搜索文档库",
        inputSchema={
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    )]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "search_docs":
        result = search(arguments["query"])
        return [TextContent(type="text", text=result)]

追问延伸：

MCP 和 OpenAI 的 Plugin 机制有什么区别？（Plugin 是平台绑定的，MCP 是开放协议）
MCP 如何做权限管理？（客户端控制工具可见性和调用权限）

Q5: MCP 由哪几部分组成？「🟡 中级」

考察点：MCP 协议的组件构成和交互关系。

参考答案：

MCP 采用客户端-服务端架构：

组件	职责	说明
MCP Host	宿主应用	Claude Desktop、Cursor IDE、自定义 Agent 应用
MCP Client	协议客户端	嵌入在 Host 中，每个对应一个 Server 连接
MCP Server	工具/数据提供方	独立进程，暴露 Resources/Tools/Prompts
Transport	通信层	stdio（本地）或 SSE/HTTP（远程）
Protocol	消息格式	JSON-RPC 2.0

交互流程：

1. 启动: Host → Client → 连接 Server → initialize → 发现工具 tools/list
2. 调用: 用户提问 → LLM 判断需要工具 → tools/call(name, arguments) → 结果回传
3. 资源: resources/list → resources/read(uri) → 返回数据

Server 能力声明：

json

{
  "protocolVersion": "2024-11-05",
  "capabilities": {
    "tools": {"listChanged": true},
    "resources": {"subscribe": true, "listChanged": true},
    "prompts": {"listChanged": true}
  },
  "serverInfo": {"name": "my-mcp-server", "version": "1.0.0"}
}

追问延伸：

一个 Host 可以连接多少个 MCP Server？（没有硬性限制，实践中通常 5-20 个）
MCP Server 之间可以互相调用吗？（协议本身不支持，但可以在 Host 层编排）

Q6: MCP 和 Function Calling 有什么区别？有没有实际跑过 MCP？「🟡 中级」

考察点：MCP 和 Function Calling 的对比及实践经验。

参考答案：

维度	Function Calling	MCP
本质	LLM 的一种输出能力	连接 LLM 与外部工具的标准化协议
层级	模型层（模型生成调用意图）	协议层（标准化工具发现和调用）
工具定义	每次请求手动传入 tools 数组	Server 自带工具，自动发现
工具执行	开发者自己实现调用逻辑	Server 端实现，协议标准化
耦合度	工具与应用紧耦合	工具与应用解耦，一次开发处处可用
生态	各厂商各自实现	开放协议，社区共享

关系：Function Calling 是"大脑决策"，MCP 是"标准化执行通道"，两者可以配合使用。

实际跑 MCP 示例：

json

// Claude Desktop 配置（claude_desktop_config.json）
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {"GITHUB_TOKEN": "ghp_xxx"}
    }
  }
}

实际对话效果：用户问"帮我看看当前目录有哪些文件" → Claude 调用 filesystem MCP Server 的 list_directory 工具 → 返回文件列表 → 生成回答。

追问延伸：

MCP 能替代 Function Calling 吗？（不能，MCP 是传输和发现层，决策仍依赖模型能力）
MCP 目前支持哪些语言 SDK？（Python、TypeScript/JavaScript、Go、Java、Rust）

Q7: Function Calling 也属于工具调用，请问什么场景下使用 Function Calling，什么场景下使用 MCP？「🟡 中级」

考察点：工具调用方案选型能力。

参考答案：

选型决策：

场景	推荐	原因
固定 3-5 个工具的聊天机器人	Function Calling	简单直接，无需额外基础设施
IDE 集成多种开发工具	MCP	标准化发现机制，Server 可独立维护
多个 AI 应用共享工具生态	MCP	一次开发处处可用
需要有状态的工具调用	MCP	MCP 支持有状态会话
工具安全性要求高	MCP	权限控制、工具可见性管理
快速原型验证/Demo	Function Calling	最快上手，无额外部署成本
生产环境数据访问	MCP	权限管理更完善

python

# 场景1：Function Calling 适用 - 固定工具 + 简单流程
tools = [get_weather, send_sms, create_calendar_event]  # 3个固定工具

# 场景2：MCP 适用 - 工具数量多、动态变化、多应用共享
# Cursor IDE 需要访问：文件系统、Git、数据库、Slack、GitHub...
# → 用 MCP，每个 Server 独立维护

追问延伸：

两者能否结合使用？（可以，MCP 发现工具后转换为 Function Calling 格式传给 LLM）
MCP 在企业落地的主要障碍是什么？（安全审计、权限管理、运维成本）

Q8: 为什么有些特定的推理模型不支持 MCP 协议？「🔴 高级」

考察点：理解模型架构与工具调用能力的关系。

参考答案：

核心原因：推理模型和工具调用模型的设计目标不同。

原因	说明
训练数据不包含工具调用	推理模型的 RL 训练专注于数学/逻辑推理，没有工具调用样本
输出格式不兼容	推理模型输出 `<think>...</think>` + 答案，没有 tool_call 格式
RL 奖励函数不含工具调用	奖励只看推理正确性，不奖励工具选择
思维链与工具调用冲突	推理模型的长思维链中插入工具调用会打断推理流

推理模型 vs 对话模型：

维度	推理模型（o1, R1）	对话模型（GPT-4o, Claude 3.5）
设计目标	复杂推理（数学/代码/逻辑）	对话交互 + 工具调用
训练方式	RL（推理链 + 答案匹配）	SFT + RLHF + 工具微调
输出格式	思维链 + 最终答案	消息 + 工具调用 + 回答
工具调用	不原生支持	原生支持

变通方案：用规则/小模型做意图识别 → 调用 MCP → 结果拼接 → 推理模型做最终推理。或用对话模型做 Agent，推理模型做复杂推理子任务。

追问延伸：

推理模型未来会支持工具调用吗？（趋势上会，OpenAI 已在 o1 后续版本逐步支持）
如何在推理模型的思维链中嵌入工具调用？（研究热点，如 ToolFormer 思路）

Q9: Skill 是什么？「🟢 校招/初级」

考察点：理解 AI Agent 中 Skill 的概念。

参考答案：

Skill 是 AI Agent 系统中封装了特定领域能力的可复用模块，包含提示词模板、工具集、知识库和执行流程的定义。

Skill vs Tool 的区别：

维度	Tool（工具）	Skill（技能）
粒度	单个函数/API	一组能力的封装
包含	只有函数签名+执行	提示词+工具+知识+流程
智能	无智能，被动执行	有推理能力，主动决策
示例	`get_weather(city)`	"天气分析技能"（含查询+解读+建议）

yaml

# Skill 定义示例：代码审查技能
name: code_review
description: 对代码进行自动化审查，发现潜在问题
prompt: |
  你是一个资深代码审查专家。请审查以下代码：
  语言：{language}
  代码：{code}
  审查维度：代码风格、潜在Bug、安全漏洞、性能、可维护性
tools: [lint_checker, security_scanner, complexity_analyzer]
knowledge: [coding_standards.md, security_checklist.md]
workflow: [静态分析, 安全扫描, AI审查, 汇总报告]

追问延伸：

Skill 和 Plugin 有什么区别？（Plugin 更重需安装；Skill 更轻量，通常是配置+提示词）
如何设计可组合的 Skill 体系？（标准化接口 + 依赖注入 + 事件驱动）

Q10: MCP 和 Agent Skill 的区别是什么？「🟡 中级」

考察点：MCP 和 Skill 的定位差异。

参考答案：

维度	MCP	Agent Skill
定位	通信协议（怎么连）	能力封装（做什么）
层级	基础设施层	应用层
内容	工具发现+调用+资源访问	提示词+工具+知识+流程
智能	无智能，纯协议	有 AI 推理和决策
粒度	单个工具/资源	一组完整能力
类比	USB-C 接口	一个 App

关系：Skill 可以通过 MCP 来发现和调用工具，MCP 是 Skill 内部获取工具能力的通道之一。两者是互补关系，不是替代关系。

python

class CodeReviewSkill:
    def __init__(self, mcp_client):
        self.prompt = "你是代码审查专家..."
        self.knowledge = load_knowledge("coding_standards.md")
        self.mcp_client = mcp_client  # 通过 MCP 获取工具

    async def execute(self, code, language):
        tools = await self.mcp_client.list_tools()          # MCP 发现工具
        lint_result = await self.mcp_client.call_tool("lint_checker", {"code": code})
        security_result = await self.mcp_client.call_tool("security_scanner", {"code": code})
        review = await llm.generate(self.prompt, context=[lint_result, security_result])
        return review

追问延伸：

没有 MCP 能不能用 Skill？（可以，Skill 可以直接调用 Function Calling 工具）
一个 Skill 可以连接多个 MCP Server 吗？（可以，Skill 可以聚合多个 MCP 工具）

Q11: Function Calling、Skill、MCP 这三个有什么区别？「🟡 中级」

考察点：三个概念的综合对比和关系理解。

参考答案：

维度	Function Calling	MCP	Skill
层级	模型层	协议层	应用层
本质	LLM 的输出能力	工具连接标准	能力封装
做什么	生成工具调用意图	标准化工具发现和调用	编排完整业务流程
谁实现	模型厂商	协议规范 + Server/Client	应用开发者
粒度	单次调用	工具级	任务级
智能	有（模型决策）	无（纯协议）	有（LLM+流程编排）
类比	手指按键	USB 接口	一个完整软件

关系：Function Calling 被 MCP 调用，MCP 被 Skill 使用，Skill 包含 MCP 和 FC。

python

# 完整 Agent 场景："分析 GitHub 仓库代码质量"
# 1. Skill 层：定义"代码分析"技能（prompt + workflow）
# 2. MCP 层：通过 MCP Server 获取工具（GitHub MCP, Linter MCP, Security MCP）
# 3. Function Calling 层：LLM 决定调用哪个工具、参数是什么

追问延伸：

如果只用 Function Calling 不用 MCP 可以吗？（可以，但工具多了维护成本高）
如果只用 MCP 不用 Skill 可以吗？（可以做简单 Agent，复杂场景缺少流程编排）

Q12: 什么是 A2A 协议？它和 MCP 协议的区别是什么？「🔴 高级」

考察点：了解 A2A（Agent-to-Agent）协议及与 MCP 的区别。

参考答案：

A2A（Agent-to-Agent Protocol） 是 Google 于 2025 年提出的开放协议，旨在标准化不同 AI Agent 之间的通信和协作。

维度	MCP	A2A
通信双方	Agent ↔ 工具/资源	Agent ↔ Agent
关系	主从（Agent 调用工具）	对等（Agent 之间协作）
核心概念	Tools, Resources, Prompts	Tasks, Agents, Delegation
提出者	Anthropic	Google
场景	Agent 使用外部能力	多 Agent 分工协作

json

// A2A 的 Agent Card（能力名片）
{
  "name": "Research Agent",
  "description": "擅长信息检索和分析",
  "capabilities": {"tasks": ["research", "summarize", "translate"]},
  "endpoints": {"tasks/send": "https://agent-a.example.com/tasks/send"}
}

// A2A 任务委托
POST /tasks/send
{"task": "搜索并总结2024年AI Agent领域的重要论文"}

两者配合使用：A2A 负责 Agent 之间委托任务，MCP 负责每个 Agent 内部调用工具。

编排Agent ─A2A→ 检索Agent ─A2A→ 分析Agent
               │MCP              │MCP
          搜索工具/文件工具   文档工具/图表工具

追问延伸：

A2A 如何处理 Agent 之间的信任问题？（Agent Card + 签名验证 + 权限授权）
A2A 和 FIPA ACL（经典多智能体通信语言）有什么关系？（A2A 是现代版，面向 LLM Agent 重新设计）

Q13: MCP 协议通常采用什么通信方式？「🟢 校招/初级」

考察点：MCP 的通信传输方式。

参考答案：

MCP 协议支持三种主要通信方式：

方式	场景	延迟	特点
stdio	本地 IDE 工具	极低	Client 启动 Server 作为子进程，通过 stdin/stdout 通信
SSE	远程服务	中	HTTP 长连接，Server-Sent Events 推送
Streamable HTTP	通用（2025年新增）	中	兼容性好、支持流式、可穿防火墙

所有方式都使用 JSON-RPC 2.0 作为消息格式。

python

# stdio 方式
import subprocess, json

server = subprocess.Popen(
    ["npx", "@modelcontextprotocol/server-filesystem", "/data"],
    stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True
)

# 发送 JSON-RPC 请求
request = {"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}
server.stdin.write(json.dumps(request) + "\n")
server.stdin.flush()

# 读取响应
response = json.loads(server.stdout.readline())

追问延伸：

stdio 方式如何处理 Server 崩溃？（Client 检测进程退出 → 重启 → 重连）
SSE 方式如何做认证？（URL 参数 token 或 Authorization Header）

Q14: 说说 WebSocket 和 SSE 通信的区别及局限性？「🟡 中级」

考察点：WebSocket 和 SSE 的对比及在 AI 场景中的应用。

参考答案：

维度	WebSocket	SSE
通信方向	双向（全双工）	单向（Server → Client）
底层协议	TCP（独立协议）	HTTP（长连接）
数据格式	文本 + 二进制	纯文本（UTF-8）
重连机制	需手动实现	浏览器自动重连
代理/防火墙	可能被拦截	兼容 HTTP 基础设施
最大连接数	同域约 200	同域约 6
适用场景	聊天室、游戏、实时协作	消息推送、AI 流式输出

局限性：

WebSocket：需额外握手延迟、被部分代理/防火墙拦截、连接管理复杂、CDN 不缓存、调试困难
SSE：单向通信、纯文本、浏览器连接数限制（同域 6 个）、不支持 POST、代理可能缓冲

AI 场景选择：

python

# 场景1：AI 流式输出 → SSE 更合适（输出是单向的）
@app.get("/chat")
def chat():
    def stream():
        for token in llm.stream(user_input):
            yield f"data: {json.dumps({'token': token})}\n\n"
    return StreamingResponse(stream(), media_type="text/event-stream")

# 场景2：实时语音对话 → WebSocket 更合适（双向音频流）
@app.websocket("/voice")
async def voice_chat(websocket):
    await websocket.accept()
    while True:
        audio_data = await websocket.receive_bytes()  # 二进制
        response_audio = process_voice(audio_data)
        await websocket.send_bytes(response_audio)     # 双向

追问延伸：

为什么 OpenAI 的 Streaming API 用 SSE 而不是 WebSocket？（SSE 更简单、兼容 HTTP 基础设施、AI 输出是单向的）
WebSocket 如何做断线重连？（指数退避 + 状态恢复）

Q15: 为什么要用 WebRTC 协议？它和 WebSocket 在 AI 对话流中的核心差异是什么？「🔴 高级」

考察点：理解 WebRTC 在实时 AI 对话中的价值。

参考答案：

为什么需要 WebRTC：人类对话延迟感知 <200ms 才自然，而 WebSocket 方案总延迟约 1350ms，WebRTC 方案可达约 250ms。

维度	WebSocket	WebRTC
设计目标	应用层消息传输	实时音视频通信
传输层	TCP	UDP（SRTP/DTLS）
延迟	较高（TCP 确认）	极低（UDP 无等待）
数据类型	文本/二进制消息	音频/视频流
编解码	不涉及	内置音频编解码（Opus）
NAT 穿透	不支持	ICE/STUN/TURN
P2P	必须经服务器	支持 P2P 直连

延迟对比：

WebSocket 方案（约 1350ms）:
采集20ms → 编码10ms → TCP发送50ms → ASR等完整句500ms → LLM推理500ms
→ TTS合成200ms → TCP发送50ms → 播放20ms

WebRTC 方案（约 250ms）:
采集20ms → RTP发送5ms → 流式ASR 50ms → 流式LLM 100ms → 流式TTS 50ms
→ RTP发送5ms → 播放20ms

javascript

// WebRTC AI 对话示例（浏览器端）
const pc = new RTCPeerConnection();
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
stream.getTracks().forEach(track => pc.addTrack(track, stream));
pc.ontrack = (e) => { audioElement.srcObject = e.streams[0]; audioElement.play(); };

追问延伸：

WebRTC 在弱网环境下如何保证音频质量？（FEC 前向纠错、自适应码率、丢包补偿）
为什么不用 HTTP/3 的 QUIC 替代 WebRTC？（QUIC 仍是可靠传输，WebRTC 的 UDP+RTP 更适合实时音视频）

Q16: 有没有用过大模型的网关框架？网关层解决了什么问题？「🟡 中级」

考察点：大模型网关的工程实践。

参考答案：

大模型网关是介于应用层和模型 API 之间的中间层，解决多模型管理、路由、安全、成本等工程问题。

网关层解决的核心问题：

问题	网关方案
API 差异	统一接口，屏蔽底层差异
模型切换	配置化路由，不改代码切模型
限流控制	统一限流 + 排队
成本管理	成本监控 + 预算控制
容灾切换	自动 fallback 到备用模型
安全合规	内容过滤 + 敏感词检测
缓存优化	语义缓存，命中免调用
可观测性	统一日志 + 指标 + 追踪

主流网关框架：

框架	特点	适合
OneAPI / NewAPI	统一 OpenAI 格式，令牌管理	中小企业
LiteLLM	Python SDK + Proxy，支持 100+ 模型	开发团队
Kong AI Gateway	基于 Kong，插件化	大型企业
Cloudflare AI Gateway	云托管，全球 CDN	全球分布应用

yaml

# LiteLLM Proxy 配置
model_list:
  - model_name: gpt-4
    litellm_params:
      model: azure/gpt-4-turbo
      api_key: "xxx"
  - model_name: gpt-4
    litellm_params:
      model: openai/gpt-4o
      api_key: "xxx"

litellm_settings:
  cache: true              # 语义缓存
  max_budget: 100.0        # 日预算上限
  rate_limit:
    gpt-4: 100            # 每分钟 100 请求

router_settings:
  routing_strategy: least-busy
  fallbacks:
    - gpt-4: [claude-3.5-sonnet, gemini-pro]

追问延伸：

网关层如何做语义缓存？（Embedding 相似度匹配，命中则返回缓存结果）
如何防止 Prompt 注入攻击？（输入过滤 + System Prompt 保护 + 输出检测）

LLM 工具调用面试专题 ​

Q1: 什么是 Function Calling？原理是什么？ 「🟢 校招/初级」 ​

Q2: LLM 是如何学会调用外部工具的？ 「🟡 中级」 ​

Q3: 大模型的 Function Call 能力是怎么训练出来的？ 「🔴 高级」 ​

1. SFT 阶段：指令跟随 + 工具调用格式 ​

2. RLHF 阶段：优化调用质量 ​

3. 特殊能力训练 ​

Q4: 什么是 MCP（模型上下文协议）？讲讲它的核心内容？ 「🟡 中级」 ​

Q5: MCP 由哪几部分组成？ 「🟡 中级」 ​

Q6: MCP 和 Function Calling 有什么区别？有没有实际跑过 MCP？ 「🟡 中级」 ​

Q7: Function Calling 也属于工具调用，请问什么场景下使用 Function Calling，什么场景下使用 MCP？ 「🟡 中级」 ​

Q8: 为什么有些特定的推理模型不支持 MCP 协议？ 「🔴 高级」 ​

Q9: Skill 是什么？ 「🟢 校招/初级」 ​

Q10: MCP 和 Agent Skill 的区别是什么？ 「🟡 中级」 ​

Q11: Function Calling、Skill、MCP 这三个有什么区别？ 「🟡 中级」 ​

Q12: 什么是 A2A 协议？它和 MCP 协议的区别是什么？ 「🔴 高级」 ​

Q13: MCP 协议通常采用什么通信方式？ 「🟢 校招/初级」 ​

Q14: 说说 WebSocket 和 SSE 通信的区别及局限性？ 「🟡 中级」 ​

Q15: 为什么要用 WebRTC 协议？它和 WebSocket 在 AI 对话流中的核心差异是什么？ 「🔴 高级」 ​

Q16: 有没有用过大模型的网关框架？网关层解决了什么问题？ 「🟡 中级」 ​

LLM 工具调用面试专题

Q1: 什么是 Function Calling？原理是什么？「🟢 校招/初级」

Q2: LLM 是如何学会调用外部工具的？「🟡 中级」

Q3: 大模型的 Function Call 能力是怎么训练出来的？「🔴 高级」

1. SFT 阶段：指令跟随 + 工具调用格式

2. RLHF 阶段：优化调用质量

3. 特殊能力训练

Q4: 什么是 MCP（模型上下文协议）？讲讲它的核心内容？「🟡 中级」

Q5: MCP 由哪几部分组成？「🟡 中级」

Q6: MCP 和 Function Calling 有什么区别？有没有实际跑过 MCP？「🟡 中级」

Q7: Function Calling 也属于工具调用，请问什么场景下使用 Function Calling，什么场景下使用 MCP？「🟡 中级」

Q8: 为什么有些特定的推理模型不支持 MCP 协议？「🔴 高级」

Q9: Skill 是什么？「🟢 校招/初级」

Q10: MCP 和 Agent Skill 的区别是什么？「🟡 中级」

Q11: Function Calling、Skill、MCP 这三个有什么区别？「🟡 中级」

Q12: 什么是 A2A 协议？它和 MCP 协议的区别是什么？「🔴 高级」

Q13: MCP 协议通常采用什么通信方式？「🟢 校招/初级」

Q14: 说说 WebSocket 和 SSE 通信的区别及局限性？「🟡 中级」

Q15: 为什么要用 WebRTC 协议？它和 WebSocket 在 AI 对话流中的核心差异是什么？「🔴 高级」

Q16: 有没有用过大模型的网关框架？网关层解决了什么问题？「🟡 中级」