first draft

.github/workflows/build_documentation.yml

@@ -0,0 +1,18 @@
+name: Build documentation
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@main
+    with:
+      commit_sha: ${{ github.sha }}
+      package: mcp-course
+      path_to_docs: units
+      build_command: doc-builder build mcp-course units --build_dir build/mcp-course
+      deploy_to_hub: true
+      languages: en 

.github/workflows/build_pr_documentation.yml

@@ -0,0 +1,19 @@
+name: Build PR Documentation
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@main
+    with:
+      commit_sha: ${{ github.event.pull_request.head.sha }}
+      pr_number: ${{ github.event.number }}
+      package: mcp-course
+      path_to_docs: units
+      additional_args: --not_python_module
+      languages: en 

README.md

@@ -0,0 +1,51 @@
+# The Model Context Protocol (MCP) Course
+
+If you like the course, **don't hesitate to ⭐ star this repository**. This helps us to **make the course more visible 🤗**.
+
+## Content
+
+The course is divided into 4 units. These will take you from **the basics of Model Context Protocol to a final project implementing MCP in an AI application**.
+
+Sign up here (it's free) 👉 [Coming Soon]
+
+You can access the course here 👉 [Coming Soon]
+
+| Unit    | Topic                                               | Description                                                                                             |
+| ------- | --------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| 0       | Welcome to the Course                               | Welcome, guidelines, necessary tools, and course overview.                                              |
+| 1       | Introduction to Model Context Protocol              | Definition of MCP, key concepts, and its role in connecting AI models with external data and tools.     |
+| 2       | Understanding MCP Architecture and Core Concepts    | Explore the MCP architecture, communication protocols, and core primitives.                             |
+| 3       | Building with MCP: Practical Development            | Learn to implement MCP clients and servers using available SDKs and frameworks.                         |
+| 4       | Advanced Topics, Security, and the Future of MCP    | Explore advanced features, security considerations, and the future roadmap of MCP.                      |
+
+## Prerequisites
+
+* 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 emphasized)
+
+## Contribution Guidelines
+
+If you want to contribute to this course, you're welcome to do so. Feel free to open an issue or submit a pull request. For specific contributions, here are some guidelines:
+
+### Small typo and grammar fixes
+
+If you find a small typo or grammar mistake, please fix it yourself and submit a pull request. This is very helpful for students.
+
+### New unit
+
+If you want to add a new unit, **please create an issue in the repository, describe the unit, and why it should be added**. We will discuss it and if it's a good addition, we can collaborate on it.
+
+## Citing the project
+
+To cite this repository in publications:
+
+```
+@misc{mcp-course,
+  author = {Your Name},
+  title = {The Model Context Protocol Course},
+  year = {2025},
+  howpublished = {\url{https://github.com/yourusername/mcp-course}},
+  note = {GitHub repository},
+}
+``` 

requirements.txt

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

units/en/_toctree.yml

@@ -0,0 +1,74 @@
+- 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/what-is-mcp
+    title: What is Model Context Protocol (MCP)?
+  - local: unit1/key-concepts
+    title: Key Concepts and Terminology
+  - local: unit1/quiz1
+    title: Unit 1 Quiz
+
+- title: "2. Understanding MCP Architecture and Core Concepts"
+  sections:
+  - local: unit2/introduction
+    title: Understanding MCP Architecture and Core Concepts
+  - local: unit2/architectural-components
+    title: Architectural Components
+  - local: unit2/communication-protocol
+    title: The Communication Protocol
+  - local: unit2/capabilities
+    title: Understanding MCP Capabilities
+  - local: unit2/quiz2
+    title: Unit 2 Quiz
+
+- title: "3. Building with MCP: Practical Development"
+  sections:
+  - local: unit3/introduction
+    title: Introduction
+  - local: unit3/environment-setup
+    title: Setting Up Your Development Environment & SDKs
+  - local: unit3/building-server
+    title: Building Your First MCP Server
+  - local: unit3/server-capabilities
+    title: Implementing Server Capabilities
+  - local: unit3/developing-clients
+    title: Developing MCP Clients
+  - local: unit3/configuration
+    title: Configuration, Authentication, and Debugging
+  - local: unit3/mcp-ecosystem
+    title: Navigating the MCP Ecosystem
+  - local: unit3/gradio-mcp
+    title: "Hugging Face Gradio MCP Integration"
+  - local: unit3/hub-mcp-servers
+    title: "Working with MCP Servers on Hugging Face Hub"
+  - local: unit3/tiny-agents-mcp
+    title: "Building with Tiny Agents and MCP"
+  - local: unit3/practical-exercise
+    title: "Practical Exercise: MCP Interaction Walkthrough"
+  - local: unit3/quiz
+    title: Unit 3 Quiz
+
+- title: "4. Advanced Topics, Security, and the Future of MCP"
+  sections:
+  - local: unit4/introduction
+    title: Introduction
+  - local: unit4/advanced-features
+    title: Exploring Advanced MCP Features
+  - local: unit4/security
+    title: Security Deep Dive - Threats and Mitigation Strategies
+  - local: unit4/limitations
+    title: Limitations, Challenges, and Comparisons
+  - local: unit4/huggingface-ecosystem
+    title: Hugging Face's Ecosystem and Future Contributions
+  - local: unit4/future
+    title: The Future of MCP - Roadmap and Standardization
+  - local: unit4/final-project
+    title: Final Project - Building a Complete MCP Application
+  - local: unit4/certification
+    title: Certification and Next Steps 

units/en/unit0/_toctree.yml

@@ -0,0 +1,13 @@
+- title: 0. Setup
+  sections:
+  - local: unit0/introduction
+    title: Welcome to the MCP Course
+  - local: unit0/onboarding
+    title: 🤗 Onboarding (Optional)
+  - local: unit0/discord
+    title: Discord 101
+
+- title: Live Session 1
+  sections:
+  - local: unit0/livesession1
+    title: How the course works and Q&A 

units/en/unit0/introduction.mdx

