AI

第四篇10-12章

好,第四批 第 10~12 章是这一整套 AI Agent 速成的收官。

AI
第四篇10-12章文章封面

当前Host

好,第四批 第 10~12 章是这一整套 AI Agent 速成的收官。

前三批你已经打通了:

LLM
↓
Prompt / Context
↓
RAG
↓
Chunk
↓
Embedding / Retrieval
↓
Rerank
↓
Agent
↓
Tool Calling

最后这一批解决三个问题:

第 10 章:MCP——Agent 怎么标准化连接外部世界。 第 11 章:Memory / Skill / Harness——一个真正 Agent 系统外围到底还有什么。 第 12 章:把所有知识压回你的博客和简历——面试怎么讲。

这一批学完以后,你要能真正讲清楚:

LLM 是大脑,RAG 给它资料,Tool 给它手脚,MCP 标准化工具接入,Memory 保存跨步骤信息,Skill 提供可复用的方法论,而 Harness 负责把模型、工具、权限、上下文、循环和运行环境组织起来,最终形成 Agent。


第 10 章:MCP 到底是什么

这是你简历里最容易被追问,同时也是最好快速掌握的概念之一。

先背一句标准定义:

MCP,Model Context Protocol,是一种用于 AI 应用与外部工具和数据源之间进行标准化连接与上下文交换的开放协议。

你可以暂时把它理解成:

AI 世界里的 USB-C。


一、没有 MCP 之前有什么问题?

假设我要开发一个 Agent。

它需要:

GitHub
MySQL
文件系统
Notion
Slack
浏览器

以前可能:

Claude → 自己写 GitHub Adapter
Claude → 自己写 MySQL Adapter
Claude → 自己写 Filesystem Adapter

另一个 Agent
      → 又写一套 GitHub Adapter
      → 又写一套 MySQL Adapter

出现:

AI × Data Source

组合爆炸。

例如:

5 个 AI Client
×
20 个外部系统
=
理论上大量单独适配

MCP 希望变成:

               MCP Protocol

AI Host ──────────────────────────┐
                                 │
            ┌────────────────────┼───────────────┐
            ↓                    ↓               ↓
       GitHub MCP            MySQL MCP       Files MCP
         Server               Server          Server

这样不同 AI 应用都按照共同协议理解:

“这个 Server 提供了哪些能力?”

这就是 MCP 的价值。


二、最核心的三层角色

面试必须会:

Host
Client
Server

官方架构中,Host 是 AI 应用本身,Host 管理一个或多个 MCP Client,而通常每个 Client 维护到一个 MCP Server 的连接。Server 可以在本地,也可以是远程服务。(Model Context Protocol)

你可以这样理解:

┌─────────────────────────────┐
│           MCP Host          │
│                             │
│ Claude Code / IDE / Agent   │
│                             │
│  ┌────────┐   ┌────────┐    │
│  │Client A│   │Client B│    │
│  └───┬────┘   └───┬────┘    │
└──────┼─────────────┼─────────┘
       ↓             ↓
 GitHub MCP       DB MCP
   Server          Server

Host

负责整个 Agent。

例如:

LLM
上下文
用户权限
多个 MCP Server
Agent Loop

都由 Host 协调。

一句话:

Host 是总指挥。


Client

Host 内负责和某一个 Server 通信。

一句:

Client 是连接器。


Server

对外提供具体能力。

例如:

GitHub MCP Server

可能提供:
搜索仓库
读取文件
创建Issue
读取PR

一句:

Server 是能力提供方。


三、MCP Server 到底提供什么?

这一块必须重点背。

核心三个:

Tools
Resources
Prompts

官方 MCP 文档把它们定义为 Server 可以提供的核心 primitives。(Model Context Protocol)


1. Tools

可以执行的动作。

例如:

search_repository()
read_file()
create_issue()
query_database()

所以:

Tool = 行动能力。


2. Resources

可以读取的上下文数据。

例如:

文件内容
数据库 Schema
Git History
项目文档
API 返回数据

所以:

Resource = 数据 / 上下文。

官方文档指出 Resource 可以代表文件、数据库记录、API 数据等,并由 Host 决定如何纳入模型 Context。(Model Context Protocol)


