MCP 协议详解：从架构、工作流到 Python 技术栈落地

MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记

### 文章目录

• [MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [@[toc]](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🧠 二、什么是 MCP？一句话先讲清](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 它解决的不是"模型会不会调函数"，而是"AI 系统怎么接世界"](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🏗️ 三、MCP 架构包含哪些核心组件？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 运行时三大参与者](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 协议能力层](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. 站在工程实现角度，最值得记住的 6 个核心对象](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🚀 四、MCP 协议支持哪两种模式？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. STDIO：本地子进程模式](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [适合场景](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [优点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [缺点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. Streamable HTTP：远程服务模式](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [适合场景](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [优点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [缺点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. 两种模式怎么选？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚖️ 五、MCP 与 Function Calling 的区别是什么？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 先给结论](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 一张表讲透区别](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. 更直白一点理解](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [4. 一个典型工程判断](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [适合直接上 Function Calling 的场景](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [更适合上 MCP 的场景](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🔄 六、MCP 的工作流程是什么？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 整体流程图](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 分步骤拆解](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第一步：建立连接](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第二步：初始化与能力协商](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第三步：发现能力](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第四步：执行调用](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第五步：Server 适配真实业务逻辑](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第六步：返回结构化结果，供模型继续推理](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. MCP 工作流中最有价值的地方](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🔧 七、在 Python 技术栈中如何集成 MCP？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. Python 集成 MCP 的两条主线](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 作为 MCP Server：优先用官方 Python SDK + FastMCP](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [安装依赖](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [最小可运行示例](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [连接远程 Streamable HTTP Server](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [连接本地 STDIO Server](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [5. Python 为什么很适合做 MCP 落地？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [6. 一个非常实用的 Python 落地建议](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🔐 八、MCP 协议安全性设计包含哪些层面？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 安全设计的 6 个层面](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 远程 HTTP 模式下，官方特别强调的点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [（1）校验 Origin，防 DNS Rebinding](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [（2）本地运行时尽量只绑定 localhost](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [（3）应有正式认证机制](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [（4）STDIO 和 HTTP 的认证思路不同](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. MCP 官方安全文档里特别值得记住的几个风险点](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚠️ 风险一：Confused Deputy（代理混淆）](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚠️ 风险二：Token Passthrough](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚠️ 风险三：Session Hijacking](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚠️ 风险四：本地 MCP Server 被恶意命令利用](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [⚠️ 风险五：作用域过大](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [4. 一套更接地气的安全落地建议](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [对本地 STDIO MCP Server](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [对远程 Streamable HTTP MCP Server](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🔄 九、如何将已有的应用转换成 MCP 服务？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 先记住一句原则](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 推荐的改造步骤](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 1：先盘点哪些能力适合暴露给 AI](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 2：把能力映射成 Tool / Resource / Prompt](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [一个简单判断标准](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 3：为 AI 重构接口语义，而不是直接搬内部 API](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 4：把权限与审计前置，不要后补](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 5：先做小而稳，再做大而全](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [Step 6：把 MCP Server 当"产品"运营，而不是只当接口](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [3. 一个通用改造架构图](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [📊 十、Python + MCP 的实战落地路线图](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第一阶段：做最小闭环](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第二阶段：做 AI 友好的结果结构](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第三阶段：做治理能力](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [第四阶段：做平台化](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [✅ 十一、面试 / 汇报时可以怎么回答？](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [1. 30 秒版本](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [2. 90 秒版本](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [📚 十二、速查表：把本文 8 个问题一次收口](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🎯 总结](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)
• [🔗 参考资料](#文章目录 MCP 协议详解：从架构、工作流到 Python 技术栈落地 -- pd的后端笔记 @[toc] 🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？ 🧠 二、什么是 MCP？一句话先讲清 1. 它解决的不是“模型会不会调函数”，而是“AI 系统怎么接世界” 🏗️ 三、MCP 架构包含哪些核心组件？ 1. 运行时三大参与者 2. 协议能力层 3. 站在工程实现角度，最值得记住的 6 个核心对象 🚀 四、MCP 协议支持哪两种模式？ 1. STDIO：本地子进程模式 适合场景 优点 缺点 2. Streamable HTTP：远程服务模式 适合场景 优点 缺点 3. 两种模式怎么选？ ⚖️ 五、MCP 与 Function Calling 的区别是什么？ 1. 先给结论 2. 一张表讲透区别 3. 更直白一点理解 4. 一个典型工程判断 适合直接上 Function Calling 的场景 更适合上 MCP 的场景 🔄 六、MCP 的工作流程是什么？ 1. 整体流程图 2. 分步骤拆解 第一步：建立连接 第二步：初始化与能力协商 第三步：发现能力 第四步：执行调用 第五步：Server 适配真实业务逻辑 第六步：返回结构化结果，供模型继续推理 3. MCP 工作流中最有价值的地方 🔧 七、在 Python 技术栈中如何集成 MCP？ 1. Python 集成 MCP 的两条主线 2. 作为 MCP Server：优先用官方 Python SDK + FastMCP 安装依赖 最小可运行示例 3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？ 连接远程 Streamable HTTP Server 连接本地 STDIO Server 4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？ 5. Python 为什么很适合做 MCP 落地？ 6. 一个非常实用的 Python 落地建议 🔐 八、MCP 协议安全性设计包含哪些层面？ 1. 安全设计的 6 个层面 2. 远程 HTTP 模式下，官方特别强调的点 （1）校验 Origin，防 DNS Rebinding （2）本地运行时尽量只绑定 localhost （3）应有正式认证机制 （4）STDIO 和 HTTP 的认证思路不同 3. MCP 官方安全文档里特别值得记住的几个风险点 ⚠️ 风险一：Confused Deputy（代理混淆） ⚠️ 风险二：Token Passthrough ⚠️ 风险三：Session Hijacking ⚠️ 风险四：本地 MCP Server 被恶意命令利用 ⚠️ 风险五：作用域过大 4. 一套更接地气的安全落地建议 对本地 STDIO MCP Server 对远程 Streamable HTTP MCP Server 🔄 九、如何将已有的应用转换成 MCP 服务？ 1. 先记住一句原则 2. 推荐的改造步骤 Step 1：先盘点哪些能力适合暴露给 AI Step 2：把能力映射成 Tool / Resource / Prompt 一个简单判断标准 Step 3：为 AI 重构接口语义，而不是直接搬内部 API Step 4：把权限与审计前置，不要后补 Step 5：先做小而稳，再做大而全 Step 6：把 MCP Server 当“产品”运营，而不是只当接口 3. 一个通用改造架构图 📊 十、Python + MCP 的实战落地路线图 第一阶段：做最小闭环 第二阶段：做 AI 友好的结果结构 第三阶段：做治理能力 第四阶段：做平台化 ✅ 十一、面试 / 汇报时可以怎么回答？ 1. 30 秒版本 2. 90 秒版本 📚 十二、速查表：把本文 8 个问题一次收口 🎯 总结 🔗 参考资料)

你有没有发现，大模型真正难做的，从来不是"能不能回答问题"，而是：

• 它怎么安全地访问数据库、文件、业务系统？
• 它怎么知道当前有哪些工具可以用？
• 它调用工具时，参数结构由谁定义？
• 它接入的是本地工具，还是远程 SaaS？
• 如果系统里已经有一堆 REST API、FastAPI 服务、Python 脚本，怎么最低成本接入 AI？

这背后真正考察的，其实不是"某个模型会不会调用函数"，而是：AI 系统如何以一种标准化、可组合、可治理的方式连接外部世界。

而 MCP（Model Context Protocol，模型上下文协议）就是这件事的核心答案之一。

很多同学第一次接触 MCP，容易把它理解成"高级版 Function Calling"。这个理解不能说完全错，但只停留在这里，会低估它的工程价值。

因为 Function Calling 更像"模型会不会调某个函数" ，而 MCP 关注的是"整个 AI 应用如何发现、协商、调用、治理一组外部能力"。

下面我们就从"为什么 MCP 会出现"开始，把它在 AI 大模型系统中的作用、架构、工作流程、安全设计，以及在 Python 技术栈中的落地方式，一次讲清楚。

---

🎯 一、为什么 MCP 会成为 AI 系统的重要基础设施？

如果你做过 Agent、Copilot、企业知识库问答、AI 助手，你很快会遇到一个老问题：

大模型本身只会"生成"，但真正的业务系统需要"连接"。

比如一个企业级 AI 助手，往往要同时接这些东西：

• CRM / ERP / 工单系统
• 数据库、对象存储、搜索系统
• Git 仓库、CI/CD、监控平台
• 本地文件系统、IDE、浏览器、命令行
• 企业内部的各种 HTTP / RPC 服务

如果每个 AI 客户端、每个 Agent 框架、每个工具提供方都定义一套自己的接入协议，最后系统一定会变成这样：

• 接一个新工具，要重新适配一遍
• 工具描述格式不统一
• 参数 Schema 不统一
• 安全认证方式不统一
• 客户端很难做"自动发现能力"
• 服务端很难做"统一暴露能力"

所以，MCP 的本质价值就是给 AI 与外部能力之间，建立一层统一协议层。

你可以先把它理解成 AI 世界里的"标准插座"或"USB-C 接口"：

• 主机（Host）负责使用能力
• 服务端（Server）负责暴露能力
• 双方通过标准协议协商"我有什么""你能调什么""怎么调""返回什么"

这就把"模型"和"工具世界"的耦合，从一堆私有适配，变成了一个可复用的标准化生态。

---

🧠 二、什么是 MCP？一句话先讲清

MCP（Model Context Protocol）是一个用于连接 LLM 应用与外部数据、工具、提示模板的开放协议。

它不负责规定你一定用哪个模型，也不负责规定你怎么写 Agent 规划逻辑；它主要负责的是：

• 如何建立客户端与服务端连接
• 如何协商双方能力
• 如何发现工具 / 资源 / Prompt
• 如何以结构化方式发起调用与返回结果
• 如何在本地或远程场景下安全通信

从官方架构上看，MCP 是一个典型的 Client-Server 协议体系 ，底层消息格式基于 JSON-RPC 2.0。

1. 它解决的不是"模型会不会调函数"，而是"AI 系统怎么接世界"

很多资料一上来只讲 Tool Calling，这会让读者误以为 MCP 只是一个"工具调用协议"。

其实它更完整地覆盖了三类能力：

能力类型	作用	典型例子
Tools	可执行动作	查库存、创建工单、执行 SQL、触发部署
Resources	可读取上下文资源	文件、知识库片段、数据库记录、配置内容
Prompts	可复用提示模板	代码审查 Prompt、排障 Prompt、数据分析 Prompt

再往前一步，MCP 还支持：

• 生命周期初始化与能力协商
• Roots（客户端提供的根目录 / 工作区边界）
• Sampling（服务端反向请求客户端发起模型采样）
• 日志、通知、补全等横切能力

所以更准确地说，MCP 是"大模型上下文与外部能力交互协议"，而不是单纯的 Tool API。

---

🏗️ 三、MCP 架构包含哪些核心组件？

MCP 的"核心组件"，建议从两个视角来理解：

• 运行时参与者：谁在和谁通信
• 协议能力层：通信时都有哪些能力块

1. 运行时三大参与者

根据官方架构，MCP 运行时有三个最核心的角色：

角色	中文理解	职责
Host	主机 / AI 应用	统筹整个 AI 应用，管理一个或多个 MCP Client
Client	协议客户端	代表 Host 与某个 MCP Server 建立连接
Server	协议服务端	暴露工具、资源、Prompt 等能力

这里最容易混淆的一点是：

Host 不直接和 Server 通信，而是 Host 为每个 Server 创建一个 Client。

也就是说，一个 AI IDE、桌面助手、企业 Agent 平台，本质上是 Host；它可能同时连：

• 一个本地文件系统 MCP Server
• 一个 Git 平台 MCP Server
• 一个企业工单系统 MCP Server
• 一个内部订单系统 MCP Server

每连一个 Server，Host 侧通常都会维护一个对应的 MCP Client 实例。

2. 协议能力层

MCP 官方还把协议拆成了两层：数据层 和 传输层。

层次	作用	关键内容
Data Layer	定义交互语义	JSON-RPC 消息、生命周期、Tools、Resources、Prompts、Notifications
Transport Layer	定义通信方式	STDIO、Streamable HTTP、授权、连接建立、会话管理

如果再展开一点，可以把 MCP 看成下面这张图：
Host

AI 应用 / IDE / Agent 平台
MCP Client A
MCP Client B
MCP Client C
MCP Server

文件系统 / 本地工具
MCP Server

企业业务系统
MCP Server

远程 SaaS / 平台服务
Tools
Resources
Prompts
Tools
Resources
Prompts
Tools
Resources
Prompts

3. 站在工程实现角度，最值得记住的 6 个核心对象

如果你是后端工程师，我更推荐你记下面这 6 个关键词：

1. Host：AI 应用入口
2. Client：连接器
3. Server：能力提供者
4. Tool：可执行动作
5. Resource：可读取上下文
6. Prompt：可复用提示模板

这 6 个词一旦想通，MCP 的大框架就已经通了 70%。

---

🚀 四、MCP 协议支持哪两种模式？

如果这里说"模式"，在工程语境里通常指的是 传输模式（Transport Modes）。

根据当前官方规范，MCP 定义了两种标准传输机制：

1. STDIO
2. Streamable HTTP

⚠️ 补充一句：老版本里你可能见过 HTTP+SSE。现在官方规范已经把它演进为 Streamable HTTP。SSE 仍然可能作为流式承载手段出现，但它不再是新的标准主名词。

这里要区分 协议标准 和 框架实现：

• 协议标准层 ：当前重点就是 STDIO 与 Streamable HTTP
• 框架实现层 ：像官方 Python SDK 这类实现，除了标准传输外，也会提供 SSE 客户端、ASGI 挂载等工程化能力

1. STDIO：本地子进程模式

STDIO 适合本地场景。通信方式很直接：

• Client 启动一个 Server 子进程
• 通过 stdin 发送 JSON-RPC 消息
• 通过 stdout 接收 JSON-RPC 返回
• stderr 一般用于日志输出

适合场景

• IDE 插件连接本地工具
• 桌面客户端连接本机文件系统
• 开发机上的命令行 / Git / Docker 等本地能力
• 对网络暴露面要求极低的场景

优点

• 部署简单
• 本地隔离感强
• 不必额外开 HTTP 端口
• 很适合单客户端、本机工具接入

缺点

• 不适合多客户端共享
• 不适合云端统一暴露
• 进程生命周期管理要做好

2. Streamable HTTP：远程服务模式

Streamable HTTP 更适合远程、多客户端、服务化部署场景。

它的典型特征是：

• 客户端通过 HTTP POST 发送 JSON-RPC 消息
• 服务端可以返回普通 JSON
• 也可以通过 SSE 进行流式返回多个消息
• 支持会话 ID、断连重连、会话终止等机制

适合场景

• 企业统一工具平台
• 远程 SaaS MCP Server
• 多租户 Agent 平台
• 云原生服务部署

优点

• 天然适合远程接入
• 易于网关化、服务治理、鉴权
• 易于支持多客户端并发访问
• 更适合企业级标准接入

缺点

• 网络与鉴权复杂度更高
• 要处理会话、重连、Origin 校验等安全问题

3. 两种模式怎么选？

对比项	STDIO	Streamable HTTP
部署位置	本机子进程	本地或远程 HTTP 服务
典型场景	IDE、本地助手、本地工具	企业服务、云端平台、共享工具中心
并发能力	通常单 Client	更适合多 Client
安全重点	本地命令执行、进程权限	Origin、认证、会话、网络暴露面
运维复杂度	低	中到高
推荐使用时机	本地单机接入	服务化、平台化、远程接入

一句话总结：

本地工具接入优先考虑 STDIO，平台化远程接入优先考虑 Streamable HTTP。

---

⚖️ 五、MCP 与 Function Calling 的区别是什么？

这是高频问题，也是最容易答浅的问题。

1. 先给结论

Function Calling 解决的是"模型如何按结构化参数调用函数"；MCP 解决的是"AI 应用如何以标准协议发现并使用外部能力"。

也就是说：

• Function Calling 更靠近模型 API 层
• MCP 更靠近系统集成层 / 工具协议层

2. 一张表讲透区别

维度	Function Calling	MCP
关注点	模型输出结构化调用意图	AI 应用与外部能力的标准化连接
作用范围	单次推理 / 单个模型调用	整个客户端 - 服务端能力生态
工具发现	通常由调用方手工注入函数定义	支持协议化发现 tools/resources/prompts
生命周期	更偏"单次调用"	包含初始化、协商、调用、通知、会话
部署模型	一般在应用进程内	本地进程或远程服务都可
可移植性	往往和具体模型 API 绑定较深	更强调跨客户端、跨服务复用
安全治理	主要由应用自己做	协议层对授权、会话、传输、安全边界考虑更多
更适合谁	简单工具调用场景	多工具、多系统、平台化集成场景

3. 更直白一点理解

你可以把它们理解成两层：

• Function Calling：告诉模型"如果要调用工具，请按这个 JSON Schema 出参"
• MCP：告诉整个 AI 系统"外部世界有哪些能力、怎么发现、怎么连接、怎么调用、怎么安全治理"

所以两者不是完全替代关系，很多时候反而是 上下层关系：

• 模型层依然可以有 Function Calling
• 但工具能力的来源，可能来自一个或多个 MCP Server

4. 一个典型工程判断

适合直接上 Function Calling 的场景

• 工具很少
• 都在当前应用进程内
• 不需要跨客户端复用
• 不需要协议化发现能力

更适合上 MCP 的场景

• 工具很多
• 工具来自多个系统
• 需要本地 + 远程统一接入
• 需要平台化治理与标准化能力暴露
• 希望未来换 Host / 换 Agent 框架仍能复用同一批工具

---

🔄 六、MCP 的工作流程是什么？

理解 MCP，最关键的一步就是把它的工作流程串起来。

如果你只记概念，不记流程，最后仍然会觉得它"像个抽象黑盒"。

下面我们按一个最典型的调用流程来讲。

1. 整体流程图

外部业务能力 MCP Server MCP Client Host/AI应用 外部业务能力 MCP Server MCP Client Host/AI应用 创建连接 initialize 返回协议版本与能力 列出 tools/resources/prompts 返回能力清单 基于任务选择工具/资源 tools/call 或 resources/read 调用真实业务逻辑 返回结果 结构化结果 提供给模型继续推理

2. 分步骤拆解

第一步：建立连接

Host 想接一个 MCP Server 时，会先创建对应的 Client，并通过某种传输方式连上 Server：

• 本地场景：STDIO
• 远程场景：Streamable HTTP

第二步：初始化与能力协商

Client 会先发起初始化请求，Server 返回：

• 支持的协议版本
• 服务端能力声明
• 是否支持 tools / resources / prompts / logging 等特性

这一步很像很多中间件里的"握手阶段"。

第三步：发现能力

连接建立后，Client 可以列出 Server 暴露的能力，比如：

• 有哪些 tools
• 有哪些 resources
• 有哪些 prompts

这一步非常关键，因为它让 AI 应用具备了 自动发现外部能力 的基础，而不是把所有工具都硬编码在客户端里。

第四步：执行调用

Host 拿到能力列表后，会结合用户请求、模型推理结果、Agent 规划策略，决定：

• 要不要读某个资源
• 要不要调某个工具
• 调哪个 Prompt 模板

此时 Client 负责把调用请求按协议发给 Server。

第五步：Server 适配真实业务逻辑

Server 本身往往不是"业务逻辑本体"，它更多是一个 协议适配层。

也就是说，Server 内部通常会再去调用：

• 本地文件系统
• 数据库
• REST API
• 微服务
• SDK
• Shell 命令

所以在真实系统里，MCP Server 更像"AI 入口适配器"。

第六步：返回结构化结果，供模型继续推理

Server 返回的不是随意拼接的一段字符串，而通常是 有结构、有边界的结果。Host 拿到结果后，再交给模型继续推理，生成最终回答或继续下一轮工具调用。

3. MCP 工作流中最有价值的地方

我认为是这三个：

• 能力发现：客户端不需要预埋死所有工具细节
• 能力解耦：业务系统不用直接理解某家模型 API
• 能力复用：同一个 MCP Server 可以被多个 Host / Agent 复用

---

🔧 七、在 Python 技术栈中如何集成 MCP？

如果你的主技术栈是 Python，那 MCP 其实会更"顺手"。

因为在当前官方生态里，Python 已经有比较成熟的 官方 SDK ，并且提供了一个很好用的高层封装：FastMCP。

这意味着你既可以：

• 把现有 Python 能力快速暴露成 MCP Server
• 也可以让你自己的 Python Agent / CLI / Web 服务去消费外部 MCP Server

📌 下文示例基于 MCP 官方 Python SDK 文档与官方 python-sdk 仓库的能力模型来讲。

1. Python 集成 MCP 的两条主线

和前面讲的协议角色一致，Python 技术栈里也有两条典型路线：

集成方向	你扮演什么角色	适合场景
做 MCP Server	把已有 Python 业务能力暴露出去	把脚本、数据处理、搜索、内部服务能力接给 AI
做 MCP Client	消费外部 MCP 服务	让你的 Python Agent / Web 应用调用别人的工具

如果你是做企业内部平台，往往这两条线会同时出现：

• 对内：把已有 Python 服务包装成 MCP Server
• 对外：让你的 AI 应用作为 MCP Client 接更多能力源

2. 作为 MCP Server：优先用官方 Python SDK + FastMCP

如果你想把已有的 Python 能力开放给 AI，用官方推荐的高层方式通常最省事：

• 安装官方 SDK
• 使用 FastMCP 创建服务
• 用装饰器暴露 tool / resource / prompt
• 根据部署场景选择 stdio 或 streamable-http

安装依赖

pip install mcp

最小可运行示例

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("inventory-service", json_response=True)


@mcp.tool()
def get_available_stock(sku_code: str) -> dict:
    """查询指定 SKU 的可售库存"""
    available = 128  # 这里换成你的真实库存查询逻辑
    return {
        "skuCode": sku_code,
        "availableStock": available,
        "status": "IN_STOCK" if available > 0 else "OUT_OF_STOCK",
    }


@mcp.resource("inventory://policy")
def inventory_policy() -> str:
    """返回库存规则说明"""
    return "库存低于 20 时触发补货提醒。"


@mcp.prompt()
def stock_analysis_prompt(sku_code: str) -> str:
    return f"请分析 SKU {sku_code} 的库存状态，并给出补货建议。"


if __name__ == "__main__":
    mcp.run(transport="streamable-http")

这个示例最值得注意的点，不是语法本身，而是它把三类能力都串起来了：

• @mcp.tool()：暴露可执行动作
• @mcp.resource()：暴露可读上下文
• @mcp.prompt()：暴露可复用 Prompt 模板

这和 MCP 协议本身的三类核心能力，是一一对应的。

3. 作为 MCP Client：你的 Python 应用如何消费外部 MCP Server？

如果你自己的 Python 应用是 Host 一侧，比如：

• 命令行 Agent
• Web 问答服务
• 数据分析助手
• 自动化脚本平台

那么你就需要以 Client 身份连接外部 MCP Server。

官方 Python SDK 的核心对象是：

• ClientSession
• stdio_client
• streamable_http_client

连接远程 Streamable HTTP Server

import asyncio

# 从 mcp 库导入客户端会话类
from mcp import ClientSession
# 从 mcp 库导入用于流式 HTTP 通信的客户端工厂函数
from mcp.client.streamable_http import streamable_http_client


async def main():
    # 1. 建立 HTTP 连接
    # 使用上下文管理器连接到本地的 MCP 服务器
    # streamable_http_client 会返回读取流、写入流和其他元数据
    async with streamable_http_client("http://localhost:8000/mcp") as (
        read_stream,   # 用于读取服务器响应的流
        write_stream,  # 用于向服务器发送请求的流
        _,             # 其他未使用的返回值（通常包含传输层信息）
    ):
        # 2. 创建并初始化 MCP 会话
        # 使用上面建立的读写流来创建客户端会话
        async with ClientSession(read_stream, write_stream) as session:
            # 发送初始化请求，完成 MCP 协议的握手
            await session.initialize()

            # 3. 获取工具列表
            # 请求服务器列出所有可用的工具
            tools = await session.list_tools()
            # 遍历工具列表，提取并打印每个工具的名称
            print([tool.name for tool in tools.tools])

            # 4. 调用具体工具
            # 调用名为 "get_available_stock" 的工具
            # 传入参数字典，查询 SKU 为 "SKU-1001" 的商品库存
            result = await session.call_tool(
                "get_available_stock",
                arguments={"sku_code": "SKU-1001"},
            )
            # 打印工具执行后的返回结果
            print(result)


# 使用 asyncio 运行主异步函数
asyncio.run(main())

连接本地 STDIO Server

import asyncio

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(
    command="python",
    args=["inventory_mcp_server.py"],
)


async def main():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([tool.name for tool in tools.tools])


asyncio.run(main())

这两段代码说明了一件很重要的事：

在 Python 里，MCP Server 不一定要嵌进某个大框架里，它既可以是本地子进程，也可以是远程 HTTP 服务。

也就是说，MCP 在 Python 生态里天然适合：

• 脚本化能力开放
• 数据处理任务开放
• CLI 工具开放
• Web 服务能力开放

4. 如果你已经有 FastAPI / Starlette / ASGI 应用怎么办？

这恰恰是 Python 技术栈的一个优势场景。

官方 Python SDK 支持把 MCP 的 Streamable HTTP 服务 挂载到现有 ASGI 应用 上，也就是你不一定非要单独再开一个独立服务。

import contextlib

from starlette.applications import Starlette
from starlette.routing import Mount

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-app", json_response=True)


@mcp.tool()
def hello() -> str:
    return "Hello from MCP!"


@contextlib.asynccontextmanager
async def lifespan(app: Starlette):
    async with mcp.session_manager.run():
        yield


app = Starlette(
    routes=[
        Mount("/mcp", app=mcp.streamable_http_app()),
    ],
    lifespan=lifespan,
)

这段代码非常适合已有项目改造，因为它意味着：

• 你原来的 Web 服务不用推倒重来
• 只是在现有应用上增加一个 MCP 接口面
• 原有业务逻辑依然在原来的服务 / 数据访问 / API 层里

如果你本来就是 FastAPI / Starlette / 其他 ASGI 体系，这种挂载方式会特别丝滑。

5. Python 为什么很适合做 MCP 落地？

我认为有四个原因：

1. 协议贴近实现：官方 SDK 很直接，概念映射清晰
2. 脚本和服务都能接：既能封装脚本，也能封装 Web 服务
3. AI 生态天然集中在 Python：Agent、数据、模型集成通常都在 Python 里先成熟
4. 改造成本低：已有脚本、数据管道、内部服务都能比较自然地包成 MCP Server

6. 一个非常实用的 Python 落地建议

如果你第一次在 Python 项目里接 MCP，推荐顺序是：

1. 先用 FastMCP 暴露 1 个最简单的查询型 tool
2. 返回稳定、结构化、字段清晰的 JSON 结果
3. 本地先用 stdio_client 跑通联调
4. 确认工具命名、参数描述、异常语义都稳定后，再升级成 streamable-http
5. 最后再补认证、审计、限流、版本控制

这样做的好处是：你能先把"协议通不通"和"AI 调得准不准"分开验证，而不会一开始就被工程复杂度拖住。

---

🔐 八、MCP 协议安全性设计包含哪些层面？

MCP 的安全设计，绝对不能只理解成"接口加个 token"。

因为它面对的是：

• 工具调用
• 数据读取
• 本地进程启动
• 远程 HTTP 会话
• OAuth 授权代理
• 多客户端、多租户、多系统边界

所以它的安全问题比普通 REST API 更"立体"。

1. 安全设计的 6 个层面

层面	重点问题	核心措施
传输安全	怎么防本地/网络劫持	STDIO、TLS、Origin 校验、localhost 绑定
身份与授权	谁能调用哪些能力	HTTP 传输走授权规范、最小权限、作用域控制
会话安全	会话 ID 会不会被冒用	安全 Session ID、过期/轮换、不要把 Session 当认证
工具安全	工具是否可造成破坏	参数校验、命令白名单、沙箱、限权执行
用户同意	用户是否知道自己授权了什么	显式 consent、作用域展示、危险操作确认
审计治理	出问题能不能追踪	日志、调用链、请求主体、结果留痕

2. 远程 HTTP 模式下，官方特别强调的点

对于 Streamable HTTP，官方规范特别强调了几件事：

（1）校验 Origin，防 DNS Rebinding

如果你的 MCP Server 暴露在 HTTP 上，而你又没有做 Origin 校验，浏览器侧恶意页面可能借机攻击本地服务。

（2）本地运行时尽量只绑定 localhost

不要默认监听 0.0.0.0。很多"我只是本地调试"的服务，最后都死在这个习惯上。

（3）应有正式认证机制

远程 HTTP 模式下，不应该把"知道 URL"当作安全边界。

（4）STDIO 和 HTTP 的认证思路不同

这点很容易被忽略。

• HTTP 传输：应遵循 MCP 的授权框架，通常走更正式的认证与授权流程
• STDIO 传输：官方更倾向于从本地环境中读取凭证，而不是硬套 HTTP 那一套授权流程

这背后的原因很简单：本地子进程模式和远程 HTTP 服务模式，本来就处在不同的信任边界里。

3. MCP 官方安全文档里特别值得记住的几个风险点

⚠️ 风险一：Confused Deputy（代理混淆）

如果一个 MCP Server 代用户去访问第三方 API，但没有做好 逐客户端同意（per-client consent），就可能出现"用户原本授权给 A，结果被 B 借壳利用"的问题。

⚠️ 风险二：Token Passthrough

这是一种被官方明确反对的反模式。

意思是：

• 客户端把 token 交给 MCP Server
• MCP Server 不验证 token 是否本来就是发给自己的
• 然后直接把 token 透传给下游 API

这会导致：

• 审计边界混乱
• 安全控制被绕过
• 下游信任边界被破坏

正确思路应该是：

MCP Server 只接受明确签发给自己的凭证，不做"无脑透传代理"。

⚠️ 风险三：Session Hijacking

尤其在有状态 HTTP 服务、多实例部署、可恢复流场景下，如果 Session ID 被截获，攻击者可能冒充原客户端继续收发消息。

所以：

• Session ID 要足够随机且不可预测
• Session 不能直接当认证凭据
• 可以绑定用户身份上下文
• 要有过期与轮换机制

⚠️ 风险四：本地 MCP Server 被恶意命令利用

如果客户端支持"一键安装本地 MCP Server"，却不向用户展示将执行的命令，那风险非常高。

比如恶意启动命令里可能带：

• 敏感文件读取
• 网络外传
• 提权命令
• 删除本地文件

所以本地模式必须关注：

• 明确展示启动命令
• 用户显式确认
• 进程最小权限运行
• 文件系统 / 网络沙箱隔离

⚠️ 风险五：作用域过大

如果一个 MCP Server 上来就申请 files:*、db:*、admin:* 这种大而全作用域，那么 token 一旦泄露，影响面会非常大。

正确做法是：

• scope 尽量细粒度
• 按能力拆授权
• 高风险能力单独提权
• 不要把"所有能力"打成一个超级 scope

4. 一套更接地气的安全落地建议

对本地 STDIO MCP Server

• 优先用 STDIO 而不是额外开本地 HTTP 端口
• 用独立低权限账号运行高风险工具
• 严控可访问目录和可执行命令
• 给危险工具加显式确认

对远程 Streamable HTTP MCP Server

• 必做认证与授权
• 校验 Origin
• 控制 CORS / 网关暴露面
• 做限流、审计、告警
• 做会话过期与销毁
• 对高危 Tool 设置二次确认

一句话总结：

MCP 的安全边界不是"协议自动帮你解决"，而是"协议给了你应该治理哪些边界"。

---

🔄 九、如何将已有的应用转换成 MCP 服务？

这是企业里最实际的问题。

很多系统已经存在多年，里面有大量：

• REST API
• RPC 服务
• 数据访问层
• 批处理任务
• 搜索 / 报表 / 工单 / 审批能力

这时候你不应该推倒重来，而应该做一层 MCP 适配层。

1. 先记住一句原则

把已有应用转换成 MCP 服务，不是重写业务系统，而是为业务系统增加一层"AI 友好接口层"。

也就是说，大多数时候你不需要动原有核心领域逻辑，只要在外面包一层协议适配即可。

2. 推荐的改造步骤

Step 1：先盘点哪些能力适合暴露给 AI

不是所有接口都适合直接变成 MCP Tool。

优先挑这几类：

• 幂等查询能力
• 风险可控的写操作
• 可解释、参数清晰的业务动作
• 高频问答依赖的数据读取能力

不建议第一批就暴露：

• 高危删除类操作
• 参数极复杂、上下文强依赖的内部接口
• 没有审计与权限控制的管理接口

Step 2：把能力映射成 Tool / Resource / Prompt

很多团队一上来只会想到 Tool，其实应该按语义分类：

原有能力	更适合映射成什么	原因
查询库存、查订单状态	Tool 或 Resource	看你是强调执行动作还是读取上下文
读取制度文档、配置模板	Resource	天然是上下文内容
代码审查模板、客服回复模板	Prompt	适合作为可复用提示资产
创建工单、审批、发起发布	Tool	这是明确的执行动作

一个简单判断标准

• 会产生动作副作用：优先 Tool
• 本质是拿一段上下文：优先 Resource
• 本质是复用提示套路：优先 Prompt

Step 3：为 AI 重构接口语义，而不是直接搬内部 API

原有内部 API 往往是给前端页面、服务间调用设计的，不一定适合直接暴露给 AI。

比如内部接口可能长这样：

POST /api/order/query/detailAndRiskAndRecommend

入参里一堆技术字段、分页标志、UI 兼容开关、版本参数。

这类接口直接暴露成 MCP Tool，模型很难稳定调用。

更好的做法是做一个"AI 语义友好版"封装：

@mcp.tool()
def get_order_status(order_no: str) -> dict:
    return order_facade.query_for_ai(order_no)

核心思想是：

• 面向 AI 重新设计入参
• 返回更稳定、更语义化的结构
• 隐藏原系统里与 AI 无关的技术噪音

Step 4：把权限与审计前置，不要后补

MCP 一旦接入，AI 就会具备"间接调用业务动作"的能力。

所以必须提前设计：

• 哪些用户能看到哪些 Tool
• 哪些 Tool 需要审批或二次确认
• 写操作是否需要审计日志
• 是否按租户 / 部门 / 项目做隔离

Step 5：先做小而稳，再做大而全

推荐的第一批改造策略：

• 先选 3~5 个高价值、低风险能力
• 优先查询类 Tool / Resource
• 跑通真实 AI 场景
• 观察调用质量、参数稳定性、错误率
• 再扩到更多业务域

Step 6：把 MCP Server 当"产品"运营，而不是只当接口

一个成熟的 MCP Server，最终要考虑的不只是"能不能调通"，还包括：

• Tool 命名是否清晰
• 参数描述是否足够明确
• 返回结构是否稳定
• 错误信息是否有助于模型修正
• 是否有版本管理策略
• 是否可观测、可审计、可限流

3. 一个通用改造架构图

已有应用

REST API / RPC / DB / 领域服务
AI 适配层

参数收敛 / 权限 / 审计 / DTO 封装
MCP Server
MCP Client
Host / Agent / IDE / AI 助手

这个图背后的关键点是：

MCP Server 最好不要直接裸连底层复杂系统，中间最好有一层 AI 适配层。

因为真正决定 AI 使用体验的，往往不是协议本身，而是这层"把业务世界翻译给 AI"的能力。

---

📊 十、Python + MCP 的实战落地路线图

如果你准备在团队里推动这件事，我建议按照下面顺序来落地：

第一阶段：做最小闭环

• 选一个简单查询场景
• 用 FastMCP 暴露一个最小查询型 tool
• 用本地或测试环境 Host 连起来
• 验证工具发现、调用、返回链路

第二阶段：做 AI 友好的结果结构

• 收敛返回字段
• 增加清晰的参数描述
• 为常见错误提供结构化错误信息
• 观察模型是否稳定选对工具、传对参数

第三阶段：做治理能力

• 认证与授权
• 审计日志
• 限流与超时
• 敏感 Tool 二次确认
• 版本控制

第四阶段：做平台化

• 统一 MCP 网关 / 注册机制
• 工具目录与说明文档
• 多业务域 MCP Server 治理
• 可观测性与 SLA

---

✅ 十一、面试 / 汇报时可以怎么回答？

如果面试官或者团队同学突然问你"什么是 MCP"，你可以直接按下面这套模板答。

1. 30 秒版本

MCP 是一个让 AI 应用以标准协议连接外部工具、资源和 Prompt 的开放协议。

它基于 Client-Server 架构，底层一般用 JSON-RPC 通信，支持本地 STDIO 和远程 Streamable HTTP 两种主要传输模式。相比单纯的 Function Calling，MCP 更关注能力发现、生命周期协商、标准化接入和安全治理，适合多工具、多系统、平台化的 AI 集成场景。

2. 90 秒版本

MCP 可以理解成 AI 世界里的标准连接协议。Host 是 AI 应用本身，Host 会为每个 MCP Server 建一个 MCP Client。Server 侧可以暴露 Tool、Resource、Prompt 等能力。客户端连接后会先初始化和协商能力，再发现可用能力，最后按协议完成调用。

它和 Function Calling 的区别在于：Function Calling 更偏模型 API 层，关注单次函数调用；MCP 更偏系统协议层，关注标准化连接和能力治理。像官方 Python SDK 这样的实现，已经能比较方便地接入 MCP，既可以把现有 Python 服务或脚本暴露成 MCP Server，也可以把外部 MCP 工具接进你的 Python Agent 或应用里。

---

📚 十二、速查表：把本文 8 个问题一次收口

问题	一句话答案
什么是 MCP 协议，它在 AI 大模型系统中的作用是什么？	MCP 是 AI 应用连接外部工具、资源和 Prompt 的标准协议，解决"模型如何稳定接入外部世界"的问题。
MCP 架构包含哪些核心组件？	运行时上有 Host、Client、Server；能力上有 Tools、Resources、Prompts，以及生命周期、授权、通知等协议能力。
MCP 协议支持哪两种模式？	标准传输模式是 STDIO 和 Streamable HTTP。
MCP 与 Function Calling 的区别是什么？	Function Calling 偏模型调用层；MCP 偏系统集成层与工具协议层。
MCP 的工作流程是什么？	连接 -> 初始化 -> 能力协商 -> 发现工具/资源 -> 发起调用 -> 返回结构化结果 -> 模型继续推理。
在 Python 技术栈中如何集成 MCP？	可以用官方 Python SDK / FastMCP 把现有 Python 服务或脚本暴露成 MCP Server，也可以用 ClientSession 连接外部 MCP Server。
MCP 协议安全性设计包含哪些层面？	传输、认证授权、会话、工具执行、用户同意、审计治理六个层面。
如何将已有的应用转换成 MCP 服务？	给原系统加一层 AI 适配层，把合适能力映射成 Tool/Resource/Prompt，并补齐权限、审计、限流与返回结构设计。

---

🎯 总结

到这里，你可以把 MCP 理解成一句话：

它不是某个模型的小功能，而是 AI 系统接入外部世界的协议基础设施。

它真正重要的地方，不在于"能不能调函数"，而在于它把下面这些事情统一起来了：

• 能力如何暴露
• 能力如何发现
• 能力如何调用
• 能力如何治理
• 能力如何跨客户端复用

对于企业系统来说，MCP 最有价值的意义并不是"新潮"，而是：

它给现有系统提供了一条走向 AI 原生集成的标准化路径。

如果你现在已经在用 Python、FastAPI、脚本平台或数据处理服务，那么完全可以从一个最小查询工具开始，把现有业务系统先包装成一个小型 MCP Server，再逐步扩展成你们自己的 AI 能力平台。

---

🔗 参考资料

• MCP Architecture Overview: https://modelcontextprotocol.io/docs/learn/architecture
• MCP Specification Overview（2025-11-25 latest）: https://modelcontextprotocol.io/specification/2025-11-25/basic/index
• MCP Transports（当前标准传输）: https://modelcontextprotocol.io/specification/2025-11-25/basic/transports
• MCP Authorization（2025-11-25 latest）: https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization
• MCP Security Best Practices: https://modelcontextprotocol.io/docs/tutorials/security/security_best_practices
• MCP Python SDK 文档: https://py.sdk.modelcontextprotocol.io/
• MCP Python SDK Server 文档: https://py.sdk.modelcontextprotocol.io/server/
• MCP Python SDK Client 文档: https://py.sdk.modelcontextprotocol.io/client/
• MCP Python SDK 官方仓库: https://github.com/modelcontextprotocol/python-sdk