add unit 0-2

Author: xxg1413

README.md

@@ -1,2 +1,81 @@
-# mcp-course-cn
-huggingface mcp-course 中文版 
+# Model Context Protocol (MCP) 课程 | MCP Course
+
+![MCP 课程横幅](https://github.com/user-attachments/assets/d26dcc5e-46cb-449e-aecb-49ece10d342a)
+
+
+## 中文版
+
+这是 [HuggingFace Model Context Protocol (MCP) 课程](https://github.com/huggingface/mcp-course) 的中文翻译项目。
+
+如果您喜欢本课程，**请不要犹豫，为这个仓库⭐点亮星标**。这有助于我们**让课程获得更多关注🤗**。
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/please_star.gif" alt="为仓库点亮星标" />
+
+### 项目概述
+
+模型上下文协议（Model Context Protocol，简称MCP）是一种标准化协议，它使AI模型能够无缝地与外部工具和数据源交互。本课程提供了对MCP的全面介绍，从基础知识到实际应用。
+
+### 课程内容
+
+本课程分为4个单元。这些单元将带您**从模型上下文协议的基础知识，到最终在AI应用中实现MCP的项目**。
+
+| 单元   | 主题                    | 描述                                                       |
+| ------- | ----------------------- | --------------------------------------------------------- |
+| 0       | 欢迎来到课程            | 欢迎，指南，必要工具和课程概述                             |
+| 1       | 模型上下文协议介绍      | MCP的定义，关键概念，以及其在连接AI模型与外部数据和工具中的作用 |
+| 2       | 使用MCP构建：实践开发   | 学习使用可用的SDK和框架实现MCP客户端和服务器              |
+| 3       | 高级用例               | 即将推出                                                  |
+| 4       | 社区集成               | 即将推出                                                  |
+
+### 先决条件
+
+* 对AI和LLM概念的基本理解
+* 熟悉软件开发原则和API概念
+* 至少熟悉一种编程语言（将着重介绍Python或TypeScript示例）
+
+### 项目结构
+
+当前项目结构如下：
+
+```
+mcp-course-cn/
+├── units/
+│   ├── zh/        # 中文版课程内容
+│   │   ├── unit0/ # 单元0：课程介绍
+│   │   ├── unit1/ # 单元1：MCP基础
+│   │   ├── unit2/ # 单元2：端到端MCP应用
+│   │   ├── unit3/ # 单元3：高级用例
+│   │   ├── unit4/ # 单元4：社区集成
+│   │   └── _toctree.yml # 目录结构
+│   └── en/        # 英文原版课程内容
+├── LICENSE        # 许可证
+├── README.md      # 说明文件
+└── requirements.txt # 依赖项
+```
+
+### 学习使用
+
+#### 在线学习
+
+正式发布后，可通过以下链接访问在线课程：
+- [在线课程链接] - 即将推出
+
+#### 本地学习
+
+您可以通过克隆本仓库来本地学习课程内容：
+
+```bash
+git clone https://github.com/yourusername/mcp-course-cn.git
+cd mcp-course-cn
+```
+
+### 贡献指南
+
+如果您发现任何翻译错误或有改进建议，欢迎提交问题或拉取请求。对于特定的贡献，以下是一些指南：
+
+
+### 致谢
+
+感谢原课程作者提供的优质内容，以及所有参与翻译和审阅的贡献者。
+
+

requirements.txt

@@ -0,0 +1,3 @@
+hf-doc-builder>=0.5.0
+mdx_truly_sane_lists
+pyyaml 

units/en/_toctree.yml

@@ -0,0 +1,46 @@
+- title: "0. Welcome to the MCP Course"
+  sections:
+  - local: unit0/introduction
+    title: Welcome to the MCP Course
+    
+- title: "1. Introduction to Model Context Protocol"
+  sections:
+  - local: unit1/introduction
+    title: Introduction to Model Context Protocol (MCP)
+  - local: unit1/key-concepts
+    title: Key Concepts and Terminology
+  - local: unit1/architectural-components
+    title: Architectural Components
+  - local: unit1/communication-protocol
+    title: The Communication Protocol
+  - local: unit1/capabilities
+    title: Understanding MCP Capabilities
+  - local: unit1/sdk
+    title: MCP SDK
+  - local: unit1/mcp-clients
+    title: MCP Clients
+  - local: unit1/gradio-mcp
+    title: Gradio MCP Integration
+
+- title: "2. Use Case: End-to-End MCP Application"
+  sections:
+  - local: unit2/introduction
+    title: Introduction to Building an MCP Application
+  - local: unit2/gradio-server
+    title: Building the Gradio MCP Server
+  - local: unit2/clients
+    title: Using MCP Clients with your application
+  - local: unit2/gradio-client
+    title: Building an MCP Client with Gradio
+  - local: unit2/tiny-agents
+    title: Building a Tiny Agent with TypeScript
+
+- title: "3. Use Case: Advanced MCP Development"
+  sections:
+  - local: unit3/introduction
+    title: Coming Soon
+
+- title: "Bonus Units"
+  sections:
+  - local: unit4/introduction
+    title: Coming Soon

units/en/unit0/introduction.mdx

@@ -0,0 +1,139 @@
+# Welcome to the 🤗 Model Context Protocol (MCP) Course
+
+![MCP Course thumbnail](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/1.png)
+
+Welcome to the most exciting topic in AI today: **Model Context Protocol (MCP)**!
+
+This free course will take you on a journey, **from beginner to informed**, in understanding, using, and building applications with MCP.
+
+This first unit will help you onboard:
+
+* Discover the **course's syllabus**.
+* **Get more information about the certification process and the schedule**.
+* Get to know the team behind the course.
+* Create your **account**.
+* **Sign-up to our Discord server**, and meet your classmates and us.
+
+Let's get started!
+
+## What to expect from this course?
+
+In this course, you will:
+
+* 📖 Study Model Context Protocol in **theory, design, and practice.**
+* 🧑‍💻 Learn to **use established MCP SDKs and frameworks**.
+* 💾 **Share your projects** and explore applications created by the community.
+* 🏆 Participate in challenges where you will **evaluate your MCP implementations against other students'.**
+* 🎓 **Earn a certificate of completion** by completing assignments.
+
+And more!
+
+At the end of this course, you'll understand **how MCP works and how to build your own AI applications that leverage external data and tools using the latest MCP standards**.
+
+Don't forget to [**sign up to the course!**](https://huggingface.co/mcp-course)
+
+## What does the course look like?
+
+The course is composed of:
+
+* _Foundational Units_: where you learn MCP **concepts in theory**.
+* _Hands-on_: where you'll learn **to use established MCP SDKs** to build your applications. These hands-on sections will have pre-configured environments.
+* _Use case assignments_: where you'll apply the concepts you've learned to solve a real-world problem that you'll choose.
+* _Collaborations_: We're collaborating with Hugging Face's partners to give you the latest MCP implementations and tools.
+ 
+This **course is a living project, evolving with your feedback and contributions!** Feel free to open issues and PRs in GitHub, and engage in discussions in our Discord server.
+
+After you have gone through the course, you can also send your feedback 👉 using this form [LINK TO FEEDBACK FORM]
+
+## What's the syllabus?
+
+Here is the **general syllabus for the course**. A more detailed list of topics will be released with each unit.
+
+| Chapter | Topic                                       | Description                                                                                                            |
+| ------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| 0       | Onboarding                                  | Set you up with the tools and platforms that you will use.                                                             |
+| 1       | MCP Fundamentals, Architecture and Core Concepts | Explain core concepts, architecture, and components of Model Context Protocol. Show a simple use case using MCP.       |
+| 2       | End-to-end Use case: MCP in Action              | Build a simple end-to-end MCP application that you can share with the community. |
+| 3       | Deployed Use case: MCP in Action               | Build a deployed MCP application using a the Hugging Face ecosystem and partners' services.                                        |
+| 4       | Bonus Units                                  | Bonus units to help you get more out of the course, working with partners' libraries and services.                                        |
+
+## What are the prerequisites?
+
+To be able to follow this course, you should have:
+
+* Basic understanding of AI and LLM concepts
+* Familiarity with software development principles and API concepts
+* Experience with at least one programming language (Python or TypeScript examples will be shown)
+
+If you don't have any of these, don't worry! Here are some resources that can help you:
+
+* [LLM Course](https://huggingface.co/learn/llm-course/) will guide you through the basics of using and building with LLMs.
+* [Agents Course](https://huggingface.co/learn/agents-course/) will guide you through building AI agents with LLMs.
+
+<Tip>
+
+The above courses are not prerequisites in themselves, so if you understand the concepts of LLMs and agents, you can start the course now!
+
+</Tip>
+
+## What tools do I need?
+
+You only need 2 things:
+
+* _A computer_ with an internet connection.
+* An _Account_: to access the course resources and create projects. If you don't have an account yet, you can create one [here](https://huggingface.co/join) (it's free).
+
+## The Certification Process
+
+You can choose to follow this course _in audit mode_, or do the activities and _get one of the two certificates we'll issue_. If you audit the course, you can participate in all the challenges and do assignments if you want, and **you don't need to notify us**.
+
+The certification process is **completely free**:
+
+* _To get a certification for fundamentals_: you need to complete Unit 1 of the course. This is intended for students that want to get up to date with the latest trends in MCP, without the need to build a full application.
+* _To get a certificate of completion_: you need to complete the use case units (2 and 3). This is intended for students that want to build a full application and share it with the community.
+
+## What is the recommended pace?
+
+Each chapter in this course is designed **to be completed in 1 week, with approximately 3-4 hours of work per week**.
+
+Since there's a deadline, we provide you a recommended pace:
+
+![Recommended Pace](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/2.png)
+
+## How to get the most out of the course?
+
+To get the most out of the course, we have some advice:
+
+1. Join study groups in Discord: studying in groups is always easier. To do that, you need to join our discord server and verify your account.
+2. **Do the quizzes and assignments**: the best way to learn is through hands-on practice and self-assessment.
+3. **Define a schedule to stay in sync**: you can use our recommended pace schedule below or create yours.
+
+![Course advice](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/3.png)
+
+## Who are we
+
+About the authors:
+
+### Ben Burtenshaw
+
+Ben is a Machine Learning Engineer at Hugging Face who focuses building LLM applications, with post training and agentic approaches.
+
+<!-- ## Acknowledgments -->
+
+<!-- We would like to extend our gratitude to the following individuals and partners for their invaluable contributions and support: -->
+
+<!-- TODO: @burtenshaw add contributors and partners -->
+
+## I found a bug, or I want to improve the course
+
+Contributions are **welcome** 🤗
+
+* If you _found a bug 🐛 in a notebook_, please open an issue and **describe the problem**.
+* If you _want to improve the course_, you can open a Pull Request.
+* If you _want to add a full section or a new unit_, the best is to open an issue and **describe what content you want to add before starting to write it so that we can guide you**.
+
+## I still have questions
+
+Please ask your question in our discord server #mcp-course-questions.
+
+Now that you have all the information, let's get on board ⛵ 

units/en/unit1/architectural-components.mdx

@@ -0,0 +1,85 @@
+# Architectural Components of MCP
+
+In the previous section, we discussed the key concepts and terminology of MCP. Now, let's dive deeper into the architectural components that make up the MCP ecosystem.
+
+## Host, Client, and Server
+
+The Model Context Protocol (MCP) is built on a client-server architecture that enables structured communication between AI models and external systems. 
+
+![MCP Architecture](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/4.png)
+
+The MCP architecture consists of three primary components, each with well-defined roles and responsibilities: Host, Client, and Server. We touched on these in the previous section, but let's dive deeper into each component and their responsibilities.
+
+### Host
+
+The **Host** is the user-facing AI application that end-users interact with directly. 
+
+Examples include:
+- AI Chat apps like OpenAI ChatGPT or Anthropic's Claude Desktop
+- AI-enhanced IDEs like Cursor, or integrations to tools like Continue.dev
+- Custom AI agents and applications built in libraries like LangChain or smolagents
+
+The Host's responsibilities include:
+- Managing user interactions and permissions
+- Initiating connections to MCP Servers via MCP Clients
+- Orchestrating the overall flow between user requests, LLM processing, and external tools
+- Rendering results back to users in a coherent format
+
+In most cases, users will select their host application based on their needs and preferences. For example, a developer may choose Cursor for its powerful code editing capabilities, while domain experts may use custom applications built in smolagents.
+
+### Client
+
+The **Client** is a component within the Host application that manages communication with a specific MCP Server. Key characteristics include:
+
+- Each Client maintains a 1:1 connection with a single Server
+- Handles the protocol-level details of MCP communication
+- Acts as the intermediary between the Host's logic and the external Server
+
+### Server
+
+The **Server** is an external program or service that exposes capabilities to AI models via the MCP protocol. Servers:
+
+- Provide access to specific external tools, data sources, or services
+- Act as lightweight wrappers around existing functionality
+- Can run locally (on the same machine as the Host) or remotely (over a network)
+- Expose their capabilities in a standardized format that Clients can discover and use
+
+## Communication Flow
+
+Let's examine how these components interact in a typical MCP workflow:
+
+<Tip>
+
+In the next section, we'll dive deeper into the communication protocol that enables these components with practical examples.
+
+</Tip>
+
+1. **User Interaction**: The user interacts with the **Host** application, expressing an intent or query.
+
+2. **Host Processing**: The **Host** processes the user's input, potentially using an LLM to understand the request and determine which external capabilities might be needed.
+
+3. **Client Connection**: The **Host** directs its **Client** component to connect to the appropriate Server(s).
+
+4. **Capability Discovery**: The **Client** queries the **Server** to discover what capabilities (Tools, Resources, Prompts) it offers.
+
+5. **Capability Invocation**: Based on the user's needs or the LLM's determination, the Host instructs the **Client** to invoke specific capabilities from the **Server**.
+
+6. **Server Execution**: The **Server** executes the requested functionality and returns results to the **Client**.
+
+7. **Result Integration**: The **Client** relays these results back to the **Host**, which incorporates them into the context for the LLM or presents them directly to the user.
+
+A key advantage of this architecture is its modularity. A single **Host** can connect to multiple **Servers** simultaneously via different **Clients**. New **Servers** can be added to the ecosystem without requiring changes to existing **Hosts**. Capabilities can be easily composed across different **Servers**.
+
+<Tip>
+
+As we discussed in the previous section, this modularity transforms the traditional M×N integration problem (M AI applications connecting to N tools/services) into a more manageable M+N problem, where each Host and Server needs to implement the MCP standard only once.
+
+</Tip>
+
+The architecture might appear simple, but its power lies in the standardization of the communication protocol and the clear separation of responsibilities between components. This design allows for a cohesive ecosystem where AI models can seamlessly connect with an ever-growing array of external tools and data sources.
+
+## Conclusion
+
+These interaction patterns are guided by several key principles that shape the design and evolution of MCP. The protocol emphasizes **standardization** by providing a universal protocol for AI connectivity, while maintaining **simplicity** by keeping the core protocol straightforward yet enabling advanced features. **Safety** is prioritized by requiring explicit user approval for sensitive operations, and discoverability enables dynamic discovery of capabilities. The protocol is built with **extensibility** in mind, supporting evolution through versioning and capability negotiation, and ensures **interoperability** across different implementations and environments.
+
+In the next section, we'll explore the communication protocol that enables these components to work together effectively.