3. Prompts

可复用的提示模板。

例如:

/code-review
/analyze-pr
/database-debug

所以:

Prompt = 可复用交互模板。


四、三个东西怎么区分?

背这张:

MCP Primitive本质例子
Tool做事情创建 Issue
Resource给资料读取项目文件
Prompt给方法模板Code Review 模板

可以记:

Tools
= 做

Resources
= 看

Prompts
= 怎么做

虽然是简化记忆,但非常好用。


五、Tool Calling 和 MCP 到底有什么区别?

这是 MCP 第一高频面试题。

你一定不要回答:

差不多,都是调用工具。

不是。

Tool Calling

解决:

模型怎么决定调用什么工具,并产生参数。

例如:

LLM

↓

{
  "tool": "search_repository",
  "arguments": {
    "query": "RAG"
  }
}

MCP

解决:

这些 Tool / Resource 如何以标准协议被 AI 应用发现、描述和访问。

例如:

MCP Client

↓

tools/list

↓

MCP Server

↓

[
 search_repository,
 read_file,
 create_issue
]

所以核心关系:

Tool Calling
=
“我要调用哪个能力?”

MCP
=
“这些能力通过什么标准方式接进来?”

非常重要。

你可以背:

Tool Calling 是模型层面的工具选择机制,MCP 是应用与外部工具、数据源之间的标准化连接协议。两者不是竞争关系,MCP 提供的 Tool 最终仍然可以由模型通过 Tool Calling 进行选择。

这基本就是标准答案。


六、API 和 MCP 又有什么区别?

面试官可能追问:

API 已经存在这么多年了,为什么还需要 MCP?

这是好问题。

API:

GET /repos
POST /issues
GET /users

主要服务:

软件和软件之间调用。

但是不同 API:

认证方式不同
Schema不同
文档不同
发现方式不同
错误结构不同
调用方式不同

Agent 需要额外适配。

MCP 在 API 上方增加一个:

面向 AI Client 的标准协议层。

可以理解:

        Agent
          ↓
        MCP
          ↓
      MCP Server
          ↓
   GitHub API / DB / FS

所以:

MCP 通常不是替代底层 API,而是把底层能力包装成 AI 应用容易统一发现和调用的标准接口。

这一句话非常关键。


七、MCP 是怎么发现 Tool 的?

MCP 不是要求:

你提前把所有工具写进一个巨大 Prompt。

Client 可以请求:

tools/list

Server 返回:

name
description
input schema
...

然后:

tools/call

调用相应工具。

这种动态发现是 MCP 很重要的思想之一。(Model Context Protocol)

和你上一章 Tool Schema 就直接接起来了。


八、MCP 底层传什么?

你不用深入协议源码。

只需要记:

MCP 的消息层基于 JSON-RPC。

官方当前文档也是这么描述的。(Model Context Protocol)

大概:

{
  "jsonrpc": "2.0",
  "method": "tools/list",
  "id": 1
}

不用背 JSON。

知道:

MCP
不是HTTP API的一个固定URL规范

而是一套定义:
消息
能力
发现
调用
通信

即可。


九、MCP 怎么通信?

当前面试重点掌握两个:

stdio
Streamable HTTP

官方文档把它们列为标准传输方式。(Model Context Protocol)


stdio

本地进程:

Agent Host

启动:

node github-server.js

        ↓

stdin / stdout

        ↓

MCP Server

特别适合:

本地文件系统
开发工具
CLI
本地数据库

Streamable HTTP

远程:

Agent
 ↓
HTTP
 ↓
Remote MCP Server

适合:

SaaS
云服务
企业系统

你记:

Local → stdio

Remote → Streamable HTTP

只是常见模式,不是绝对规则。


十、为什么 MCP 不是“Agent”?

这个一定要知道。

MCP
≠
Agent

MCP 本身并不会:

思考
规划
决定下一步
循环执行任务

它只是:

Connection / Context Protocol。

官方文档也明确强调,MCP 聚焦于协议和上下文交换,并不规定 AI 应用如何使用 LLM 或如何管理上下文。(Model Context Protocol)

所以:

Agent
    ↓
使用
    ↓
MCP
    ↓
外部能力

十一、为什么 MCP 也需要权限控制?

