Merge branch 'main' into patch-3

Author: burtenshaw

units/en/_toctree.yml

@@ -23,6 +23,8 @@
     title: Quiz 2 - MCP SDK
   - local: unit1/mcp-clients
     title: MCP Clients
+  - local: unit1/hf-mcp-server
+    title: Hugging Face MCP Server
   - local: unit1/gradio-mcp
     title: Gradio MCP Integration
   - local: unit1/unit1-recap
@@ -44,6 +46,8 @@
     title: Building an MCP Client with Gradio
   - local: unit2/tiny-agents
     title: Building Tiny Agents with MCP and the Hugging Face Hub
+  - local: unit2/lemonade-server
+    title: Local Tiny Agents with AMD NPU and iGPU Acceleration
 
 - title: "3. Advanced MCP Development: Custom Workflow Servers"
   sections:

units/en/unit1/gradio-mcp.mdx

@@ -114,6 +114,16 @@ When you set `mcp_server=True` in `launch()`, several things happen:
 
 4. **Hosted MCP Servers on 🤗 Spaces**: You can publish your Gradio application for free on Hugging Face Spaces, which will allow you to have a free hosted MCP server. Here's an example of such a Space: https://huggingface.co/spaces/abidlabs/mcp-tools
 
+## Use MCP-compatible Spaces from your client
+
+You can connect any MCP-compatible Space to your assistant via Hugging Face MCP settings:
+
+1. Explore MCP-compatible Spaces: https://huggingface.co/spaces?search=mcp
+2. Open https://huggingface.co/settings/mcp (logged in) and add the Space.
+3. Restart or refresh your MCP client so it discovers the new tools.
+
+These Spaces expose their functions as tools with arguments and descriptions, so your assistant can call them directly.
+
 ## Troubleshooting Tips
 
 1. **Type Hints and Docstrings**: Ensure you provide type hints and valid docstrings for your functions. The docstring should include an "Args:" block with indented parameter names.

units/en/unit1/hf-mcp-server.mdx