@@ -0,0 +1,153 @@
+# Welcome to the 🤗 Model Context Protocol (MCP) Course
+
+![MCP Course thumbnail](https://placeholder-for-mcp-course-thumbnail.com/image.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 expert**, in understanding, using, and building applications with MCP.
+
+This first unit will help you onboard:
+
+* Discover the **course's syllabus**.
+* **Choose the path** you're going to take (either self-audit or certification process).
+* **Get more information about the certification process and the deadlines**.
+* 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!**
+
+(We are respectful of your privacy. We collect your email address to be able to **send you the links when each Unit is published and give you information about the challenges and updates**).
+
+## 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.
+* _The Challenge_: you'll get to put your implementation to compete against other implementations in a challenge. There will also be a leaderboard for you to compare performance.
+
+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                            | Explain core concepts, architecture, and components of Model Context Protocol. Show a simple use case using MCP.       |
+| 2       | Architecture and Core Concepts              | Understand the MCP architecture, communication protocols, and core primitives like Tools, Resources, and Prompts.      |
+| 3       | Practical Development                       | Learn to implement MCP clients and servers using available SDKs and frameworks.                                        |
+| 4       | Advanced Topics and Security                | Explore advanced features, security considerations, and the future roadmap of MCP.                                     |
+
+## 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 emphasized)
+
+## 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** (it's free).
+
+## The Certification Process
+
+### Two paths 
+
+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.
+* _To get a certificate of completion_: you need to complete Unit 1, one of the use case assignments we'll propose during the course, and the final challenge.
+
+There's a deadline for the certification process: all the assignments must be finished before **July 1st 2025**.
+
+![Deadline](https://placeholder-for-deadline-image.com/image.png)
+
+## 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://placeholder-for-pace-image.com/image.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://placeholder-for-advice-image.com/image.png)
+
+## Who are we
+
+About the authors:
+
+### Author 1
+
+Author 1 is an AI engineer and has built and deployed MCP applications in production. Author 1 will be your main instructor for this course.
+
+* Follow Author 1 on GitHub
+* Follow Author 1 on Twitter
+* Follow Author 1 on LinkedIn
+
+### Author 2
+
+Author 2 is an AI engineer and has delivered multiple courses across various platforms. Author 2's goal is to make the course accessible to everyone.
+
+* Follow Author 2 on GitHub
+* Follow Author 2 on Twitter
+* Follow Author 2 on LinkedIn
+
+## Acknowledgments
+
+We would like to extend our gratitude to the following individuals for their invaluable contributions to this course:
+
+* **Contributor 1** – For guidance and expertise in reviewing the materials.
+* **Contributor 2** – For amazing demo applications.
+* **Contributor 3** – For help on the course content.
+
+## 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/_toctree.yml

@@ -0,0 +1,20 @@
+- title: 1. Introduction to Model Context Protocol
+  sections:
+  - local: unit1/introduction
+    title: Introduction
+  - local: unit1/what-is-mcp
+    title: What is Model Context Protocol?
+  - local: unit1/quiz1
+    title: Quick Quiz 1
+  - local: unit1/key-concepts
+    title: Key Concepts of Model Context Protocol
+  - local: unit1/integration-challenges
+    title: The Integration Challenges MCP Solves
+  - local: unit1/quiz2
+    title: Quick Quiz 2
+  - local: unit1/benefits-goals
+    title: Key Benefits and Goals of MCP
+  - local: unit1/example-project
+    title: A Simple MCP Integration Example
+  - local: unit1/finalquiz
+    title: Unit 1 Final Quiz 

units/en/unit1/introduction.mdx

@@ -0,0 +1,33 @@
+# Introduction to Model Context Protocol (MCP)
+
+Welcome to Unit 1 of the MCP Course! In this unit, we'll explore the fundamentals of Model Context Protocol.
+
+## What You Will Learn
+
+In this unit, you will:
+
+* Understand what Model Context Protocol is and why it's important
+* Learn the key concepts and terminology associated with MCP
+* Explore the integration challenges that MCP solves
+* Walk through the key benefits and goals of MCP
+* See a simple example of MCP integration in action
+
+By the end of this unit, you'll have a solid understanding of the foundational concepts of MCP and be ready to dive deeper into its architecture and implementation in the next unit.
+
+## Importance of MCP
+
+The AI ecosystem is evolving rapidly, with Large Language Models (LLMs) and other AI systems becoming increasingly capable. However, these models are often limited by their training data and lack access to real-time information or specialized tools. This limitation hinders the potential of AI systems to provide truly relevant, accurate, and helpful responses in many scenarios.
+
+This is where Model Context Protocol (MCP) comes in. MCP enables AI models to connect with external data sources, tools, and environments, allowing for the seamless transfer of information and capabilities between AI systems and the broader digital world. This interoperability is crucial for the growth and adoption of truly useful AI applications.
+
+## Overview of Unit 1
+
+Here's a brief overview of what we'll cover in this unit:
+
+1. **What is Model Context Protocol?** - We'll start by defining what MCP is and discussing its role in the AI ecosystem.
+2. **Key Concepts** - We'll explore the fundamental concepts and terminology associated with MCP.
+3. **Integration Challenges** - We'll examine the problems that MCP aims to solve, particularly the "M×N Integration Problem."
+4. **Benefits and Goals** - We'll discuss the key benefits and goals of MCP, including standardization, enhanced AI capabilities, and interoperability.
+5. **Simple Example** - Finally, we'll walk through a simple example of MCP integration to see how it works in practice.
+
+Let's dive in and explore the exciting world of Model Context Protocol! 

units/en/unit1/quiz1.mdx

@@ -0,0 +1,48 @@
+# Quick Quiz 1
+
+<CourseQuiz>
+<Question
+	question="What is the primary purpose of Model Context Protocol (MCP)?"
+	choice1="To replace all existing AI models with a single unified model"
+	choice2="To enable interoperability between AI models and external data/tools"
+	choice3="To create a new programming language for AI development"
+	choice4="To increase the training data size for all LLMs"
+	answer={2}
+/>
+
+<Question
+	question="Which of the following is NOT a common problem that MCP aims to solve?"
+	choice1="AI models' inability to access real-time information"
+	choice2="The M×N integration problem between AI apps and tools"
+	choice3="Reducing the need for AI models entirely"
+	choice4="Inconsistent implementations of tool integration"
+	answer={3}
+/>
+
+<Question
+	question="The 'USB-C for AI applications' analogy for MCP refers to:"
+	choice1="The physical hardware interface required for AI models"
+	choice2="The universal connector that enables different AI systems to plug into various data sources and tools"
+	choice3="The power delivery specifications for AI hardware"
+	choice4="The physical shape of AI processing units"
+	answer={2}
+/>
+
+<Question
+	question="Which of the following is a key component of the MCP architecture?"
+	choice1="A centralized repository of all AI training data"
+	choice2="A server that exposes capabilities like Tools, Resources, and Prompts"
+	choice3="A regulatory body that approves all AI models"
+	choice4="A hardware accelerator for AI processing"
+	answer={2}
+/>
+
+<Question
+	question="How can MCP be best described in terms of its standardization benefits?"
+	choice1="It forces all AI models to use the same training data"
+	choice2="It transforms the M×N integration problem into a more manageable M+N problem"
+	choice3="It eliminates the need for any custom integrations"
+	choice4="It prevents any further development of new AI tools"
+	answer={2}
+/>
+</CourseQuiz> 

units/en/unit1/what-is-mcp.mdx

@@ -0,0 +1,100 @@
+# What is Model Context Protocol (MCP)?
+
+Model Context Protocol (MCP) is an open standard designed to define a universal way for AI models, particularly Large Language Models (LLMs), to connect with external data sources, tools, and environments. It provides a standardized framework for AI applications to access the context they need to provide more relevant, accurate, and helpful responses.
+
+## Definition
+
+At its core, MCP refers to a set of standardized rules, conventions, and technologies that allow for structured communication between AI models and external systems. It provides the infrastructure necessary for AI systems to access information and capabilities in a secure, standardized manner.
+
+Think of MCP as the "USB-C for AI applications" – a universal connector that enables different AI systems to plug into various data sources and tools, allowing them to work together despite their inherent differences.
+
+## MCP and the Hugging Face Ecosystem
+
+Hugging Face has embraced MCP as a key standard in the AI ecosystem, offering several implementations and tools to make working with MCP more accessible:
+
+- **MCP Servers on Hugging Face**: The community has contributed various MCP servers that can be discovered, shared, and deployed directly from the Hugging Face Hub.
+- **Gradio MCP Integration**: Hugging Face's Gradio now supports MCP, allowing developers to quickly create web interfaces for their MCP-enabled applications.
+
+This integration with the Hugging Face ecosystem makes deploying and sharing MCP components more straightforward, enabling wider adoption of this important standard.
+
+## Why Do We Need MCP?
+
+### The AI Integration Challenge
+
+The AI ecosystem has expanded dramatically, with numerous models and applications designed for specific use cases:
+
+- **AI Assistants**: Like Claude, ChatGPT, and other conversational AIs
+- **Coding Assistants**: Like GitHub Copilot, Cursor, and Codeium
+- **Specialized Agents**: For document processing, data analysis, or domain-specific tasks
+- **Enterprise AI Applications**: Custom AI solutions for organizations
+- Many others with specific features and optimizations
+
+Each of these AI applications might need access to similar external systems:
+
+- **File Systems**: To read and write documents
+- **APIs**: Like GitHub, Slack, or Google Drive
+- **Databases**: For querying and retrieving structured data
+- **Custom Tools**: Organization-specific systems and functions
+
+This creates what's known as the "M×N Integration Problem" - with M different AI applications and N different tools or data sources, you potentially need M×N custom integrations without a standard.
+
+### The M×N Integration Problem
+
+Without a standard like MCP, connecting M AI applications to N external tools creates several problems:
+
+1. **Integration Complexity**: Each AI app needs custom code for each external tool (M×N integrations)
+2. **Maintenance Burden**: Changes in any tool or AI system can break multiple integrations
+3. **Inconsistent Implementations**: Each integration might handle similar functions differently
+4. **Limited Model Utility**: AI models are restricted to static training data without access to real-time context
+5. **Development Inefficiency**: Developers waste time creating redundant integrations
+
+### Benefits of MCP
+
+Model Context Protocol solves these problems by enabling:
+
+1. **Standardization**: A universal protocol for AI connectivity that replaces fragmented approaches
+2. **Simplified Integration**: Reducing complexity from M×N to M+N integrations
+3. **Enhanced AI Capabilities**: Giving models access to real-time data and specialized tools
+4. **Interoperability**: Allowing easier swapping of AI models and tools, avoiding lock-in
+5. **Improved Security**: Providing structured access patterns and potential for centralized control
+6. **Community Collaboration**: Platforms like Hugging Face enable sharing and reusing MCP components
+
+## Evolution of MCP
+
+The journey toward standardized AI connectivity has evolved through several stages:
+
+### 1. Early LLM Limitations (2020-2022)
+- AI models operated with only their training data
+- No standardized way to access external information or tools
+- Custom integrations were required for each use case
+
+### 2. Function Calling & Plugins (2022-2023)
+- Introduction of function calling APIs by OpenAI and others
+- Development of plugin ecosystems for specific AI platforms
+- Proprietary approaches dominated, leading to fragmentation
+
+### 3. Cross-Platform Standards (2023-2024)
+- Emergence of interoperability initiatives
+- Growing need for AI models to access real-time context
+- Move toward open standards for AI connectivity
+
+### 4. Model Context Protocol (2024-Present)
+- Release of MCP as an open standard initially by Anthropic
+- Growing ecosystem of clients, servers, and frameworks on platforms like Hugging Face
+- Industry collaboration on standardization efforts
+
+MCP represents the latest evolution in this journey, moving beyond proprietary solutions toward true AI interoperability.
+
+## Key Components of MCP
+
+An effective Model Context Protocol implementation typically includes these essential components:
+
+1. **Host**: The AI application that interacts with users
+2. **Client**: The component within the Host that connects to a Server
+3. **Server**: An external program that exposes capabilities
+4. **Tools**: Executable functions the AI can call
+5. **Resources**: Data sources the AI can access
+6. **Prompts**: Pre-defined templates for interactions
+7. **Transports**: Communication methods like stdio or HTTP+SSE
+
+In the next section, we'll explore these key concepts in more detail to understand how MCP works at a technical level. 

units/en/unit2/_toctree.yml

@@ -0,0 +1,14 @@
+- title: 2. Understanding MCP Architecture and Core Concepts
+  sections:
+  - local: unit2/introduction
+    title: Introduction
+  - local: unit2/architecture
+    title: MCP Architecture - Hosts, Clients, and Servers
+  - local: unit2/core-primitives
+    title: Core Primitives - Tools, Resources, Prompts, and Sampling
+  - local: unit2/communication-protocols
+    title: Communication Protocols - JSON-RPC, stdio, HTTP+SSE
+  - local: unit2/interaction-lifecycle
+    title: The MCP Interaction Lifecycle
+  - local: unit2/quiz
+    title: Unit 2 Quiz 

units/en/unit2/introduction.mdx

@@ -0,0 +1,45 @@
+# Understanding MCP Architecture and Core Concepts
+
+Welcome to Unit 2 of the MCP Course! In this unit, we'll dive deeper into the technical architecture and core concepts of the Model Context Protocol.
+
+## What You Will Learn
+
+In this unit, you will:
+
+* Understand the client-server architecture of MCP and the roles of Hosts, Clients, and Servers
+* Learn about MCP's core primitives: Tools, Resources, Prompts, and Sampling
+* Explore the communication protocols that power MCP interactions
+* Trace through a complete MCP interaction lifecycle
+* Understand how these architectural components work together in real implementations
+
+By the end of this unit, you'll have a comprehensive understanding of MCP's technical foundation, enabling you to build and integrate MCP components effectively.
+
+## Why Architecture Matters
+
+Understanding the architecture of MCP is crucial for several reasons:
+
+* **Effective Implementation**: A clear mental model of how MCP components interact allows you to implement or integrate MCP correctly.
+* **Troubleshooting**: Knowledge of the architecture helps you diagnose and fix issues when they arise.
+* **Design Decisions**: Understanding the "why" behind MCP's design helps you make appropriate decisions for your use case.
+* **Security Considerations**: The architecture has implications for security that are essential to understand before deployment.
+* **Performance Optimization**: Knowing how data flows through MCP helps optimize for performance.
+
+## The Components We'll Explore
+
+MCP's architecture consists of several key components that work together to enable AI models to access external context and capabilities. In this unit, we'll examine:
+
+1. **Client-Server Architecture**: The foundational structure of MCP, including Hosts (the AI applications), Clients (protocol handlers within hosts), and Servers (providing capabilities).
+
+2. **Core Primitives**: The fundamental building blocks of MCP interactions:
+   - Tools: Executable functions the model can call
+   - Resources: Data sources the application can access
+   - Prompts: Pre-defined templates or workflows
+   - Sampling: Server-initiated model interactions
+
+3. **Communication Protocols**: The standardized methods for exchanging information:
+   - JSON-RPC: The message format for requests, responses, and notifications
+   - Transports: stdio (for local servers) and HTTP+SSE/Streamable HTTP (for remote servers)
+
+4. **Interaction Lifecycle**: The sequence of steps in an MCP interaction, from initialization to termination.
+
+Let's begin our exploration of MCP's architecture and core concepts, which will provide the foundation for the practical development we'll cover in Unit 3. 

units/en/unit3/_toctree.yml

@@ -0,0 +1,24 @@
+- title: "3. Building with MCP: Practical Development"
+  sections:
+  - local: unit3/introduction
+    title: Introduction
+  - local: unit3/environment-setup
+    title: Setting Up Your Development Environment & SDKs
+  - local: unit3/building-server
+    title: Building Your First MCP Server
+  - local: unit3/server-capabilities
+    title: Implementing Server Capabilities
+  - local: unit3/developing-clients
+    title: Developing MCP Clients
+  - local: unit3/configuration
+    title: Configuration, Authentication, and Debugging
+  - local: unit3/mcp-ecosystem
+    title: Navigating the MCP Ecosystem
+  - local: unit3/gradio-mcp
+    title: "Hugging Face Gradio MCP Integration"
+  - local: unit3/hub-mcp-servers
+    title: "Working with MCP Servers on Hugging Face Hub"
+  - local: unit3/practical-exercise
+    title: "Practical Exercise: MCP Interaction Walkthrough"
+  - local: unit3/quiz
+    title: Unit 3 Quiz 

units/en/unit3/gradio-mcp.mdx

@@ -0,0 +1,215 @@
+# Hugging Face Gradio MCP Integration
+
+Hugging Face's Gradio framework offers a powerful way to build and deploy web interfaces for AI applications. With its MCP integration, Gradio now makes it easier than ever to create interactive interfaces for MCP-enabled AI systems as well as building MCP servers in just a few lines of code.
+
+## What is Gradio MCP?
+
+Gradio MCP is an extension of the popular Gradio framework that allows developers to:
+
+1. Create web interfaces for MCP-enabled applications with minimal code
+2. Build MCP servers that can be used by any MCP client (like Claude, Cursor, or Cline)
+3. Visualize and debug MCP interactions through a user-friendly interface
+4. Deploy MCP applications to the Hugging Face Spaces platform with a single click
+5. Share MCP capabilities with others through an intuitive UI
+
+This integration bridges the gap between powerful MCP functionality and accessible user interfaces, making MCP-enabled AI systems more usable and shareable.
+
+## Building an MCP Server with Gradio
+
+According to the [official Hugging Face blog post](https://huggingface.co/blog/gradio-mcp), turning any Gradio app into an MCP server is remarkably simple. Here's how:
+
+### Installation
+
+First, install Gradio with the MCP extra:
+
+```bash
+pip install "gradio[mcp]"
+```
+
+### Creating a Simple MCP Server
+
+Here's an example of a letter-counting tool exposed as an MCP server:
+
+```python
+import gradio as gr
+
+def letter_counter(word, letter):
+    """Count the occurrences of a specific letter in a word.
+    
+    Args:
+        word: The word or phrase to analyze
+        letter: The letter to count occurrences of
+        
+    Returns:
+        The number of times the letter appears in the word
+    """
+    return word.lower().count(letter.lower())
+
+demo = gr.Interface(
+    fn=letter_counter,
+    inputs=["text", "text"],
+    outputs="number",
+    title="Letter Counter",
+    description="Count how many times a letter appears in a word"
+)
+
+demo.launch(mcp_server=True)
+```
+
+That's it! The only addition is the `mcp_server=True` parameter in the `launch()` method. When you run this app, it will:
+
+1. Start the regular Gradio web interface
+2. Start the MCP server
+3. Print the MCP server URL in the console
+
+### How Gradio MCP Works
+
+Gradio automatically converts your Python functions into MCP tools that can be used by LLMs. The docstring of your function is used to generate the description of the tool and its parameters, making it seamless to expose functionality to MCP clients.
+
+The MCP server will be accessible at:
+```
+http://your-server:port/gradio_api/mcp/sse
+```
+
+To use this server with an MCP client (like Claude Desktop, Cursor, or Cline), you simply need to add this URL to your client's configuration:
+
+```json
+{
+  "mcpServers": {
+    "gradio": {
+      "url": "http://your-server:port/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+## Key Features of Gradio MCP
+
+### Tool Conversion
+
+Each API endpoint in your Gradio app is automatically converted into an MCP tool with a corresponding name, description, and input schema. To view the available tools and their schemas, you can visit:
+```
+http://your-server:port/gradio_api/mcp/schema
+```
+
+Or go to the "View API" link in the footer of your Gradio app and click on "MCP".
+
+### Environment Variable Support
+
+There are two ways to enable MCP server functionality:
+
+1. Using the `mcp_server` parameter as shown above:
+   ```python
+   demo.launch(mcp_server=True)
+   ```
+
+2. Using environment variables:
+   ```bash
+   export GRADIO_MCP_SERVER=True
+   ```
+
+### File Handling
+
+The server automatically handles file data conversions, including:
+- Converting base64-encoded strings to file data
+- Processing image files and returning them in the correct format
+- Managing temporary file storage
+
+It is strongly recommended to pass input images and files as full URLs ("http://..." or "https://...") as MCP clients do not always handle local files correctly.
+
+### Hosted MCP Servers on Hugging Face Spaces
+
+You can publish your Gradio application for free on Hugging Face Spaces, which will give you a free hosted MCP server. This allows you to share your MCP tools with others easily.
+
+For example, you can try out the MCP tools from [this Space](https://huggingface.co/spaces/abidlabs/mcp-tools) by adding the following configuration to your MCP client:
+
+```json
+{
+  "mcpServers": {
+    "gradio": {
+      "url": "https://abidlabs-mcp-tools.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+## Advanced Usage
+
+### Multiple Tools in One Server
+
+You can expose multiple tools from a single Gradio app:
+
+```python
+import gradio as gr
+
+def add(a, b):
+    """Add two numbers together.
+    
+    Args:
+        a: The first number
+        b: The second number
+        
+    Returns:
+        The sum of the two numbers
+    """
+    return a + b
+
+def multiply(a, b):
+    """Multiply two numbers together.
+    
+    Args:
+        a: The first number
+        b: The second number
+        
+    Returns:
+        The product of the two numbers
+    """
+    return a * b
+
+demo = gr.Blocks()
+
+with demo:
+    with gr.Tab("Addition"):
+        a1 = gr.Number()
+        b1 = gr.Number()
+        output1 = gr.Number()
+        gr.Interface(fn=add, inputs=[a1, b1], outputs=output1)
+    
+    with gr.Tab("Multiplication"):
+        a2 = gr.Number()
+        b2 = gr.Number()
+        output2 = gr.Number()
+        gr.Interface(fn=multiply, inputs=[a2, b2], outputs=output2)
+
+demo.launch(mcp_server=True)
+```
+
+This will expose both the `add` and `multiply` functions as separate MCP tools.
+
+### Client Integration
+
+Gradio can also serve as an MCP client, allowing you to create interfaces that connect to MCP servers. This will be covered in more detail in our hub-mcp-servers section.
+
+## Example Projects
+
+Hugging Face hosts several example projects demonstrating Gradio MCP integration:
+
+1. **[MCP Tools Demo](https://huggingface.co/spaces/abidlabs/mcp-tools)**: A collection of useful MCP tools built with Gradio
+2. **[Kokoro MCP](https://huggingface.co/spaces/fdaudens/kokoro-mcp)**: A text-to-speech application exposed as an MCP server
+3. **MCP Multi-Tool Demo**: Showcases multiple MCP servers working together in a single interface
+
+These examples provide excellent starting points for your own Gradio MCP applications.
+
+## Best Practices
+
+When building with Gradio MCP, consider these best practices:
+
+1. **Provide Clear Documentation**: Use detailed docstrings to help LLMs understand how to use your tools
+2. **Use Type Hints**: Add Python type hints to your functions to help Gradio generate accurate schemas
+3. **Error Handling**: Implement robust error handling to provide helpful feedback
+4. **Consider Statelessness**: Design your tools to be stateless when possible
+5. **Security Considerations**: Be mindful of tool permissions, especially in shared deployments
+
+By following these practices, you can create robust, user-friendly MCP applications using Gradio that seamlessly integrate with LLM applications.
+
+In the next section, we'll explore working with MCP servers on the Hugging Face Hub. 

units/en/unit3/hub-mcp-servers.mdx

@@ -0,0 +1,154 @@
+# Working with MCP Servers on Hugging Face Hub
+
+The Hugging Face Hub provides a centralized platform for discovering, sharing, and deploying MCP servers. This ecosystem approach dramatically simplifies working with MCP by providing a community-driven repository of reusable components.
+
+## The MCP Server Ecosystem on Hugging Face
+
+The Hugging Face Hub hosts a growing collection of MCP servers covering various functionalities:
+
+- **Data Access Servers**: For accessing files, databases, and APIs
+- **Tool Servers**: Providing utilities like code execution, data analysis, and web browsing
+- **Integration Servers**: Connecting to third-party services like Slack, GitHub, and Google Workspace
+- **Specialized Servers**: For domain-specific tasks like image generation, document processing, and more
+
+This shared ecosystem eliminates the need to build common MCP servers from scratch, allowing developers to focus on their unique application requirements.
+
+## Finding MCP Servers on the Hub
+
+### Searching for MCP Servers
+
+You can discover MCP servers on the Hugging Face Hub using:
+
+1. **The Hub Search**: Visit [huggingface.co](https://huggingface.co) and search for "mcp-server" or specific functionality like "mcp-server-github"
+2. **Tags**: Browse servers tagged with "mcp", "mcp-server", or related categories
+3. **Collections**: Explore curated collections of MCP servers for specific domains or use cases
+
+### MCP Server Cards
+
+Each MCP server on the Hub includes a detailed card with:
+
+- **Description**: Overview of the server's functionality
+- **Installation Instructions**: How to set up and run the server
+- **Configuration Options**: Available settings and their default values
+- **Authentication Requirements**: Details on required credentials or tokens
+- **Examples**: Sample code for integrating the server into your applications
+- **Limitations**: Known issues or constraints
+
+These cards make it easy to evaluate and compare different servers to find the one that best meets your needs.
+
+## Using Hub MCP Servers in Your Projects
+
+### Installation
+
+Most Hub MCP servers can be installed via pip:
+
+```bash
+pip install "mcp-server-github @ git+https://huggingface.co/mcp-servers/github.git"
+```
+
+Or cloned directly:
+
+```bash
+git clone https://huggingface.co/mcp-servers/github
+cd github
+pip install -e .
+```
+
+### Basic Usage
+
+Once installed, you can use a Hub MCP server like any other MCP server:
+
+```python
+# Python example using a GitHub MCP server from the Hub
+from mcp.client import McpClient
+from mcp_server_github import GitHubMcpServer
+
+# Start the server
+server = GitHubMcpServer(
+    auth_token="your_github_token",
+    repo_owner="your_username",
+    repo_name="your_repo"
+)
+server.start()
+
+# Connect a client
+client = McpClient("github")
+client.connect_to_server_stdio(server.get_stdio_connection())
+
+# List available tools
+tools = client.list_tools()
+print(f"Available tools: {[tool.name for tool in tools]}")
+
+# Call a tool
+result = client.call_tool("create_issue", {
+    "title": "Test issue",
+    "body": "This is a test issue created via MCP"
+})
+print(f"Issue created: {result}")
+```
+
+### Configuration
+
+Hub MCP servers typically offer various configuration options:
+
+```python
+# Example with comprehensive configuration
+server = FileSystemMcpServer(
+    root_directory="/path/to/files",
+    allowed_extensions=[".txt", ".md", ".py"],
+    read_only=True,
+    max_file_size=10_000_000,  # 10MB
+    concurrency_limit=5
+)
+```
+
+The specific options available depend on the server, but they are documented in the server's Hub card and README.
+
+## Contributing MCP Servers to the Hub
+
+### Creating a New MCP Server
+
+If you've developed an MCP server that might be useful to others, sharing it on the Hub is straightforward:
+
+1. **Prepare Your Code**: Ensure your server is well-documented and follows MCP best practices
+2. **Create a Repository**: Set up a new repository on the Hugging Face Hub using the web interface or the `huggingface-cli`
+3. **Push Your Code**: Upload your server code to the repository
+4. **Add a README**: Create a detailed README.md describing your server, its functionality, and usage instructions
+5. **Add Tags**: Tag your repository with "mcp", "mcp-server", and other relevant tags
+
+### Best Practices for Hub MCP Servers
+
+When contributing to the Hub, follow these best practices:
+
+1. **Standardized Structure**: Use a consistent project structure with a clear entry point
+2. **Comprehensive Documentation**: Document all functionality, configuration options, and examples
+3. **Error Handling**: Implement robust error handling and meaningful error messages
+4. **Security Considerations**: Document security implications and recommended precautions
+5. **Version Management**: Use semantic versioning and maintain a changelog
+6. **Tests**: Include tests to verify functionality and prevent regressions
+
+Following these practices ensures your server is accessible and useful to the community.
+
+## Example: Deploying a Hub MCP Server to Spaces
+
+You can deploy MCP servers from the Hub to Hugging Face Spaces for easy access:
+
+1. **Create a New Space**: Set up a Space using the Gradio or Streamlit framework
+2. **Install the Server**: Add the server as a dependency in your requirements.txt
+3. **Create a Web Interface**: Build a simple UI for configuring and using the server
+4. **Deploy**: Push your code to the Space
+
+This approach allows you to provide a user-friendly interface for your MCP server, making it accessible to users who may not be comfortable with command-line tools.
+
+## Community Collaboration on MCP Servers
+
+The Hugging Face Hub facilitates collaboration on MCP servers through:
+
+1. **Discussions**: Engage with other developers on server functionality and improvements
+2. **Pull Requests**: Contribute enhancements or fixes to existing servers
+3. **Issue Tracking**: Report and track bugs or feature requests
+4. **Version History**: View changes over time and roll back to previous versions if needed
+
+This collaborative environment accelerates the development and refinement of MCP servers, benefiting the entire community.
+
+In the next section, we'll explore building with Tiny Agents and MCP, combining efficient agent architectures with the power of external tools. 

units/en/unit3/introduction.mdx

@@ -0,0 +1,68 @@
+# Building with MCP: Practical Development
+
+Welcome to Unit 3 of the MCP Course! In this unit, we'll roll up our sleeves and dive into the practical aspects of developing with Model Context Protocol.
+
+## What You Will Learn
+
+In this unit, you will:
+
+* Set up a development environment with the necessary MCP SDKs
+* Learn how to build MCP servers that expose capabilities to AI models
+* Implement server capabilities like Tools, Resources, and Prompts
+* Develop MCP clients that can connect to and utilize these servers
+* Configure connections, authentication, and debug MCP interactions
+* Navigate the growing MCP ecosystem of clients, servers, and platforms
+* Walk through a complete MCP interaction from end to end
+* Leverage Hugging Face's tools and platforms for MCP development
+
+By the end of this unit, you'll have the practical skills needed to implement MCP in your own projects, both on the server side (exposing capabilities) and the client side (consuming capabilities in AI applications).
+
+## Hugging Face's MCP Ecosystem
+
+Hugging Face offers several powerful tools that simplify MCP development and deployment:
+
+### Gradio MCP Integration
+
+Hugging Face's Gradio framework now provides native support for MCP, allowing you to:
+* Create user-friendly web interfaces for your MCP-enabled applications
+* Easily visualize and interact with MCP server capabilities
+* Deploy MCP applications with minimal configuration
+* Share your MCP implementations with the community
+
+### MCP Servers on Hugging Face Hub
+
+The Hugging Face Hub serves as a central repository for sharing and discovering MCP servers:
+* Browse a growing collection of community-contributed MCP servers
+* Deploy pre-built MCP servers with one click
+* Share your own MCP server implementations
+* Collaborate with others to improve existing servers
+
+## The Value of Practical Implementation
+
+While understanding the theory and architecture of MCP is essential, hands-on implementation provides several unique benefits:
+
+* **Concrete Understanding**: Translating concepts into working code solidifies your understanding of MCP's principles.
+* **Debugging Skills**: You'll learn to diagnose and resolve common issues that arise in real-world implementations.
+* **Integration Patterns**: You'll discover effective patterns for integrating MCP with existing systems and applications.
+* **Developer Experience**: You'll gain familiarity with the tools and SDKs that streamline MCP development.
+* **Best Practices**: Working examples provide models for secure, efficient, and maintainable MCP implementations.
+* **Community Engagement**: Building with Hugging Face's tools connects you to a vibrant ecosystem of MCP developers.
+
+## What We'll Build
+
+Throughout this unit, we'll focus on developing practical components of the MCP ecosystem:
+
+1. **MCP Servers**: We'll build servers that expose various capabilities, from simple file access to API integrations, using official SDKs in languages like Python and TypeScript.
+
+2. **Server Capabilities**: We'll implement each type of MCP capability:
+   - Tools that provide executable functions
+   - Resources that offer data access
+   - Prompts that structure interactions
+
+3. **MCP Clients**: We'll develop client-side code that connects to servers, discovers their capabilities, and integrates them into AI applications.
+
+4. **Configuration & Debugging**: We'll explore approaches for configuring connections, handling authentication, and debugging MCP interactions using tools like the MCP Inspector.
+
+5. **Hugging Face Integrations**: We'll implement MCP applications using Hugging Face's Gradio, Hub, and other tools to take advantage of their robust infrastructure and community.
+
+Let's begin our journey into practical MCP development, where theory meets implementation to create powerful AI applications with access to the context and tools they need. 

units/en/unit3/tiny-agents-mcp.mdx

@@ -0,0 +1 @@
+ 

units/en/unit4/_toctree.yml

@@ -0,0 +1,18 @@
+- title: 4. Advanced Topics, Security, and the Future of MCP
+  sections:
+  - local: unit4/introduction
+    title: Introduction
+  - local: unit4/advanced-features
+    title: Exploring Advanced MCP Features
+  - local: unit4/security
+    title: Security Deep Dive - Threats and Mitigation Strategies
+  - local: unit4/limitations
+    title: Limitations, Challenges, and Comparisons
+  - local: unit4/huggingface-ecosystem
+    title: Hugging Face's Ecosystem and Future Contributions
+  - local: unit4/future
+    title: The Future of MCP - Roadmap and Standardization
+  - local: unit4/final-project
+    title: Final Project - Building a Complete MCP Application
+  - local: unit4/certification
+    title: Certification and Next Steps 

units/en/unit4/huggingface-ecosystem.mdx

@@ -0,0 +1,173 @@
+# Hugging Face's Ecosystem and Future Contributions
+
+Hugging Face has emerged as a key player in the MCP ecosystem, providing tools, platforms, and resources that accelerate the adoption and implementation of this important standard. In this section, we'll explore Hugging Face's current contributions to MCP and their future roadmap for enhancing the ecosystem.
+
+## Current Ecosystem Contributions
+
+### MCP Server Hub
+
+Hugging Face's Hub provides a centralized repository for MCP servers, offering several advantages:
+
+- **Discovery**: Easily find existing MCP servers for common use cases
+- **Versioning**: Track changes and updates to server implementations
+- **Documentation**: Access comprehensive guides on server configuration and usage
+- **Community**: Engage with developers and share improvements
+
+This collaborative approach through the Hub significantly reduces the effort required to build and maintain MCP servers, allowing developers to focus on creating innovative applications rather than reinventing infrastructure.
+
+### Gradio MCP Integration
+
+Hugging Face's Gradio framework brings MCP to a broader audience through:
+
+- **Simplified UI Creation**: Build interfaces for MCP-enabled applications with minimal code
+- **Interactive Demos**: Create shareable demos showcasing MCP capabilities
+- **Visualization Tools**: Monitor and debug MCP interactions through visual tools
+- **One-Click Deployment**: Deploy MCP applications to Spaces with a single command
+
+This integration makes MCP more accessible to developers who may not be familiar with the underlying protocol details but want to leverage its capabilities in their applications.
+
+### Tiny Agents Framework
+
+Hugging Face's work on Tiny Agents extends MCP to resource-constrained environments:
+
+- **Efficient Implementation**: Run MCP-enabled agents on edge devices and low-resource environments
+- **Specialized Model Support**: Leverage smaller, task-specific models while maintaining MCP capabilities
+- **Optimized Context Management**: Efficiently handle context with limited model context windows
+- **Pipeline Architecture**: Build multi-stage agent workflows that leverage MCP at each step
+
+This framework democratizes access to advanced agent capabilities, allowing MCP to be used in a wider range of applications and environments.
+
+### Educational Resources
+
+Hugging Face has contributed significantly to MCP education through:
+
+- **Blog Posts**: In-depth articles explaining MCP concepts and implementations
+- **Tutorials**: Step-by-step guides for building MCP applications
+- **Example Projects**: Ready-to-run examples demonstrating MCP capabilities
+- **Course Materials**: Comprehensive courses like this one that teach MCP from fundamentals to advanced topics
+
+These resources have helped create a knowledgeable community of MCP developers who continue to push the boundaries of what's possible with this standard.
+
+## Future Roadmap and Initiatives
+
+### Enhanced MCP Server Registry
+
+Hugging Face is developing an enhanced registry for MCP servers with features like:
+
+- **Automated Verification**: Ensure servers comply with the MCP specification
+- **Performance Metrics**: Track and compare server performance characteristics
+- **Compatibility Badges**: Indicate compatibility with different MCP versions and features
+- **Usage Analytics**: Provide insights into the most widely used servers and tools
+
+This registry will make it easier to discover reliable, high-quality MCP servers for specific use cases.
+
+### MCP Inference API
+
+Hugging Face is working on extending their Inference API to support MCP:
+
+- **Hosted MCP Servers**: Access popular MCP servers through a managed API
+- **Pay-as-you-go Access**: Use MCP capabilities without managing infrastructure
+- **Enterprise Integrations**: Connect enterprise systems to MCP using secure, managed endpoints
+- **Scalability**: Automatically scale MCP servers based on demand
+
+This service will reduce the barrier to entry for organizations wanting to leverage MCP without building and maintaining their own server infrastructure.
+
+### Cross-Framework Compatibility
+
+Hugging Face is actively working on ensuring MCP compatibility across different AI frameworks:
+
+- **Transformers Integration**: Seamless integration between Transformers models and MCP
+- **PEFT Support**: Use Parameter-Efficient Fine-Tuning with MCP-enabled models
+- **Accelerate Compatibility**: Optimize MCP server performance with Accelerate
+- **Datasets Integration**: Connect MCP servers directly to Hugging Face Datasets
+
+These integrations will create a more cohesive ecosystem where MCP can be used with existing Hugging Face tools.
+
+### MCP Standards Contributions
+
+Hugging Face is contributing to the MCP specification itself:
+
+- **Protocol Extensions**: Proposing enhancements to address limitations and add features
+- **Testing Frameworks**: Developing tools to verify MCP implementation compliance
+- **Reference Implementations**: Creating exemplary implementations of the MCP standard
+- **Community Engagement**: Organizing discussions and feedback on MCP evolution
+
+By actively participating in the standardization process, Hugging Face helps ensure MCP remains open, robust, and aligned with real-world needs.
+
+## Case Study: MCP Platform at Scale
+
+To illustrate Hugging Face's vision for MCP, let's examine a hypothetical large-scale deployment that leverages their ecosystem:
+
+### Enterprise MCP Platform
+
+Consider a large enterprise that has deployed an MCP platform using Hugging Face tools:
+
+1. **MCP Server Hub**: The organization maintains a private hub of MCP servers for different internal systems:
+   - Document management system
+   - HR records and policies
+   - Customer relationship management
+   - Financial reporting
+   - Product knowledge base
+
+2. **Deployment Infrastructure**:
+   - Critical servers run on dedicated infrastructure
+   - Less-critical servers are deployed as Spaces
+   - Development and testing servers use local deployments with versioning
+
+3. **User Interfaces**:
+   - Department-specific dashboards built with Gradio
+   - Internal chatbot with access to appropriate MCP servers
+   - Integration with existing enterprise applications
+
+4. **Security and Governance**:
+   - Centralized authentication and authorization
+   - Comprehensive logging and auditing
+   - Regular security reviews and updates
+
+This platform allows the organization to leverage AI across their operations while maintaining security and governance controls.
+
+## Community Impact and Innovation
+
+Hugging Face's contributions to the MCP ecosystem have catalyzed community innovation in several areas:
+
+### Specialized MCP Servers
+
+The community has developed specialized MCP servers for various domains:
+
+- **Healthcare**: Servers for accessing medical knowledge bases and EHR systems
+- **Legal**: Servers for legal research and document analysis
+- **Education**: Servers for educational content and assessment
+- **Scientific Research**: Servers for accessing research papers and datasets
+
+These domain-specific servers extend MCP's utility in specialized fields.
+
+### Multi-Modal MCP
+
+Emerging work is expanding MCP beyond text to include:
+
+- **Image Processing**: MCP servers for image analysis and generation
+- **Audio Integration**: Servers for speech recognition and audio processing
+- **Video Analysis**: Servers for video content understanding
+- **Multi-Modal Reasoning**: Tools for reasoning across different modalities
+
+Hugging Face's support for multi-modal models complements these efforts, creating a richer MCP ecosystem.
+
+## Getting Involved with Hugging Face's MCP Ecosystem
+
+There are several ways to participate in and contribute to Hugging Face's MCP ecosystem:
+
+1. **Share Your MCP Servers**: Publish your MCP servers to the Hub for others to use and improve
+2. **Contribute to Examples**: Add examples and use cases to the documentation
+3. **Report Issues and Suggestions**: Help identify bugs or suggest improvements
+4. **Join Community Discussions**: Participate in forum discussions about MCP
+5. **Create Educational Content**: Share your knowledge through blog posts or tutorials
+
+By getting involved, you can help shape the future of MCP and contribute to this growing ecosystem.
+
+## Conclusion
+
+Hugging Face's contributions to the MCP ecosystem have significantly accelerated its adoption and development. By providing tools, platforms, and resources for working with MCP, Hugging Face has made it easier for developers to build sophisticated AI applications that leverage external context and tools.
+
+As MCP continues to evolve, Hugging Face's ongoing investments in this ecosystem will help ensure it remains open, accessible, and powerful. Whether you're building simple tool integrations or complex agent systems, Hugging Face's MCP resources provide a solid foundation for your projects.
+
+In the next section, we'll look more broadly at the future of MCP, including standardization efforts and the roadmap for protocol evolution. 

units/en/unit4/introduction.mdx

@@ -0,0 +1,78 @@
+# Advanced Topics, Security, and the Future of MCP
+
+Welcome to Unit 4 of the MCP Course! In this final unit, we'll explore advanced topics in Model Context Protocol, dig deep into security considerations, and look toward the future of this evolving standard, with particular attention to Hugging Face's role in shaping the MCP ecosystem.
+
+## What You Will Learn
+
+In this unit, you will:
+
+* Explore advanced MCP features like roots, streaming, progress reporting, and sampling
+* Understand the security challenges of MCP and learn effective mitigation strategies
+* Analyze the current limitations of MCP and potential solutions
+* Compare MCP with alternative approaches to AI tool integration
+* Examine the future roadmap and standardization efforts for MCP
+* Discover Hugging Face's contributions to the MCP community and ecosystem
+* Apply everything you've learned in a comprehensive final project
+
+By the end of this unit, you'll have a sophisticated understanding of MCP's advanced capabilities, security implications, and future direction, positioning you to make informed decisions about implementing and evolving MCP in your own applications.
+
+## Hugging Face's Impact on the MCP Ecosystem
+
+Hugging Face has emerged as a significant contributor to the MCP ecosystem, helping to shape its future in several key ways:
+
+* **Democratizing Access**: Through the Hugging Face Hub, MCP servers and components are made accessible to a broader developer community
+* **Usability Improvements**: Hugging Face's Gradio integration simplifies the creation of user interfaces for MCP applications
+* **Efficiency Innovations**: Work on Tiny Agents with MCP support enables deployment on a wider range of hardware
+* **Community Building**: Hugging Face Spaces and Forums foster collaboration and knowledge sharing around MCP
+* **Educational Resources**: Comprehensive guides, blog posts, and courses like this one help developers understand and adopt MCP
+
+These contributions are helping to accelerate adoption and innovation in the MCP ecosystem, making it more accessible, useful, and robust.
+
+## The Importance of Advanced Understanding
+
+As MCP adoption grows, developers and organizations need to move beyond basic implementation to address several critical concerns:
+
+* **Security**: Understanding potential vulnerabilities in AI-to-tool integrations is crucial for protecting systems and users from threats like prompt injection, tool poisoning, and data exfiltration.
+
+* **Scalability**: Advanced features like streaming, efficient resource handling, and optimized communication protocols become essential as MCP implementations grow in complexity and scale.
+
+* **Interoperability**: As the ecosystem of MCP-compatible tools and platforms expands, understanding how MCP compares and interacts with other standards becomes increasingly important.
+
+* **Future-Proofing**: Knowledge of the MCP roadmap and standardization efforts helps organizations align their implementations with the likely evolution of the protocol.
+
+## Topics We'll Cover
+
+This unit expands your MCP knowledge with these key topics:
+
+1. **Advanced Features**: We'll dive into sophisticated MCP capabilities including:
+   - Roots for client-defined operation scopes
+   - Streaming for bidirectional, chunked messages
+   - Progress reporting for long-running tasks
+   - Resource subscriptions for monitoring changes
+   - Agent graphs for complex workflows
+   - Sampling for server-initiated LLM interactions
+
+2. **Security Deep Dive**: We'll analyze the threat landscape and mitigation strategies, including:
+   - Prompt injection and tool poisoning risks
+   - Authentication and authorization best practices
+   - Input validation and output sanitization
+   - Monitoring, logging, and auditability
+   - Human-in-the-loop confirmation patterns
+
+3. **Limitations and Comparisons**: We'll examine current limitations of MCP and compare it with alternatives:
+   - Authentication maturity challenges
+   - Ecosystem reliability considerations
+   - Comparison with OpenAPI/Function Calling
+   - Contrast with RAG approaches
+   - Comparison with agent frameworks like LangChain
+
+4. **Future Roadmap**: We'll look at where MCP is headed:
+   - Recent updates and new features
+   - Standardization efforts and community contributions
+   - Integration with emerging AI capabilities
+   - Potential impact on the broader AI ecosystem
+   - Hugging Face's roadmap for MCP support
+
+5. **Final Project**: You'll apply everything you've learned in a comprehensive final project, potentially leveraging Hugging Face tools and platforms.
+
+Let's dive into these advanced topics and prepare you for the cutting edge of Model Context Protocol implementation and design.