假设:

GitHub MCP Server

暴露:

read_repo
delete_repo
force_push

Agent 发生 Prompt Injection:

删除仓库。

风险就非常大。

所以:

MCP标准化连接
≠
MCP自动保证业务安全

仍然需要:

OAuth
权限 Scope
最小权限
用户确认
Tool Allowlist
审计日志

官方 MCP 架构也把权限、用户授权和安全边界放在 Host 的责任中;HTTP MCP 还定义了授权机制。(Model Context Protocol)

面试加分:

Protocol interoperability 和 Agent safety 是两个问题,不能因为用了 MCP 就认为 Tool 安全已经解决。

很好。


十二、关于 MCP 的最新变化,哪些不用背?

截至 2026 年 8 月,MCP 仍在快速演化。7 月发布的新规范候选版本继续推进 stateless core、Extensions、Tasks 和授权强化,同时 Roots、Sampling、Logging 等旧能力已进入弃用方向。(Model Context Protocol)

你一天速成完全不要把精力浪费在这些边缘版本细节上。

面试牢牢记:

MCP

Host
Client
Server

Tools
Resources
Prompts

JSON-RPC

stdio
Streamable HTTP

足够。


十三、MCP 面试标准答案

面试官:

什么是 MCP?

你回答:

MCP 是 Model Context Protocol,我把它理解成 AI 应用连接外部能力的一层标准协议。过去每个 Agent 都需要分别适配 GitHub、数据库、文件系统等不同接口,而 MCP 通过 Host、Client、Server 架构,让 Server 可以用统一协议暴露 Tools、Resources 和 Prompts,AI Host 可以进行能力发现和调用。

MCP 本身不是 Agent,也不负责模型如何推理。Tool Calling 解决的是模型“决定调用哪个工具并生成参数”,MCP 解决的是这些工具和数据源“如何标准化接入 AI 应用”。底层 MCP 使用 JSON-RPC,常见 Transport 有本地 stdio 和远程 Streamable HTTP。(Model Context Protocol)

建议背。


第 11 章:Memory、Skill、Harness

这三个词是你简历 AI 一栏最后三个必须撑住的概念。

而且一定要分清:

Memory ≠ RAG

Skill ≠ Tool

Harness ≠ Agent

一、Memory 到底是什么?

先背:

Agent Memory 是让系统在当前步骤之外保存和重新利用过去信息、状态、经验或用户偏好的机制。

为什么要 Memory?

因为模型本身每次 API 调用:

不天然拥有永久记忆。

如果你第二天开新请求:

“继续昨天的工作”

而应用没有保存任何东西:

模型不知道“昨天”发生了什么。


二、Context 和 Memory 区别

这个非常重要。

Memory
= 仓库

Context
= 当前桌面

Memory 里可能有:

1000条历史

但模型 Context Window 不能全部放。

所以:

Memory
 ↓
Retrieve / Select
 ↓
Relevant Memory
 ↓
Context
 ↓
LLM

这和 RAG 非常像。

实际上:

Memory Retrieval 本质上经常也会使用检索思想。


三、Short-term Memory

简单理解:

当前任务过程中的状态。

例如 Agent:

Step1:找到了5篇文章

Step2:已经读取3篇

Step3:还剩2篇

这些状态必须保留。

否则 Agent 每一步都:

“我刚才干嘛了?”


四、Long-term Memory

跨 Session 保存。

例如:

用户喜欢中文回答
项目技术栈 Astro + React
博客文章路径规则
之前已经分析过哪些文章

以后再检索回来。


五、你只要记 3 类 Memory

不用学几十种术语。

Conversation Memory

历史聊天:

User
Assistant
User
Assistant

Semantic Memory

事实:

用户项目使用Astro
博客部署在Vercel

Episodic Memory

过去发生过的任务经历:

上一次修复AI Gateway时
DeepSeek曾返回429
最后通过限流处理

你把这三个概念懂了即可。


六、Memory 和 RAG 有什么区别?

高频。

RAG:

通常检索外部知识

例如:

博客
PDF
企业Wiki

Memory:

通常检索过去交互和Agent自身状态

所以:

RAG:
“世界知道什么?”