@@ -0,0 +1,70 @@
+# Hugging Face MCP Server
+
+The Hugging Face MCP (Model Context Protocol) Server connects your MCP‑compatible AI assistant (for example VS Code, Cursor, Zed, or Claude Desktop) directly to the Hugging Face Hub. Once connected, your assistant can search and explore Hub resources and use community tools, all from within your editor, chat or CLI.
+
+<Tip>
+
+The main advanatage of the Hugging Face MCP Server is that it provides a built-in tools for the hub as well as community tools based on Gradio Spaces. As we start to build our own MCP servers, we'll see that we can use the Hugging Face MCP Server as a reference for our own MCP servers.
+
+</Tip>
+
+## What you can do
+
+- Search and explore Hub resources: models, datasets, Spaces, and papers.
+- Run community tools via MCP‑compatible Gradio apps hosted on [Spaces](https://hf.co/spaces).
+- Bring results back into your assistant with metadata, links, and context.
+
+## Built-in tools
+
+The server provides curated tools that work across supported clients:
+
+- Models search and exploration (filter by task, library, downloads, likes)
+- Datasets search and exploration (filter by tags, size, modality)
+- Spaces semantic search (find apps by capability, e.g., TTS, ASR, OCR)
+- Papers semantic search (discover relevant research on the Hub)
+
+## Get started
+
+1. Open your MCP settings: visit https://huggingface.co/settings/mcp while logged in.
+
+2. Pick your client: select your MCP‑compatible client (for example VS Code, Cursor, Zed, Claude Desktop). The page shows client‑specific instructions and a ready‑to‑copy configuration snippet.
+
+3. Paste and restart: copy the snippet into your client’s MCP configuration, save, and restart/reload the client. You should see “Hugging Face” (or similar) listed as a connected MCP server in your client.
+
+<Tip>
+
+The settings page generates the exact configuration your client expects. Use it rather than writing config by hand.
+
+</Tip>
+
+![MCP Settings Example](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/hf-mcp-settings.png)
+
+## Using the server
+
+After connecting, ask your assistant to use the Hugging Face tools. Example prompts:
+
+- “Search Hugging Face models for Qwen 3 quantizations.”
+- “Find a Space that can transcribe audio files.”
+- “Show datasets about weather time‑series.”
+- “Create a 1024 × 1024 image of a cat in Ghibli style.”
+
+Your assistant will call MCP tools exposed by the Hugging Face MCP Server (including Spaces) and return results (titles, owners, downloads, links, and so on). You can then open the resource on the Hub or continue iterating in the same chat.
+
+![HF MCP with Spaces in VS Code](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/hf-mcp-vscode.png)
+
+## Add community tools (Spaces)
+
+You can extend your setup with MCP‑compatible Gradio Spaces built by the community:
+
+- Explore Spaces with MCP support [here](https://huggingface.co/spaces?search=mcp).
+- Add the relevant space in your MCP settings on Hugging Face [here](https://huggingface.co/settings/mcp).
+
+Gradio MCP apps expose their functions as tools (with arguments and descriptions) so your assistant can call them directly. Please, restart or refresh your client so it picks up new tools you add.
+
+## Learn more
+
+- Settings and client setup: https://huggingface.co/settings/mcp
+- Changelog announcement: https://huggingface.co/changelog/hf-mcp-server
+- HF MCP Server documentation: https://huggingface.co/docs/hub/en/hf-mcp-server
+- Building your own MCP server with Gradio and Hub tools: https://huggingface.co/docs/hub/main/agents
+

units/en/unit1/key-concepts.mdx

@@ -31,8 +31,6 @@ MCP transforms this into an M+N problem by providing a standard interface: each
 
 ![With MCP](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/2.png)
 
-Each AI application implements the client side of MCP once, and each tool/data source implements the server side once.
-
 ## Core MCP Terminology
 
 Now that we understand the problem that MCP solves, let's dive into the core terminology and concepts that make up the MCP protocol.

units/en/unit1/mcp-clients.mdx

@@ -9,7 +9,7 @@ In this section, you will:
 * Understand what MCP Clients are and their role in the MCP architecture
 * Learn about the key responsibilities of MCP Clients
 * Explore the major MCP Client implementations
-* Discover how to use Hugging Face's MCP Client implementation
+* Discover how to connect to the Hugging Face MCP Server and built-in tools
 * See practical examples of MCP Client usage
 
 <Tip>
@@ -30,13 +30,26 @@ Let's start by exploring the user interface clients that are available for the M
 
 ### Chat Interface Clients
 
-Anthropic's Claude Desktop stands as one of the most prominent MCP Clients, providing integration with various MCP Servers.
+- Claude Desktop (Anthropic)
 
 ### Interactive Development Clients
 
-Cursor's MCP Client implementation enables AI-powered coding assistance through direct integration with code editing capabilities. It supports multiple MCP Server connections and provides real-time tool invocation during coding, making it a powerful tool for developers.
+- VS Code extensions with MCP (e.g., Continue)
+- Cursor IDE (built-in MCP client)
+- Zed editor
 
-Continue.dev is another example of an interactive development client that supports MCP and connects to an MCP server from VS Code.
+These clients support connecting to multiple MCP servers and real-time tool invocation.
+
+## Quick connect to Hugging Face MCP Server
+
+Hugging Face provides a hosted MCP server with built-in tools for exploring models, datasets, Spaces, and papers.
+
+1. Visit https://huggingface.co/settings/mcp while logged in.
+2. Select your MCP-compatible client (e.g., VS Code, Cursor, Zed, Claude Desktop).
+3. Copy the generated configuration snippet into your client's MCP config.
+4. Restart or reload your client. You should see “Hugging Face” connected.
+
+Tip: Prefer the generated snippet over hand-written config; it’s tailored per client.
 
 ## Configuring MCP Clients
 
@@ -267,15 +280,15 @@ Now, let's create an agent configuration file `agent.json`.
 
 ```json
 {
+    "name": "playwright-agent",
+    "description": "Agent with Playwright MCP server",
     "model": "Qwen/Qwen2.5-72B-Instruct",
     "provider": "nebius",
     "servers": [
         {
             "type": "stdio",
-            "config": {
-                "command": "npx",
-                "args": ["@playwright/mcp@latest"]
-            }
+            "command": "npx",
+            "args": ["@playwright/mcp@latest"]
         }
     ]
 }
@@ -310,17 +323,15 @@ Create an agent configuration file at `my-agent/agent.json`:
 
 ```json
 {
-	"model": "Qwen/Qwen2.5-72B-Instruct",
-	"provider": "nebius",
-	"servers": [
-		{
-			"type": "stdio",
-			"config": {
-				"command": "npx",
-				"args": ["@playwright/mcp@latest"]
-			}
-		}
-	]
+    "model": "Qwen/Qwen2.5-72B-Instruct",
+    "provider": "nebius",
+    "servers": [
+        {
+            "type": "stdio",
+            "command": "npx",
+            "args": ["@playwright/mcp@latest"]
+        }
+    ]
 }
 ```
 

units/en/unit1/unit1-recap.mdx

@@ -43,3 +43,9 @@ Official SDKs are available in various programming languages for implementing MC
 
 ### Gradio Integration
 Gradio allows easy creation of web interfaces that expose capabilities to the MCP protocol, making it accessible for both humans and AI models. This integration provides a human-friendly interface alongside AI-accessible tools with minimal code.
+
+### Hugging Face MCP enhancements
+- Hosted MCP Server now integrates with more clients (VS Code, Cursor, Zed, Claude Desktop).
+- Curated built-in tools for searching models, datasets, Spaces, and papers.
+- One-click configuration snippets from `https://huggingface.co/settings/mcp`.
+- Add MCP-compatible Gradio Spaces via settings and use them directly from your assistant.

units/en/unit2/clients.mdx

@@ -84,7 +84,7 @@ Cursor provides built-in MCP support, allowing you to connect your deployed MCP
 
 ### Configuration
 
-Open Cursor settings (`Ctrl + Shift + J` / `Cmd + Shift + J`) → **MCP** tab → **Add new global MCP server**:
+Open Cursor settings (`Ctrl + Shift + J` / `Cmd + Shift + J`) → **Tools & Integrations** tab → **Add Custom MCP**:
 
 **macOS:**
 ```json
@@ -124,13 +124,28 @@ Open Cursor settings (`Ctrl + Shift + J` / `Cmd + Shift + J`) → **MCP** tab 
 }
 ```
 
-### Why We Use mcp-remote
+### Why We Use `mcp-remote`
 
-Most MCP clients, including Cursor, currently only support local servers via stdio transport and don't yet support remote servers with OAuth authentication. The `mcp-remote` tool serves as a bridge solution that:
+> **Note**: As of mid-2025, Cursor supports direct remote MCP connections via HTTP+SSE and OAuth. You may not need `mcp-remote` unless working with legacy setups or encountering specific compatibility issues.
 
-- Runs locally on your machine
-- Forwards requests from Cursor to the remote MCP server
+Earlier versions of MCP clients, including Cursor, only supported local servers via `stdio` transport and lacked support for remote servers with authentication. The `mcp-remote` tool was introduced as a workaround that:
+
+- Runs locally on your machine  
+- Bridges Cursor with remote MCP servers  
+- Handles transport and authentication implicitly  
 - Uses the familiar configuration file format
 
-Once configured, you can ask Cursor to use your sentiment analysis tool for tasks like analyzing code comments, user feedback, or pull request descriptions.
+While this is still useful in some edge cases, Cursor now supports native remote MCP integration. You can directly configure a remote server like this:
 
+```json
+{
+  "mcpServers": {
+    "my-server": {
+      "url": "https://your-mcp-server.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+> See [Cursor’s official documentation](https://docs.cursor.com/context/mcp) for up-to-date setup instructions.
+
+Once configured, you can ask Cursor to use your sentiment analysis tool for tasks like analyzing code comments, user feedback, or pull request descriptions.

units/en/unit2/continue-client.mdx

@@ -20,7 +20,7 @@ You can install Continue from the VS Code marketplace.
 2. This will open the Continue extension page in VS Code, where you will need to click `Install` again
 3. The Continue logo will appear on the left sidebar. For a better experience, move Continue to the right sidebar
 
-![sidebar vs code demo](https://docs.continue.dev/assets/images/move-to-right-sidebar-b2d315296198e41046fc174d8178f30a.gif)
+![move-to-right-sidebar](https://mintlify.s3.us-west-1.amazonaws.com/continue-docs/images/move-to-right-sidebar-b2d315296198e41046fc174d8178f30a.gif)
 
 With Continue configured, we'll move on to setting up Ollama to pull local models. 
 
@@ -208,4 +208,4 @@ specialized tools, from web automation to file management, all running entirely
 on your local machine. Ready to take your development workflow to the next
 level? Start by experimenting with different MCP servers from the [Continue Hub
 MCP explore page](https://hub.continue.dev/explore/mcp) and discover how
-local AI can transform your coding experience.
+local AI can transform your coding experience.

units/en/unit2/gradio-client.mdx

@@ -20,7 +20,7 @@ Let's connect to an example MCP Server that is already running on Hugging Face.
 from smolagents.mcp_client import MCPClient
 
 with MCPClient(
-    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse", "transport": "sse"}
+    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse", "transport": "sse",}
 ) as tools:
     # Tools from the remote server are available
     print("\n".join(f"{t.name}: {t.description}" for t in tools))
@@ -64,7 +64,7 @@ Next, we'll connect to the MCP Server and get the tools that we can use to answe
 
 ```python
 mcp_client = MCPClient(
-    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse"} # This is the MCP Client we created in the previous section
+    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse", "transport": "sse",} # This is the MCP Client we created in the previous section
 )
 tools = mcp_client.get_tools()
 ```
@@ -115,7 +115,7 @@ from smolagents import InferenceClientModel, CodeAgent, MCPClient
 
 try:
     mcp_client = MCPClient(
-        {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse"}
+        {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse", "transport": "sse",}
     )
     tools = mcp_client.get_tools()
 
@@ -152,7 +152,7 @@ To deploy your Gradio MCP client to Hugging Face Spaces:
 
 ```python
 mcp_client = MCPClient(
-    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse"}
+    {"url": "https://abidlabs-mcp-tool-http.hf.space/gradio_api/mcp/sse", "transport": "sse"}
 )
 ```
 

units/en/unit2/gradio-server.mdx

@@ -75,7 +75,7 @@ if __name__ == "__main__":
 Let's break down the key components:
 
 1. **Function Definition**:
-   - The `sentiment_analysis` function takes a text input and returns a dictionary
+   - The `sentiment_analysis` function takes a text input and returns the string representation of a JSON dictionary
    - It uses TextBlob to analyze the sentiment
    - The docstring is crucial as it helps Gradio generate the MCP tool schema
    - Type hints (`str` and `dict`) help define the input/output schema
@@ -157,10 +157,11 @@ You can test the server in two ways:
 To make your server available to others, you can deploy it to Hugging Face Spaces:
 
 1. Create a new Space on Hugging Face:
-   - Go to huggingface.co/spaces
-   - Click "Create new Space"
-   - Choose "Gradio" as the SDK
+   - Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+   - Click "New Space"
    - Name your space (e.g., "mcp-sentiment")
+   - Choose "Gradio" as the SDK
+   - Click "Create Space"
 
 2. Create a `requirements.txt` file:
 ```txt