Memory:
“这个Agent / 用户之前发生过什么?”

但实现层:

Chunk
Embedding
Vector Search
Metadata

可能高度相似。


七、Memory 不是越多越好

如果 Agent 什么都记:

用户每句话
每个Tool Result
所有无意义状态

会产生:

Memory Noise
Storage增长
隐私风险
错误记忆
Context污染

所以好的 Memory 体系需要:

Write Policy
Retrieve Policy
Forget / Update Policy

也就是:

什么值得记,什么时候取出来,什么时候删除或更新。

这句话很重要。


八、Skill 到底是什么?

这里一定要准确。

Skill 不是所有 Agent 框架统一规定的基础概念。

但当前 Agent Skills 体系里,可以把 Skill 理解成:

针对某类任务打包好的可复用专业知识、工作流程、指令和可选脚本/资源,让通用 Agent 在需要时加载并按照既定方法完成任务。

目前 Agent Skills 规范中,一个 Skill 至少包含:

skill-name/
└── SKILL.md

还可以有:

scripts/
references/
assets/

SKILL.md 包含 Metadata 和具体 Instructions。(Agent Skills)

Anthropic 当前官方文档也采用这种基于文件系统、按需加载的 Skill 模型。(Claude Platform)


九、给你一个非常直观的 Skill

比如:

frontend-code-review/
│
├─ SKILL.md
├─ references/
│  └─ review-rules.md
│
└─ scripts/
   └─ analyze-bundle.js

SKILL.md:

---
name: frontend-code-review
description: 用于前端项目代码审查和性能排查
---

# Workflow

1. 先检查项目结构
2. 检查 React/Vue 状态设计
3. 检查重复渲染
4. 检查包体积
5. 检查 XSS
6. 输出严重程度

Agent 遇到:

帮我 review 这个前端项目。

就可以加载这个 Skill。


十、Skill 和 Prompt 有什么区别?

Prompt:

这一次告诉AI:
帮我按照以下规则检查代码……

Skill:

把这套规则长期封装起来

所以:

Prompt 更像一次性指导,Skill 更像可复用的任务操作手册。


十一、Skill 和 Tool 又有什么区别?

这个必须背。

例如:

Tool

read_file()

它解决:

能做什么。


Skill

code-review skill

告诉 Agent:

先读哪些文件
检查什么
怎么判断
最后怎么输出

它解决:

应该怎么做。

所以一句:

Tool
= Capability

Skill
= Procedure / Expertise

翻中文:

Tool 是能力,Skill 是方法。

非常好背。


十二、Skill 和 MCP 又是什么关系?

MCP:

标准化把 Tool / Resource 接给 Agent。

Skill:

告诉 Agent 如何组合这些能力完成某类任务。

例如:

Frontend Review Skill
        ↓
要求:
读取package.json
读取源码
运行测试
检查Git Diff
        ↓
实际能力来自:
Filesystem MCP
GitHub MCP
Terminal Tool

所以:

MCP
= 接工具

Skill
= 用工具的方法

十三、Skill 为什么经常使用“渐进加载”?

这是非常好的 AI 工程思想。

假设有:

100 个 Skill

如果启动时:

100 个 SKILL.md
全部塞入Context

Context 爆炸。

因此当前 Agent Skills 思路一般是:

启动时:

Name
Description

↓

判断相关

↓

再加载完整 SKILL.md

↓

需要时再读取references / scripts

Agent Skills 官方规范和 Anthropic 文档都强调这种按需 / 渐进式加载。(Agent Skills)

你马上应该想到:

Context Engineering。

这和我们第二章完全接上了。


十四、Harness 到底是什么?

这个概念经常被说得特别玄。

先说明:

Agent Harness 并不是像 MCP 那样有唯一统一标准协议,它更多是一个工程概念。

你可以理解:

Harness 是包在 LLM 外面、负责让 Agent 真正稳定执行任务的一整套运行时和基础设施。

核心图:

                  User
                   ↓

          ┌───────────────────┐
          │   Agent Harness   │
          │                   │
          │ Context Manager   │
          │ Tool Registry     │
          │ Permission        │
          │ Agent Loop        │
          │ Memory            │
          │ Timeout / Retry   │
          │ Sandbox           │
          │ Logging           │
          │ Budget            │
          └─────────┬─────────┘
                    ↓
                   LLM
                    ↓
                 Tool Call

十五、为什么单有 LLM 不够?

裸 LLM:

input
 ↓
model
 ↓
text

Coding Agent 却可以:

搜索代码
读取文件
编辑文件
运行npm test
读取错误
重新修改
检查Git diff

这里真正复杂的:

不只是模型。

外围系统还要解决:

给模型哪些文件?

允许它执行什么命令?

命令多久超时?

失败重试几次?

当前任务执行到第几步?

Tool结果怎么放回Context?

最多允许消耗多少Token?

文件写错如何回滚?

这些都属于 Harness 要负责的问题。


十六、Harness 最重要的 8 个东西

你不用背 30 个。

就背八个:

1. Context Management

2. Tool Execution

3. Agent Loop

4. State / Memory

5. Permission

6. Sandbox

7. Retry / Timeout

8. Observability

Context Management

决定:

给LLM看什么
删什么
摘要什么
什么时候加载Skill

Tool Execution

真正:

执行Shell
调用API
读写文件

Agent Loop

控制:

Decision
→ Action
→ Observation
→ Repeat

Memory / State

保存:

任务状态
历史
进度

Permission

决定:

可以读
可以写
可以删除?

Sandbox

把 Agent 限制在安全环境里。

比如:

只能修改项目目录

不能:

rm -rf /

Retry / Timeout

避免:

无限重试
无限等待

Observability

记录:

调用了哪个Tool
耗时
Token
失败原因
执行轨迹

出了问题才能 Debug。


十七、Agent、Harness 到底怎么区分?

这句话非常好:

Agent 描述的是“谁在做决策”,Harness 描述的是“这个决策系统如何被安全、稳定地运行起来”。

简单:

Agent
= 智能决策逻辑

Harness
= Agent运行环境

你甚至可以类比前端:

React组件
≈ Agent逻辑

浏览器 + Runtime + Bundler + DevTools
≈ Harness外围基础设施

只是类比,不是完全等价。


十八、为什么 Codex / Claude Code 这种东西比纯聊天模型强?

不要简单说:

因为模型更聪明。

更完整:

Model
+
Filesystem
+
Terminal
+
Search
+
Context Selection
+
Patch / Edit
+
Testing
+
Permissions
+
Agent Loop
+
Sandbox

这些外围能力差异巨大。

所以:

Agent 产品最终体验 = Model Capability × Harness Quality。

这是一个非常值得你形成的观点。


十九、第 11 章必背关系图

LLM
= 思考

Tool
= 做事

MCP
= 标准化连接外部能力

Skill
= 可复用操作方法

Memory
= 记住过去

Harness
= 管理整套运行过程

Agent
= 利用这些东西围绕目标动态决策

第二部分收口:MCP / Skill / Tool / Memory / Harness 一次分清

这是你最应该每天背的一张表:

概念一句话
LLM大脑
RAG给大脑查资料
Tool给大脑手脚
MCP标准化连接工具和数据
Skill告诉 Agent 一类任务应该怎么做
Memory保存过去需要复用的信息
Harness让 Agent 安全稳定运行的外围系统
Agent围绕目标动态决策并使用以上能力

第 12 章:把 12 章全部压到你的博客和简历里

这一章非常重要。

因为:

知道知识 ≠ 面试会讲项目。

你简历现在明确写了:

AI:了解 LLM、Agent、RAG、MCP、Skill 和 Harness;同时项目里写了大模型流式渲染、Markdown、安全渲染、上下文问答等能力。

所以我们现在让这句话真正撑起来。


一、先搞清楚:你的个人博客 AI 目前到底是什么

根据你现在 GitHub 实际源码,准确描述应该是:

一个带轻量 RAG / Retrieval 能力的 Page-Aware AI Assistant,而不是一个完整的 Tool-Using Agent。

README 当前明确写了:

DeepSeek V4 Pro
流式对话
文章感知
静态知识检索

Retrieval 2.0:
Metadata 查询
Heading Chunk
中英混合词法检索
无 Vector DB

这一定不能包装过头。


二、你的博客 AI 整体架构

你必须能脱稿画:

                    Visitor
                       ↓
                   React Chat
                       ↓
                  用户 Query
                       ↓
              Query Intent Router
                       ↓
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
 Metadata Query   Chunk Retrieval  Current Page
        │              │              │
        └──────────────┼──────────────┘
                       ↓
                  Blog Context
                       +
                   Chat History
                       +
                 System Prompt
                       ↓
                 /api/chat
                       ↓
               Vercel Function
                       ↓
               DeepSeek V4 Pro
                       ↓
                    SSE
                       ↓
                ReadableStream
                       ↓
             Markdown Incremental UI

三、面试官:介绍一下你博客的 AI 功能

下面这一段你可以直接作为 2~3 分钟项目回答来练。

我的个人博客里面做了一个文章感知的 AI Assistant,它不只是前端直接调用大模型 API。

整体上我把它分成 Retrieval 层、LLM Gateway 层和前端 Streaming 层。

Retrieval 层会先把博客 Markdown 构造成结构化知识索引,文章内容根据 Heading 做 Chunk,同时保留 HeadingPath、Category、Tags 和 URL 等 Metadata。用户提问后先做 Intent Classification,对文章数量、分类列表这种确定性问题直接查询 Metadata;普通内容问题再通过中英混合词法检索和字段加权进行 Ranking,选择少量高相关 Chunk 作为 Context。

模型层使用 DeepSeek V4 Pro,但 Key 不会暴露在浏览器,而是经过 Vercel Serverless AI Gateway。Gateway 会处理 Zod 参数校验、Origin、Rate Limit、最大并发、Timeout、Abort 和上游错误映射,然后代理 DeepSeek 的 SSE Stream。

最后浏览器通过 Streaming 增量消费模型输出并渲染 Markdown。对于 RAG Context,我还明确把它标记成只读资料,降低间接 Prompt Injection 风险。

目前这个项目准确来说还是 RAG Assistant,不是完整 Agent,因为没有模型自主选择并执行 Tool 的多步循环。后续如果 Agent 化,我会把 searchBlog、readArticle、createDraft 等能力 Tool 化,再加入 Tool Schema、权限和 Human-in-the-loop。

如果你能自然讲完:

已经比“我接了一个 DeepSeek API”强很多。


四、面试官:你这个 RAG 为什么没有 Vector DB?

这个问题你已经应该秒答:

当前博客知识规模还比较小,而且 Markdown 天然具有高质量的 Title、Heading、Category、Tag 等结构化信息,同时技术文章的关键词辨识度比较高。所以我没有为了技术栈而强行增加 Embedding 和 Vector Database,而是先使用 Heading Chunk、Metadata 和 Field-weighted Lexical Retrieval。

这样成本低、可解释性强,也没有额外的 Embedding 和向量索引同步问题。如果以后文章规模扩大,出现大量同义语义 Query 导致 Recall 不足,我会增加 Embedding Retrieval,并与当前 Lexical Search 做 Hybrid Search,而不是完全替换当前体系。


五、面试官:你这个算 Agent 吗?

直接答:

目前严格来说不算完整 Agent,它是带 Retrieval 能力的 AI Assistant。它已经有 Intent Routing、RAG、Context Engineering 和 Streaming,但模型当前主要负责生成答案,并没有自主选择 Tool、执行 Tool、观察 Tool Result 再继续决策的 Agent Loop。

如果升级成 Agent,我会先加 searchBlog、readArticle 和 createDraft 三个 Tool,让模型可以围绕“检查博客内容并创建草稿”形成 Decision → Tool Call → Observation → Decision 的闭环。

不要不好意思承认。

这反而说明:

你真的知道 Agent 的边界。


六、面试官:那你怎么把它升级成 Agent?

你可以画:

                    User Goal

   “分析我Vue文章缺什么并创建一篇草稿”

                       ↓

                  Blog Agent
                       ↓

                  LLM Decision
                       ↓

          search_blog(category="Vue")

                       ↓

                  Observation
                   找到12篇

                       ↓

                  read_article()

                       ↓

                  Observation
                  发现缺KeepAlive

                       ↓

                 create_draft()

                       ↓

              Schema Validation

                       ↓

                User Confirmation

                       ↓

                     Write

                       ↓

                 Final Answer

然后:

后续如果还需要 GitHub、Web Search 或数据库,我不会全部手写专用 Adapter,可以考虑通过 MCP Server 接入这些外部能力。

这就把:

Agent
Tool
MCP

全部串起来了。


七、面试官:MCP 在这个项目里有什么用?

现在博客没有必要假装已经用了 MCP。

你应该说:

当前博客的站内 Retrieval 是项目内部实现,并没有为了本地函数强行上 MCP。MCP 更适合未来 Agent 需要连接独立外部系统时,比如 GitHub、文件系统或其他 SaaS。我会把 MCP 当成外部能力标准化接入层,而不是把每个本地函数都包装成 MCP。

这回答非常成熟。

因为:

不是用了更多协议就更高级。


八、面试官:RAG 和 Agent 最大区别是什么?

背:

RAG 主要解决知识增强问题,它回答的是“模型回答前需要知道哪些外部信息”;Agent 解决的是任务执行问题,它回答的是“为了完成目标下一步应该做什么”。RAG 可以被封装成 Agent 的一个 Retrieval Tool,但两者不是一个层次。


九、面试官:Tool Calling 和 MCP 最大区别?

背:

Tool Calling 解决的是模型如何选择工具并生成结构化参数,而 MCP 解决的是 AI Host 与外部 Tool、Resource 之间如何标准化连接、发现和通信。MCP 提供出来的 Tool 最终仍然可以由模型通过 Tool Calling 选择执行。


十、面试官:Skill 和 MCP 有什么区别?

背:

MCP 偏向能力接入,Skill 偏向能力使用方法。比如 GitHub MCP 可以给 Agent 提供读取仓库、创建 Issue 等能力,而 Code Review Skill 可以规定完成代码审查时先看哪些文件、执行哪些检查、最后按照什么格式输出。


十一、面试官:Skill 和 Tool 有什么区别?

秒答:

Tool 解决“能不能做”,Skill 解决“应该怎么做”。

然后举:

read_file
=
Tool

frontend-code-review
=
Skill

十二、面试官:Memory 和 RAG 有什么区别?

秒答:

RAG 通常检索外部知识,Memory 更多保存和检索过去交互、用户信息或 Agent 执行状态。两者实现上都可能使用 Embedding、Vector Search 和 Metadata,但信息来源和目的不同。


十三、面试官:Harness 是什么?

这段值得背:

Harness 可以理解为 Agent 外围的运行时基础设施。模型只负责推理和生成 Tool Call,而真正的 Context 管理、Tool 执行、权限、Sandbox、Memory、Agent Loop、Retry、Timeout、Token Budget 和日志,都需要外围系统负责。

所以我认为一个 Coding Agent 的能力并不完全等于底层模型能力,Model 决定智能上限,而 Harness 很大程度决定它能不能稳定地完成真实工程任务。

最后一句很加分。


十四、面试官开始连环追问

你要形成下面这条脑中链路:

Q:LLM是什么?

A:
Transformer
Next Token Prediction

↓

Q:它不知道我博客怎么办?

A:
RAG

↓

Q:文章太长怎么办?

A:
Chunk

↓

Q:怎么检索?

A:
Lexical / BM25 / Vector / Hybrid

↓

Q:Vector为什么懂语义?

A:
Embedding

↓

Q:怎么提升最终检索质量?

A:
Top-K + Rerank

↓

Q:怎么让模型做事情?

A:
Tool Calling

↓

Q:多步动态执行?

A:
Agent

↓

Q:Tool怎么标准化接进来?

A:
MCP

↓

Q:怎么让Agent记住过去?

A:
Memory

↓

Q:怎么让它掌握固定专业流程?

A:
Skill

↓

Q:谁负责权限、上下文、Loop、Sandbox?

A:
Harness

这就是你一天 AI 学习真正应该形成的:

知识网络。

而不是 12 个孤立名词。


十五、整套 AI Agent 最强的一句话总结

这个我建议你每天抄一遍:

LLM 是 Agent 的推理核心;Prompt 和 Context 决定模型当前看到什么;RAG 通过 Retrieval 给模型补充外部知识;Chunk 控制知识检索粒度;Embedding 和 BM25 分别提供语义和词法检索能力;Rerank 提高最终 Context 的精度;Tool Calling 让模型提出结构化行动;MCP 标准化外部工具与数据源的接入;Memory 保存需要跨步骤或跨会话复用的信息;Skill 封装某类任务的专业流程;Harness 则负责 Context、Tool、权限、状态、循环、Sandbox 和错误处理,最终共同形成一个真正能够围绕目标行动的 Agent。

如果你能完全脱稿讲出来:

你简历里:

LLM、Agent、RAG、MCP、Skill、Harness

这一排词已经不再只是关键词。


最后:第四批每天背诵版

第一段:MCP

MCP 是 Model Context Protocol,是 AI 应用连接外部工具和数据源的一套标准协议。核心架构包括 Host、Client 和 Server,Server 可以暴露 Tools、Resources 和 Prompts。MCP 的消息层基于 JSON-RPC,常见传输包括本地 stdio 和远程 Streamable HTTP。

Tool Calling 解决的是模型如何选择工具和生成参数,MCP 解决的是工具和数据源如何标准化接入 AI 应用。MCP 本身不是 Agent,它只负责能力和上下文的连接。(Model Context Protocol)


第二段:Memory / Skill / Harness

Memory 用来保存和复用当前 Context 之外的信息,可以包括 Conversation、Semantic 和 Episodic Memory。Memory 是长期仓库,Context 是当前工作区,因此通常需要从 Memory 中检索真正相关的信息再送进 Context。

Tool 表示 Agent 能做什么,而 Skill 表示一类任务应该怎么做。当前 Agent Skills 通常通过 SKILL.md 封装 Metadata、Instructions 和可选 Scripts、References,并按需加载以减少 Context 消耗。(Agent Skills)

Harness 是 Agent 外围的运行时基础设施,主要处理 Context、Tool Execution、Agent Loop、State、Permission、Sandbox、Retry、Timeout 和 Observability。


第三段:Agent 总结

Agent 是以 LLM 为核心决策能力,根据 Goal 和当前 Observation 动态决定下一步行动的系统。它通过 Tool Calling 与外部环境交互,通过 RAG 获取知识,通过 Memory 保存过去,通过 Skill 获得专业工作方法,通过 MCP 标准化连接外部能力,而 Harness 负责让整个过程安全稳定运行。

能用确定性 Workflow 解决的问题不应该为了 Agent 而 Agent,真正适合 Agent 的任务通常是目标明确但执行路径需要根据环境动态变化的复杂任务。


12 章终极速记卡

最后请你把这一块保存下来反复背:

LLM
=
大脑
=
Next Token Prediction


Prompt
=
告诉模型任务

Context
=
当前工作记忆


RAG
=
给模型查资料

Document
↓
Chunk
↓
Retrieve
↓
Context
↓
LLM


Chunk
=
检索粒度


Embedding
=
文本 → 语义向量


BM25
=
词法相关性


Hybrid
=
Lexical + Vector


Retriever
=
别漏
=
Recall


Reranker
=
别排错
=
Precision


Tool
=
能做什么


Tool Calling
=
模型决定调用什么


Agent
=
Goal
→ Decision
→ Action
→ Observation
→ Repeat


MCP
=
标准化连接外部能力

Host
Client
Server

Tools
Resources
Prompts


Memory
=
记住过去


Skill
=
任务应该怎么做


Harness
=
Agent运行时

Context
Tools
Loop
Memory
Permission
Sandbox
Retry
Timeout
Logging


最终:

LLM = 大脑

RAG = 资料

Tool = 手脚

MCP = 接口标准

Memory = 记忆

Skill = 方法

Harness = 运行环境

Agent = 总体决策与行动系统

到这里,12 章 AI Agent 核心知识主干已经完整结束。

你现在最需要的已经不是再继续疯狂加概念,而是把这 12 章变成真正的“面试肌肉记忆”:任何一个名词被抽出来,你都能做到 一句话定义 → 工作原理 → 与相邻概念区别 → 工程难点 → 结合你的博客举例。这五步一旦形成,你在前端实习生里讲 AI 应用已经会明显比只会“调用大模型 API”的回答完整得多。