Move docker-mcp-server contents to root

.gitignore

@@ -173,4 +173,14 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
-.DS_Store
+.DS_Store
+
+# Docker
+.dockerignore
+docker-compose.yml
+docker-compose.override.yml
+.docker/
+
+# Hugging Face Spaces
+.space/
+mcpserver/

Dockerfile

@@ -0,0 +1,41 @@
+# Use Python 3.11 slim image as base
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app.py .
+
+# Create a non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+USER app
+
+# Expose the port that Gradio will run on
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Run the application
+CMD ["python", "app.py"]

Makefile

@@ -0,0 +1,152 @@
+# Makefile for MCP Sentiment Analysis Server
+
+# Variables
+IMAGE_NAME = mcp-sentiment
+CONTAINER_NAME = mcp-sentiment-container
+PORT = 7860
+DOCKER_REGISTRY = 
+VERSION = latest
+
+# Default target
+.PHONY: help
+help:
+	@echo "MCP Sentiment Analysis Server - Development Commands"
+	@echo "=================================================="
+	@echo ""
+	@echo "Development:"
+	@echo "  install     Install Python dependencies locally"
+	@echo "  run         Run the server locally (without Docker)"
+	@echo "  test        Run tests locally"
+	@echo ""
+	@echo "Docker:"
+	@echo "  build       Build Docker image"
+	@echo "  run-docker  Run Docker container"
+	@echo "  stop        Stop Docker container"
+	@echo "  logs        Show Docker container logs"
+	@echo "  shell       Open shell in running container"
+	@echo ""
+	@echo "Testing:"
+	@echo "  test-docker Test Docker container"
+	@echo "  test-all    Run all tests (local + Docker)"
+	@echo ""
+	@echo "Deployment:"
+	@echo "  deploy-hf   Deploy to Hugging Face Spaces (interactive)"
+	@echo ""
+	@echo "Cleanup:"
+	@echo "  clean       Remove Docker containers and images"
+	@echo "  clean-all   Remove everything including volumes"
+
+# Development targets
+.PHONY: install
+install:
+	pip install -r requirements.txt
+
+.PHONY: run
+run:
+	python app.py
+
+.PHONY: test
+test:
+	python test_mcp_server.py
+
+# Docker targets
+.PHONY: build
+build:
+	docker build -t $(IMAGE_NAME):$(VERSION) .
+
+.PHONY: run-docker
+run-docker: build
+	docker run -d \
+		--name $(CONTAINER_NAME) \
+		-p $(PORT):7860 \
+		$(IMAGE_NAME):$(VERSION)
+	@echo "Container started. Access at http://localhost:$(PORT)"
+	@echo "MCP endpoint: http://localhost:$(PORT)/gradio_api/mcp/sse"
+
+.PHONY: stop
+stop:
+	-docker stop $(CONTAINER_NAME)
+	-docker rm $(CONTAINER_NAME)
+
+.PHONY: logs
+logs:
+	docker logs -f $(CONTAINER_NAME)
+
+.PHONY: shell
+shell:
+	docker exec -it $(CONTAINER_NAME) /bin/bash
+
+# Testing targets
+.PHONY: test-docker
+test-docker:
+	python test_mcp_server.py --server --wait
+
+.PHONY: test-all
+test-all: test test-docker
+
+# Deployment targets
+.PHONY: deploy-hf
+deploy-hf:
+	@echo "Deploying to Hugging Face Spaces..."
+	@read -p "Enter your HF username: " username; \
+	read -p "Enter space name: " space_name; \
+	python deploy_to_hf.py $$space_name $$username
+
+# Docker Compose targets
+.PHONY: up
+up:
+	docker-compose up -d
+
+.PHONY: down
+down:
+	docker-compose down
+
+.PHONY: restart
+restart: down up
+
+# Cleanup targets
+.PHONY: clean
+clean: stop
+	-docker rmi $(IMAGE_NAME):$(VERSION)
+	-docker system prune -f
+
+.PHONY: clean-all
+clean-all: clean
+	-docker volume prune -f
+	-docker network prune -f
+
+# Development workflow
+.PHONY: dev
+dev: install test build test-docker
+	@echo "Development setup complete!"
+
+# Production workflow
+.PHONY: prod
+prod: clean build test-docker
+	@echo "Production build complete!"
+
+# Quick start
+.PHONY: quick-start
+quick-start: build run-docker
+	@echo "Quick start complete!"
+	@echo "Waiting for server to be ready..."
+	@sleep 5
+	@python test_mcp_server.py --server --url=http://localhost:$(PORT)
+
+# Health check
+.PHONY: health
+health:
+	@curl -f http://localhost:$(PORT)/ || echo "Server not responding"
+
+# Show running containers
+.PHONY: ps
+ps:
+	docker ps --filter "name=$(CONTAINER_NAME)"
+
+# Show image info
+.PHONY: info
+info:
+	@echo "Image: $(IMAGE_NAME):$(VERSION)"
+	@echo "Container: $(CONTAINER_NAME)"
+	@echo "Port: $(PORT)"
+	@docker images $(IMAGE_NAME) || echo "Image not built yet"

README.md

@@ -1,57 +1,215 @@
-# The Model Context Protocol (MCP) Course
+# Docker MCP Sentiment Analysis Server
 
-<div align="center"> <a href="README.md">🇺🇸 English</a> | <a href="README_vi.md">🇻🇳 Tiếng Việt</a> </div>
+This is a containerized Model Context Protocol (MCP) server that provides sentiment analysis capabilities using TextBlob. It's designed to run in Docker containers and can be easily deployed to Hugging Face Spaces or any Docker-compatible hosting platform.
 
-![1](https://github.com/user-attachments/assets/d26dcc5e-46cb-449e-aecb-49ece10d342a)
+## Features
 
-If you like the course, **don't hesitate to ⭐ star this repository**. This helps us to **make the course more visible 🤗**.
+- **Sentiment Analysis**: Comprehensive sentiment analysis with polarity and subjectivity scores
+- **Sentiment Scoring**: Numerical sentiment scoring from -1 (negative) to 1 (positive)
+- **Emotion Classification**: Basic emotion classification (Joy, Sadness, Anger, etc.)
+- **Batch Processing**: Analyze multiple texts at once
+- **Web Interface**: User-friendly Gradio interface for testing
+- **MCP Protocol**: Full MCP server support for AI applications
+- **Docker Ready**: Containerized for consistent deployment
 
-<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/please_star.gif" alt="Star the repo" />
+## Quick Start
 
-## Content
+### Local Development with Docker
 
-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**.
+1. **Build the Docker image:**
+```bash
+cd docker-mcp-server
+docker build -t mcp-sentiment .
+```
+
+2. **Run the container:**
+```bash
+docker run -p 7860:7860 mcp-sentiment
+```
+
+3. **Access the server:**
+- Web interface: http://localhost:7860
+- MCP endpoint: http://localhost:7860/gradio_api/mcp/sse
+
+### Local Development without Docker
+
+1. **Install dependencies:**
+```bash
+cd docker-mcp-server
+pip install -r requirements.txt
+```
+
+2. **Run the server:**
+```bash
+python app.py
+```
 
-Sign up here (it's free) 👉 [Coming Soon]
+## Deployment to Hugging Face Spaces
 
-You can access the course here 👉 [Coming Soon]
+### Method 1: Direct Upload
 
-| 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       | Building with MCP: Practical Development            | Learn to implement MCP clients and servers using available SDKs and frameworks.                         |
-| 3       | MCP Protocol Deep Dive                            | Explore advanced MCP features, architecture, and real-world integration patterns|
-| 4       | Bonus Units & Collaborations                    | Special topics, partner libraries, and community-driven projects.|
+1. **Create a new Space on Hugging Face:**
+   - Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+   - Click "Create new Space"
+   - Choose "Docker" as the SDK
+   - Name your space (e.g., "mcp-sentiment-analysis")
 
-## Prerequisites
+2. **Upload files:**
+   - Copy `app.py` and `requirements.txt` to your Space repository
+   - Ensure `app.py` is in the root directory of your Space
 
-* 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)
+3. **Your server will be available at:**
+   - Web interface: `https://YOUR_USERNAME-mcp-sentiment-analysis.hf.space`
+   - MCP endpoint: `https://YOUR_USERNAME-mcp-sentiment-analysis.hf.space/gradio_api/mcp/sse`
 
-## Contribution Guidelines
+### Method 2: Git Push
 
-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:
+1. **Clone your Space repository:**
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/mcp-sentiment-analysis
+cd mcp-sentiment-analysis
+```
+
+2. **Copy files and push:**
+```bash
+cp ../docker-mcp-server/app.py .
+cp ../docker-mcp-server/requirements.txt .
+git add app.py requirements.txt
+git commit -m "Add MCP sentiment analysis server"
+git push
+```
 
-### Small typo and grammar fixes
+## Available MCP Tools
 
-If you find a small typo or grammar mistake, please fix it yourself and submit a pull request. This is very helpful for students.
+The server provides the following tools that can be used by MCP clients:
 
-### New unit
+### 1. analyze_sentiment
+- **Description**: Comprehensive sentiment analysis
+- **Input**: Text string
+- **Output**: JSON with sentiment, polarity, subjectivity, and interpretation
 
-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.
+### 2. get_sentiment_score
+- **Description**: Numerical sentiment scoring
+- **Input**: Text string
+- **Output**: JSON with sentiment score (-1 to 1)
 
-## Citing the project
+### 3. classify_emotion
+- **Description**: Basic emotion classification
+- **Input**: Text string
+- **Output**: JSON with emotion category and confidence
 
-To cite this repository in publications:
+### 4. batch_analyze
+- **Description**: Analyze multiple texts at once
+- **Input**: Multiple texts (one per line)
+- **Output**: JSON with summary statistics and individual results
 
+## Using the MCP Server
+
+### With MCP Clients
+
+Once deployed, you can connect to your MCP server using various MCP clients:
+
+#### Python (smolagents)
+```python
+from smolagents.mcp_client import MCPClient
+
+with MCPClient(
+    {"url": "https://YOUR_USERNAME-mcp-sentiment-analysis.hf.space/gradio_api/mcp/sse"}
+) as tools:
+    # Use the sentiment analysis tools
+    for tool in tools:
+        print(f"{tool.name}: {tool.description}")
 ```
-@misc{mcp-course,
-  author = Burtenshaw, Ben,
-  title = {The Model Context Protocol Course},
-  year = {2025},
-  howpublished = {\url{https://github.com/huggingface/mcp-course}},
-  note = {GitHub repository},
+
+#### Cursor IDE
+Add to your MCP configuration:
+```json
+{
+  "mcpServers": {
+    "sentiment-analysis": {
+      "command": "npx",
+      "args": [
+        "-y", 
+        "mcp-remote", 
+        "https://YOUR_USERNAME-mcp-sentiment-analysis.hf.space/gradio_api/mcp/sse", 
+        "--transport", 
+        "sse-only"
+      ]
+    }
+  }
 }
 ```
+
+### Direct HTTP Requests
+
+You can also make direct HTTP requests to the MCP endpoint:
+
+```bash
+curl -X POST "https://YOUR_USERNAME-mcp-sentiment-analysis.hf.space/gradio_api/mcp/sse" \
+  -H "Content-Type: application/json" \
+  -d '{"method": "tools/call", "params": {"name": "analyze_sentiment", "arguments": {"text": "I love this!"}}}'
+```
+
+## Configuration
+
+### Environment Variables
+
+- `GRADIO_SERVER_NAME`: Server host (default: "0.0.0.0")
+- `GRADIO_SERVER_PORT`: Server port (default: 7860)
+
+### Docker Configuration
+
+The Dockerfile includes:
+- Python 3.11 slim base image
+- Non-root user for security
+- Health checks
+- Optimized layer caching
+
+## Development
+
+### Adding New Tools
+
+To add new sentiment analysis tools:
+
+1. Create a new function in `app.py`
+2. Add it to the Gradio interface
+3. The function will automatically be available as an MCP tool
+
+### Testing
+
+Test your server locally before deployment:
+
+```bash
+# Build and run
+docker build -t mcp-sentiment .
+docker run -p 7860:7860 mcp-sentiment
+
+# Test the web interface
+open http://localhost:7860
+
+# Test MCP endpoint
+curl http://localhost:7860/gradio_api/mcp/sse
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Port conflicts**: Change the port mapping if 7860 is in use
+2. **Memory issues**: Increase Docker memory limits for large batch processing
+3. **Network issues**: Ensure proper firewall configuration for deployment
+
+### Logs
+
+View container logs:
+```bash
+docker logs <container_id>
+```
+
+## License
+
+This project follows the same license as the MCP Course repository.
+
+## Contributing
+
+Contributions are welcome! Please follow the course contribution guidelines.

app.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+MCP Sentiment Analysis Server with Docker Support
+
+This is a Model Context Protocol (MCP) server that provides sentiment analysis
+capabilities using TextBlob. It's designed to run in Docker containers and
+can be deployed to Hugging Face Spaces.
+
+The server provides the following tools:
+- analyze_sentiment: Analyze the sentiment of text
+- get_sentiment_score: Get numerical sentiment score
+- classify_emotion: Classify text into emotion categories
+"""
+
+import gradio as gr
+from textblob import TextBlob
+import json
+import re
+from typing import Dict, Any, List
+
+
+def improved_sentiment_analysis(text: str) -> tuple[float, float]:
+    """
+    Improved sentiment analysis that handles negations better than TextBlob alone.
+
+    Returns:
+        tuple: (polarity, subjectivity)
+    """
+    # Get TextBlob's analysis
+    blob = TextBlob(text)
+    original_polarity = blob.sentiment.polarity
+    subjectivity = blob.sentiment.subjectivity
+
+    # Define negation patterns
+    negation_patterns = [
+        r"\b(don't|dont|do not|doesn't|doesnt|does not|didn't|didnt|did not)\b",
+        r"\b(won't|wont|will not|wouldn't|wouldnt|would not|can't|cant|cannot)\b",
+        r"\b(shouldn't|shouldnt|should not|isn't|isnt|is not|aren't|arent|are not)\b",
+        r"\b(wasn't|wasnt|was not|weren't|werent|were not|haven't|havent|have not)\b",
+        r"\b(hasn't|hasnt|has not|hadn't|hadnt|had not|never|no|not)\b",
+        r"\b(hate|dislike|terrible|awful|horrible|bad|worst|disgusting)\b"
+    ]
+
+    # Check for negations
+    text_lower = text.lower()
+    negation_found = any(re.search(pattern, text_lower) for pattern in negation_patterns)
+
+    # Adjust polarity if negation is found and TextBlob gave a positive result
+    if negation_found and original_polarity > 0:
+        # Flip the polarity for negated positive statements
+        adjusted_polarity = -abs(original_polarity) * 0.8  # Make it negative but slightly less extreme
+    else:
+        adjusted_polarity = original_polarity
+
+    return adjusted_polarity, subjectivity
+
+
+def analyze_sentiment(text: str) -> str:
+    """
+    Analyze the sentiment of the given text.
+
+    Args:
+        text: The text to analyze
+
+    Returns:
+        A detailed sentiment analysis including polarity and subjectivity
+    """
+    if not text or not text.strip():
+        return "Error: Please provide text to analyze"
+
+    # Use improved sentiment analysis
+    polarity, subjectivity = improved_sentiment_analysis(text)
+
+    # Also get TextBlob's original analysis for comparison
+    blob = TextBlob(text)
+    original_polarity = blob.sentiment.polarity
+
+    # Determine sentiment category with more conservative thresholds
+    if polarity > 0.05:
+        sentiment = "Positive"
+    elif polarity < -0.05:
+        sentiment = "Negative"
+    else:
+        sentiment = "Neutral"
+
+    # Determine subjectivity level
+    if subjectivity > 0.6:
+        subjectivity_level = "Highly subjective"
+    elif subjectivity > 0.3:
+        subjectivity_level = "Moderately subjective"
+    else:
+        subjectivity_level = "Objective"
+
+    # Add debug information to help understand the analysis
+    debug_info = f"Original TextBlob: {original_polarity:.3f} -> Improved: {polarity:.3f}, subjectivity={subjectivity:.3f}"
+
+    result = {
+        "text": text,
+        "sentiment": sentiment,
+        "polarity": round(polarity, 3),
+        "subjectivity": round(subjectivity, 3),
+        "subjectivity_level": subjectivity_level,
+        "interpretation": f"The text is {sentiment.lower()} with a polarity of {polarity:.3f} and is {subjectivity_level.lower()}.",
+        "debug": debug_info
+    }
+
+    return json.dumps(result, indent=2)
+
+
+def get_sentiment_score(text: str) -> str:
+    """
+    Get a numerical sentiment score for the text.
+
+    Args:
+        text: The text to score
+
+    Returns:
+        A numerical score between -1 (very negative) and 1 (very positive)
+    """
+    if not text or not text.strip():
+        return "Error: Please provide text to analyze"
+
+    # Use improved sentiment analysis
+    score, _ = improved_sentiment_analysis(text)
+    
+    result = {
+        "text": text,
+        "sentiment_score": round(score, 3),
+        "scale": "Score ranges from -1 (very negative) to 1 (very positive)"
+    }
+    
+    return json.dumps(result, indent=2)
+
+
+def classify_emotion(text: str) -> str:
+    """
+    Classify the text into basic emotion categories.
+    
+    Args:
+        text: The text to classify
+        
+    Returns:
+        Emotion classification based on sentiment analysis
+    """
+    if not text or not text.strip():
+        return "Error: Please provide text to analyze"
+    
+    blob = TextBlob(text)
+    polarity = blob.sentiment.polarity
+    subjectivity = blob.sentiment.subjectivity
+    
+    # Simple emotion classification based on polarity and subjectivity
+    if polarity > 0.5:
+        emotion = "Joy"
+    elif polarity > 0.1:
+        emotion = "Contentment"
+    elif polarity < -0.5:
+        emotion = "Anger" if subjectivity > 0.5 else "Sadness"
+    elif polarity < -0.1:
+        emotion = "Disappointment"
+    else:
+        if subjectivity > 0.7:
+            emotion = "Confusion"
+        else:
+            emotion = "Neutral"
+    
+    confidence = abs(polarity) if abs(polarity) > 0.1 else 0.1
+    
+    result = {
+        "text": text,
+        "emotion": emotion,
+        "confidence": round(confidence, 3),
+        "polarity": round(polarity, 3),
+        "subjectivity": round(subjectivity, 3)
+    }
+    
+    return json.dumps(result, indent=2)
+
+
+def batch_analyze(texts: str) -> str:
+    """
+    Analyze multiple texts at once (one per line).
+    
+    Args:
+        texts: Multiple texts separated by newlines
+        
+    Returns:
+        Batch analysis results
+    """
+    if not texts or not texts.strip():
+        return "Error: Please provide texts to analyze (one per line)"
+    
+    lines = [line.strip() for line in texts.split('\n') if line.strip()]
+    if not lines:
+        return "Error: No valid text lines found"
+    
+    results = []
+    for i, text in enumerate(lines, 1):
+        # Use improved sentiment analysis
+        polarity, _ = improved_sentiment_analysis(text)
+
+        # Use the same conservative thresholds as analyze_sentiment
+        if polarity > 0.05:
+            sentiment = "Positive"
+        elif polarity < -0.05:
+            sentiment = "Negative"
+        else:
+            sentiment = "Neutral"
+
+        results.append({
+            "line": i,
+            "text": text,
+            "sentiment": sentiment,
+            "polarity": round(polarity, 3)
+        })
+    
+    summary = {
+        "total_texts": len(results),
+        "positive": len([r for r in results if r["sentiment"] == "Positive"]),
+        "negative": len([r for r in results if r["sentiment"] == "Negative"]),
+        "neutral": len([r for r in results if r["sentiment"] == "Neutral"]),
+        "average_polarity": round(sum(r["polarity"] for r in results) / len(results), 3)
+    }
+    
+    return json.dumps({
+        "summary": summary,
+        "results": results
+    }, indent=2)
+
+
+# Create the main MCP interface - using TabbedInterface to expose all functions as MCP tools
+demo = gr.TabbedInterface(
+    [
+        gr.Interface(
+            fn=analyze_sentiment,
+            inputs=gr.Textbox(placeholder="Enter text to analyze...", label="Text"),
+            outputs=gr.JSON(label="Analysis Result"),
+            title="Sentiment Analysis",
+            description="Analyze the sentiment of text using TextBlob"
+        ),
+        gr.Interface(
+            fn=get_sentiment_score,
+            inputs=gr.Textbox(placeholder="Enter text to score...", label="Text"),
+            outputs=gr.JSON(label="Score Result"),
+            title="Sentiment Score",
+            description="Get numerical sentiment score (-1 to 1)"
+        ),
+        gr.Interface(
+            fn=classify_emotion,
+            inputs=gr.Textbox(placeholder="Enter text to classify...", label="Text"),
+            outputs=gr.JSON(label="Emotion Result"),
+            title="Emotion Classification",
+            description="Classify text into emotion categories"
+        ),
+        gr.Interface(
+            fn=batch_analyze,
+            inputs=gr.Textbox(placeholder="Enter multiple texts, one per line...", label="Texts", lines=5),
+            outputs=gr.JSON(label="Batch Results"),
+            title="Batch Analysis",
+            description="Analyze multiple texts at once"
+        )
+    ],
+    tab_names=["Sentiment Analysis", "Sentiment Score", "Emotion Classification", "Batch Analysis"],
+    title="MCP Sentiment Analysis Server"
+)
+
+
+if __name__ == "__main__":
+    # Launch the Gradio app with MCP server support
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        mcp_server=True  # This enables MCP protocol support
+    )

demo.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Demo script showing how to use the MCP Sentiment Analysis Server
+
+This script demonstrates various ways to interact with the MCP server:
+1. Direct function calls (local testing)
+2. HTTP requests to the MCP endpoint
+3. Using the smolagents MCP client (if available)
+"""
+
+import json
+import requests
+import sys
+from typing import Dict, Any
+
+# Import local functions for testing
+try:
+    from app import analyze_sentiment, get_sentiment_score, classify_emotion, batch_analyze
+    LOCAL_FUNCTIONS_AVAILABLE = True
+except ImportError:
+    LOCAL_FUNCTIONS_AVAILABLE = False
+    print("⚠️  Local functions not available. Make sure you're in the docker-mcp-server directory.")
+
+
+def demo_local_functions():
+    """Demonstrate the sentiment analysis functions directly."""
+    print("🔧 Testing Local Functions")
+    print("=" * 40)
+    
+    if not LOCAL_FUNCTIONS_AVAILABLE:
+        print("❌ Local functions not available")
+        return
+    
+    # Test texts
+    texts = [
+        "I absolutely love this product! It's amazing!",
+        "This is terrible and I hate it.",
+        "The weather is okay today.",
+        "I'm feeling confused about this situation."
+    ]
+    
+    for i, text in enumerate(texts, 1):
+        print(f"\n📝 Test {i}: '{text}'")
+        
+        # Analyze sentiment
+        result = analyze_sentiment(text)
+        data = json.loads(result)
+        print(f"   Sentiment: {data['sentiment']} (polarity: {data['polarity']})")
+        
+        # Get emotion
+        emotion_result = classify_emotion(text)
+        emotion_data = json.loads(emotion_result)
+        print(f"   Emotion: {emotion_data['emotion']} (confidence: {emotion_data['confidence']})")
+    
+    # Test batch analysis
+    print(f"\n📊 Batch Analysis:")
+    batch_text = "\n".join(texts)
+    batch_result = batch_analyze(batch_text)
+    batch_data = json.loads(batch_result)
+    print(f"   Total texts: {batch_data['summary']['total_texts']}")
+    print(f"   Positive: {batch_data['summary']['positive']}")
+    print(f"   Negative: {batch_data['summary']['negative']}")
+    print(f"   Neutral: {batch_data['summary']['neutral']}")
+    print(f"   Average polarity: {batch_data['summary']['average_polarity']}")
+
+
+def demo_http_requests(base_url: str = "http://localhost:7860"):
+    """Demonstrate HTTP requests to the MCP server."""
+    print("\n🌐 Testing HTTP Requests")
+    print("=" * 40)
+    
+    # Test if server is running
+    try:
+        response = requests.get(base_url, timeout=5)
+        if response.status_code != 200:
+            print(f"❌ Server not accessible at {base_url}")
+            return
+    except requests.exceptions.RequestException:
+        print(f"❌ Cannot connect to server at {base_url}")
+        print("   Make sure the server is running with: docker run -p 7860:7860 mcp-sentiment")
+        return
+    
+    print(f"✅ Server accessible at {base_url}")
+    
+    # Test MCP endpoint
+    mcp_url = f"{base_url}/gradio_api/mcp/sse"
+    try:
+        response = requests.get(mcp_url, timeout=5)
+        print(f"✅ MCP endpoint accessible at {mcp_url}")
+    except requests.exceptions.RequestException as e:
+        print(f"❌ MCP endpoint not accessible: {e}")
+
+
+def demo_mcp_client(server_url: str = "http://localhost:7860/gradio_api/mcp/sse"):
+    """Demonstrate using the smolagents MCP client."""
+    print("\n🤖 Testing MCP Client")
+    print("=" * 40)
+    
+    try:
+        from smolagents.mcp_client import MCPClient
+        
+        print(f"Connecting to MCP server at {server_url}...")
+        
+        with MCPClient({"url": server_url}) as tools:
+            print(f"✅ Connected! Available tools:")
+            for tool in tools:
+                print(f"   - {tool.name}: {tool.description}")
+            
+            # Test a tool
+            if tools:
+                print(f"\n🧪 Testing first tool...")
+                # This would require more specific implementation
+                # depending on how the MCP client works
+                
+    except ImportError:
+        print("❌ smolagents not available")
+        print("   Install with: pip install smolagents")
+    except Exception as e:
+        print(f"❌ MCP client error: {e}")
+
+
+def demo_gradio_api(base_url: str = "http://localhost:7860"):
+    """Demonstrate using the Gradio API directly."""
+    print("\n🎨 Testing Gradio API")
+    print("=" * 40)
+    
+    # This is a simplified example - actual Gradio API usage
+    # would require knowing the specific endpoint structure
+    try:
+        # Test basic connectivity
+        response = requests.get(f"{base_url}/api/", timeout=5)
+        if response.status_code == 200:
+            print("✅ Gradio API accessible")
+        else:
+            print(f"⚠️  Gradio API returned status {response.status_code}")
+    except requests.exceptions.RequestException:
+        print("❌ Gradio API not accessible")
+
+
+def main():
+    """Run all demos."""
+    print("🎭 MCP Sentiment Analysis Server Demo")
+    print("=" * 50)
+    
+    # Parse command line arguments
+    server_url = "http://localhost:7860"
+    mcp_url = f"{server_url}/gradio_api/mcp/sse"
+    
+    for arg in sys.argv[1:]:
+        if arg.startswith("--url="):
+            server_url = arg.split("=", 1)[1]
+            mcp_url = f"{server_url}/gradio_api/mcp/sse"
+    
+    # Run demos
+    if LOCAL_FUNCTIONS_AVAILABLE:
+        demo_local_functions()
+    
+    demo_http_requests(server_url)
+    demo_gradio_api(server_url)
+    demo_mcp_client(mcp_url)
+    
+    print("\n🎉 Demo completed!")
+    print("\nNext steps:")
+    print("1. Deploy to Hugging Face Spaces using: python deploy_to_hf.py")
+    print("2. Connect your MCP clients to the deployed endpoint")
+    print("3. Use the sentiment analysis tools in your AI applications")
+
+
+if __name__ == "__main__":
+    if "--help" in sys.argv or "-h" in sys.argv:
+        print("Usage: python demo.py [--url=SERVER_URL]")
+        print("\nOptions:")
+        print("  --url=URL    Server URL (default: http://localhost:7860)")
+        print("  --help, -h   Show this help message")
+        print("\nExamples:")
+        print("  python demo.py")
+        print("  python demo.py --url=https://myspace.hf.space")
+        sys.exit(0)
+    
+    main()

deploy_to_hf.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+Deployment script for Hugging Face Spaces
+
+This script helps deploy the MCP server to Hugging Face Spaces.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import argparse
+from pathlib import Path
+
+
+def check_git():
+    """Check if git is available."""
+    try:
+        subprocess.run(["git", "--version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("❌ Git is not installed or not available in PATH")
+        return False
+
+
+def check_huggingface_hub():
+    """Check if huggingface_hub is available."""
+    try:
+        import huggingface_hub
+        return True
+    except ImportError:
+        print("❌ huggingface_hub is not installed")
+        print("Install it with: pip install huggingface_hub")
+        return False
+
+
+def create_space_files(space_dir: Path):
+    """Create the necessary files for Hugging Face Spaces."""
+    # Copy main files
+    shutil.copy("app.py", space_dir / "app.py")
+    shutil.copy("requirements.txt", space_dir / "requirements.txt")
+    
+    # Create README for the space
+    readme_content = """---
+title: MCP Sentiment Analysis Server
+emoji: 🎭
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "5.0.0"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# MCP Sentiment Analysis Server
+
+This is a Model Context Protocol (MCP) server that provides sentiment analysis capabilities.
+
+## Features
+
+- Comprehensive sentiment analysis
+- Numerical sentiment scoring
+- Emotion classification
+- Batch text processing
+- Full MCP protocol support
+
+## Usage
+
+### Web Interface
+Use the interface above to test the sentiment analysis tools.
+
+### MCP Endpoint
+Connect your MCP clients to: `https://YOUR_USERNAME-SPACE_NAME.hf.space/gradio_api/mcp/sse`
+
+### Available Tools
+- `analyze_sentiment`: Comprehensive sentiment analysis
+- `get_sentiment_score`: Numerical sentiment scoring (-1 to 1)
+- `classify_emotion`: Basic emotion classification
+- `batch_analyze`: Analyze multiple texts at once
+
+## Example with smolagents
+
+```python
+from smolagents.mcp_client import MCPClient
+
+with MCPClient(
+    {"url": "https://YOUR_USERNAME-SPACE_NAME.hf.space/gradio_api/mcp/sse"}
+) as tools:
+    for tool in tools:
+        print(f"{tool.name}: {tool.description}")
+```
+
+## Example with Cursor IDE
+
+Add to your MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "sentiment-analysis": {
+      "command": "npx",
+      "args": [
+        "-y", 
+        "mcp-remote", 
+        "https://YOUR_USERNAME-SPACE_NAME.hf.space/gradio_api/mcp/sse", 
+        "--transport", 
+        "sse-only"
+      ]
+    }
+  }
+}
+```
+"""
+    
+    with open(space_dir / "README.md", "w") as f:
+        f.write(readme_content)
+    
+    print(f"✅ Created space files in {space_dir}")
+
+
+def deploy_with_git(space_name: str, username: str):
+    """Deploy using git commands."""
+    space_dir = Path(f"./hf_space_{space_name}")
+    
+    if space_dir.exists():
+        print(f"Directory {space_dir} already exists. Remove it first or use a different name.")
+        return False
+    
+    try:
+        # Clone the space repository
+        repo_url = f"https://huggingface.co/spaces/{username}/{space_name}"
+        print(f"Cloning {repo_url}...")
+        subprocess.run(["git", "clone", repo_url, str(space_dir)], check=True)
+        
+        # Create space files
+        create_space_files(space_dir)
+        
+        # Git operations
+        os.chdir(space_dir)
+        subprocess.run(["git", "add", "."], check=True)
+        subprocess.run(["git", "commit", "-m", "Deploy MCP sentiment analysis server"], check=True)
+        subprocess.run(["git", "push"], check=True)
+        
+        print(f"✅ Successfully deployed to {repo_url}")
+        print(f"🌐 Your space will be available at: https://{username}-{space_name}.hf.space")
+        print(f"🔗 MCP endpoint: https://{username}-{space_name}.hf.space/gradio_api/mcp/sse")
+        
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Git operation failed: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Deployment failed: {e}")
+        return False
+    finally:
+        # Go back to original directory
+        os.chdir("..")
+
+
+def deploy_with_hub_api(space_name: str, username: str):
+    """Deploy using Hugging Face Hub API."""
+    try:
+        from huggingface_hub import HfApi, create_repo
+        
+        api = HfApi()
+        
+        # Create the space repository
+        repo_id = f"{username}/{space_name}"
+        print(f"Creating space {repo_id}...")
+        
+        create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="gradio",
+            exist_ok=True
+        )
+        
+        # Upload files
+        print("Uploading files...")
+        api.upload_file(
+            path_or_fileobj="app.py",
+            path_in_repo="app.py",
+            repo_id=repo_id,
+            repo_type="space"
+        )
+        
+        api.upload_file(
+            path_or_fileobj="requirements.txt",
+            path_in_repo="requirements.txt",
+            repo_id=repo_id,
+            repo_type="space"
+        )
+        
+        # Create and upload README
+        space_dir = Path("./temp_space")
+        space_dir.mkdir(exist_ok=True)
+        create_space_files(space_dir)
+        
+        api.upload_file(
+            path_or_fileobj=str(space_dir / "README.md"),
+            path_in_repo="README.md",
+            repo_id=repo_id,
+            repo_type="space"
+        )
+        
+        # Cleanup
+        shutil.rmtree(space_dir)
+        
+        print(f"✅ Successfully deployed to https://huggingface.co/spaces/{repo_id}")
+        print(f"🌐 Your space will be available at: https://{username}-{space_name}.hf.space")
+        print(f"🔗 MCP endpoint: https://{username}-{space_name}.hf.space/gradio_api/mcp/sse")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Hub API deployment failed: {e}")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deploy MCP server to Hugging Face Spaces")
+    parser.add_argument("space_name", help="Name of the Hugging Face Space")
+    parser.add_argument("username", help="Your Hugging Face username")
+    parser.add_argument("--method", choices=["git", "api"], default="git",
+                       help="Deployment method (default: git)")
+    parser.add_argument("--check-only", action="store_true",
+                       help="Only check prerequisites without deploying")
+    
+    args = parser.parse_args()
+    
+    print("🚀 MCP Server Deployment to Hugging Face Spaces")
+    print("=" * 50)
+    
+    # Check prerequisites
+    print("Checking prerequisites...")
+    
+    if not Path("app.py").exists():
+        print("❌ app.py not found in current directory")
+        return 1
+    
+    if not Path("requirements.txt").exists():
+        print("❌ requirements.txt not found in current directory")
+        return 1
+    
+    git_ok = check_git()
+    hub_ok = check_huggingface_hub()
+    
+    if args.method == "git" and not git_ok:
+        print("❌ Git method selected but git is not available")
+        return 1
+    
+    if args.method == "api" and not hub_ok:
+        print("❌ API method selected but huggingface_hub is not available")
+        return 1
+    
+    if args.check_only:
+        print("✅ All prerequisites check passed")
+        return 0
+    
+    # Deploy
+    print(f"\nDeploying '{args.space_name}' for user '{args.username}' using {args.method} method...")
+    
+    if args.method == "git":
+        success = deploy_with_git(args.space_name, args.username)
+    else:
+        success = deploy_with_hub_api(args.space_name, args.username)
+    
+    if success:
+        print("\n🎉 Deployment completed successfully!")
+        print("\nNext steps:")
+        print("1. Wait a few minutes for the space to build")
+        print("2. Test the web interface")
+        print("3. Test the MCP endpoint with your clients")
+        return 0
+    else:
+        print("\n💥 Deployment failed!")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

quiz/README.md

@@ -1 +0,0 @@
-# MCP Course quiz scripts

quiz/data/unit_1.json

@@ -1,10 +0,0 @@
-[
-    {
-        "question": "Which of the following best describes a Large Language Model (LLM)?",
-        "answer_a": "A model specializing in language recognition",
-        "answer_b": "A massive neural network that understands and generates human language",
-        "answer_c": "A model exclusively used for language data tasks like summarization or classification",
-        "answer_d": "A rule-based chatbot used for conversations",
-        "correct_answer": "B"
-    }
-]

quiz/push_questions.py

@@ -1,31 +0,0 @@
-import json
-from pathlib import Path
-from datasets import Dataset
-
-ORG_NAME = "mcp-course"
-
-
-def main():
-    """Push quiz questions to the Hugging Face Hub"""
-
-    for file in Path("data").glob("*.json"):
-        print(f"Processing {file}")
-
-        with open(file, "r") as f:
-            quiz_data = json.load(f)
-
-        repo_id = f"{ORG_NAME}/{file.stem}_quiz"
-
-        dataset = Dataset.from_list(quiz_data)
-
-        print(f"Pushing {repo_id} to the Hugging Face Hub")
-
-        dataset.push_to_hub(
-            repo_id,
-            private=True,
-            commit_message=f"Update quiz questions for {file.stem}",
-        )
-
-
-if __name__ == "__main__":
-    main()

quiz/pyproject.toml

@@ -1,12 +0,0 @@
-[project]
-name = "agents-course"
-version = "0.1.0"
-description = "Add your description here"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = [
-    "datasets>=3.2.0",
-    "huggingface-hub>=0.27.1",
-    "ipykernel>=6.29.5",
-    "requests>=2.32.3",
-]

requirements.txt

@@ -1,3 +1,10 @@
-hf-doc-builder>=0.5.0
-mdx_truly_sane_lists
-pyyaml 
+# Core dependencies for MCP server
+gradio[mcp]>=5.0.0
+textblob>=0.17.1
+
+# Additional dependencies for better functionality
+numpy>=1.24.0
+requests>=2.31.0
+
+# Development and debugging (optional)
+uvicorn>=0.23.0

scripts/translation.py

@@ -1,85 +0,0 @@
-import os
-import sys
-from huggingface_hub import InferenceClient
-from dotenv import load_dotenv
-load_dotenv()
-
-
-hf_token = os.environ.get("HF_TOKEN")
-if not hf_token:
-    raise ValueError("HF_TOKEN not found in environment variables. Please set it in a .env file.")
-
-
-# Get the directory containing the current script
-script_dir = os.path.dirname(os.path.abspath(__file__))
-default_inp_dir = os.path.join(script_dir, '..', 'units/en')
-default_model = "deepseek-ai/DeepSeek-R1"
-default_client = InferenceClient(
-    provider="together",
-    # api_key is read from the environment
-)
-
-def auto_translate(
-    output_lang: str,
-    prompt: callable,
-    inp_dir: str = default_inp_dir,
-    model: str = default_model,
-    client: InferenceClient = default_client
-):
-    get_output_path = lambda x: x.replace('/en', f'/{output_lang}')
-    escape_special_tokens = lambda x: x.replace('<think>', '<%%think%%>').replace('</think>', '<%%/think%%>')
-    unescape_special_tokens = lambda x: x.replace('<%%think%%>', '<think>').replace('<%%/think%%>', '</think>')
-
-    # Get the list of all files in the directory, recursively
-    inp_files: list[str] = []
-    print('Collecting files...')
-    for root, dirs, files in os.walk(inp_dir):
-        for file in files:
-            if file.endswith('.mdx') or file == "_toctree.yml":
-                fname = os.path.join(root, file)
-                print('  +', fname)
-                inp_files.append(fname)
-
-    def write_out_file(fpath: str, content: str):
-        base_path = os.path.dirname(fpath)
-        os.makedirs(base_path, exist_ok=True)
-        with open(fpath, 'w', encoding='utf-8') as f:
-            f.write(content)
-
-    # Read the content of the file and process
-    for i, inp_file in enumerate(inp_files):
-        out_file = get_output_path(inp_file)
-        if os.path.exists(out_file):
-            print(f'[{i+1}/{len(inp_files)}] Skipping file: {inp_file}')
-            continue
-        with open(inp_file, 'r', encoding='utf-8') as f:
-            content: str = f.read()
-            content = escape_special_tokens(content)
-            if content.strip() == "":
-                print(f'[{i+1}/{len(inp_files)}] Skipping empty file: {inp_file}')
-                write_out_file(out_file, "")
-                continue
-
-            print(f'[{i+1}/{len(inp_files)}] Processing file: {inp_file}')
-            stream = client.chat.completions.create(
-                model=model,
-                temperature=0.0,
-                messages=[
-                    {"role": "user", "content": prompt(content)},
-                ],
-                stream=True,
-            )
-            final_text = ""
-            for chunk in stream:
-                content_chunk = chunk.choices[0].delta.content
-                print(content_chunk, end="", flush=True)
-                final_text += content_chunk
-            # Optionally filter <think>...</think> reasoning process
-            final_text = final_text.split('</think>').pop().strip()
-            # Write the output to the file
-            final_text = unescape_special_tokens(final_text)
-            write_out_file(out_file, final_text)
-            print()
-            print(f'  -> Translated to: {out_file}')
-            print("--" * 20)
-            #break

scripts/vi.py

@@ -1,125 +0,0 @@
-from translation import auto_translate
-
-output_lang = "vi"
-
-# Fix the prompt function to escape curly braces in the content
-prompt = lambda content: f'''
-You are a translator for the Vietnamese translation team. You are tasked with translating the following texts into Vietnamese. You must follow these instructions:
-- Translate the texts into Vietnamese, while keeping the original formatting (either Markdown, MDX or HTML)
-- Inside code blocks, translate the comments but leave the code as-is; If the code block contains quite plain texts, you MUST provide the translation in <details> tag
-- Do not translate inline code, the URLs and file paths
-- If the term is abbreviated, keep the original term and provide the translation in parentheses for the first time it appears in the text
-- If there are any slag or funny joke in english, keep it (do not translate) and give an explanation so Vietnamese reader can understand
-- Use "ta", "mình, "chúng ta", "chúng mình", "các bạn" as pronouns
-
-KEEP THESE TERMS (DO NOT TRANSLATE, do NOT add translation in parentheses): MCP, API, SDK, CLI, HTML, GGUF, AI, Client, Server, Hugging Face, Space, CodeAgent, LangGraph, LangChain, Llama, Gemma, inference, notebook, python, transformers, token, pretrain, format, certificate.
-
-For these terms, use the pre-defined translation:
-- Quick Quiz: Kiểm tra nhanh
-- Unit: Chương
-- Bonus Unit: Chương bổ trợ
-- Module: Mô-đun
-- Lesson ...: Bài ...
-- Model: Mô hình
-- Dataset: Tập dữ liệu
-- Course: Khóa học
-- state-of-the-art: nổi tiếng
-- Q&A: Hỏi và Đáp
-- Dummy: ảo (or "giả", or "thử" depending on the context)
-- onboarding: làm quen
-- Hands-on: Thực hành
-- Challenge: Bài tập lớn
-- Training: Huấn luyện
-- Model Context Protocol: Giao Thức Ngữ Cảnh Mô Hình
-
-Here is an example:
-- Original text: [Agents Course](https://huggingface.co/learn/agents-course/) will guide you through building AI agents with LLMs.
-- Translation: [Agents Course](https://huggingface.co/learn/agents-course/) sẽ hướng dẫn các bạn cách xây dựng AI Agents với LLMs.
-
-Here is another example:
-- Original text: JSON-RPC defines the message format, but MCP also specifies how these messages are transported between Clients and Servers.
-- Translation: JSON-RPC định nghĩa định dạng tin nhắn, nhưng MCP cũng chỉ định cách thức các tin nhắn này được truyền tải giữa Máy khách và Máy chủ.
-
-If the code block contains many plain texts, prove translation in collapsible <details> tag. Example:
-- Original text:
-    ```python
-    def get_weather(location: str) -> dict:
-        """Get the current weather for a specified location."""
-        # Connect to weather API and fetch data
-        return {{
-            "temperature": 72,
-            "conditions": "Sunny",
-            "humidity": 45
-        }}
-    ```
-- Translation (add the <details> collapsible ABOVE of the original code block):
-    <details>
-    <summary>Bấm để xem bản dịch tiếng Việt</summary>
-    ```
-    def get_weather(location: str) -> dict:
-        """Nhận thông tin thời tiết hiện tại ở một địa điểm cụ thể."""
-        # Connect to weather API and fetch data
-        return {{
-            "temperature": 72,
-            "conditions": "Sunny",
-            "humidity": 45
-        }}
-    ```
-    </details>
-    ```
-    def get_weather(location: str) -> dict:
-        """Get the current weather for a specified location."""
-        # Connect to weather API and fetch data
-        return {{
-            "temperature": 72,
-            "conditions": "Sunny",
-            "humidity": 45
-        }}
-    ```
-
-If the code block does not contain any plain texts or comments, leave it as it is. Example:
-- Original text:
-    ```json
-    {{
-    "servers": [
-        {{
-        "name": "File Explorer",
-        "transport": {{
-            "type": "stdio",
-            "command": "python",
-            "args": ["/path/to/file_explorer_server.py"]
-        }}
-        }}
-    ]
-    }}
-    ```
-
-- Translation:
-    ```json
-    {{
-    "servers": [
-        {{
-        "name": "File Explorer",
-        "transport": {{
-            "type": "stdio",
-            "command": "python",
-            "args": ["/path/to/file_explorer_server.py"]
-        }}
-        }}
-    ]
-    }}
-    ```
-
-IMPORTANT: Only output the translated texts and nothing else, no need explaination or instruction. The input text is between "=== BEGIN OF TEXT ===" and "=== END OF TEXT ===".
-
-Please translate the following texts to Vietnamese:
-
-=== BEGIN OF TEXT ===
-{content}
-=== END OF TEXT ===
-'''.strip()
-
-auto_translate(
-    prompt=prompt,
-    output_lang=output_lang,
-)

test_mcp_server.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Test script for the MCP Sentiment Analysis Server
+
+This script tests the MCP server functionality both locally and remotely.
+"""
+
+import requests
+import json
+import time
+import sys
+from typing import Dict, Any
+
+
+def test_web_interface(base_url: str = "http://localhost:7860") -> bool:
+    """Test if the web interface is accessible."""
+    try:
+        response = requests.get(base_url, timeout=10)
+        if response.status_code == 200:
+            print(f"✅ Web interface accessible at {base_url}")
+            return True
+        else:
+            print(f"❌ Web interface returned status {response.status_code}")
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Failed to connect to web interface: {e}")
+        return False
+
+
+def test_mcp_endpoint(base_url: str = "http://localhost:7860") -> bool:
+    """Test if the MCP endpoint is accessible."""
+    mcp_url = f"{base_url}/gradio_api/mcp/sse"
+    try:
+        # Test basic connectivity
+        response = requests.get(mcp_url, timeout=10)
+        print(f"✅ MCP endpoint accessible at {mcp_url}")
+        return True
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Failed to connect to MCP endpoint: {e}")
+        return False
+
+
+def test_sentiment_functions() -> bool:
+    """Test the sentiment analysis functions directly."""
+    try:
+        # Import the functions from app.py
+        import sys
+        import os
+        sys.path.append(os.path.dirname(__file__))
+        
+        from app import analyze_sentiment, get_sentiment_score, classify_emotion, batch_analyze
+        
+        # Test analyze_sentiment
+        result = analyze_sentiment("I love this product!")
+        result_data = json.loads(result)
+        assert "sentiment" in result_data
+        assert result_data["sentiment"] == "Positive"
+        print("✅ analyze_sentiment function works")
+        
+        # Test get_sentiment_score
+        result = get_sentiment_score("This is terrible!")
+        result_data = json.loads(result)
+        assert "sentiment_score" in result_data
+        assert result_data["sentiment_score"] < 0
+        print("✅ get_sentiment_score function works")
+        
+        # Test classify_emotion
+        result = classify_emotion("I'm so happy today!")
+        result_data = json.loads(result)
+        assert "emotion" in result_data
+        print("✅ classify_emotion function works")
+        
+        # Test batch_analyze
+        result = batch_analyze("I love this!\nThis is bad.\nNeutral statement.")
+        result_data = json.loads(result)
+        assert "summary" in result_data
+        assert result_data["summary"]["total_texts"] == 3
+        print("✅ batch_analyze function works")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Function tests failed: {e}")
+        return False
+
+
+def test_gradio_api(base_url: str = "http://localhost:7860") -> bool:
+    """Test the Gradio API endpoints."""
+    try:
+        # Test the analyze_sentiment endpoint
+        api_url = f"{base_url}/api/predict"
+        
+        # This is a basic test - actual Gradio API testing would require
+        # more specific endpoint knowledge
+        print("ℹ️  Gradio API testing requires running server")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Gradio API test failed: {e}")
+        return False
+
+
+def wait_for_server(base_url: str = "http://localhost:7860", max_wait: int = 60) -> bool:
+    """Wait for the server to become available."""
+    print(f"Waiting for server at {base_url}...")
+    
+    for i in range(max_wait):
+        try:
+            response = requests.get(base_url, timeout=5)
+            if response.status_code == 200:
+                print(f"✅ Server is ready after {i+1} seconds")
+                return True
+        except requests.exceptions.RequestException:
+            pass
+        
+        time.sleep(1)
+        if (i + 1) % 10 == 0:
+            print(f"Still waiting... ({i+1}/{max_wait} seconds)")
+    
+    print(f"❌ Server did not become available within {max_wait} seconds")
+    return False
+
+
+def main():
+    """Run all tests."""
+    print("🧪 Testing MCP Sentiment Analysis Server")
+    print("=" * 50)
+    
+    # Test functions directly (doesn't require server)
+    print("\n📋 Testing sentiment analysis functions...")
+    functions_ok = test_sentiment_functions()
+    
+    # Check if we should test the server
+    test_server = "--server" in sys.argv or len(sys.argv) == 1
+    base_url = "http://localhost:7860"
+    
+    # Allow custom URL
+    for arg in sys.argv:
+        if arg.startswith("--url="):
+            base_url = arg.split("=", 1)[1]
+    
+    if test_server:
+        print(f"\n🌐 Testing server at {base_url}...")
+        
+        # Wait for server if needed
+        if "--wait" in sys.argv:
+            server_ready = wait_for_server(base_url)
+            if not server_ready:
+                print("❌ Server tests skipped - server not available")
+                return 1 if not functions_ok else 0
+        
+        # Test server endpoints
+        web_ok = test_web_interface(base_url)
+        mcp_ok = test_mcp_endpoint(base_url)
+        api_ok = test_gradio_api(base_url)
+        
+        server_ok = web_ok and mcp_ok and api_ok
+    else:
+        print("\n⏭️  Server tests skipped (use --server to enable)")
+        server_ok = True
+    
+    # Summary
+    print("\n📊 Test Summary")
+    print("=" * 50)
+    print(f"Functions: {'✅ PASS' if functions_ok else '❌ FAIL'}")
+    if test_server:
+        print(f"Server:    {'✅ PASS' if server_ok else '❌ FAIL'}")
+    
+    overall_success = functions_ok and (server_ok if test_server else True)
+    print(f"Overall:   {'✅ PASS' if overall_success else '❌ FAIL'}")
+    
+    if overall_success:
+        print("\n🎉 All tests passed!")
+        return 0
+    else:
+        print("\n💥 Some tests failed!")
+        return 1
+
+
+if __name__ == "__main__":
+    if "--help" in sys.argv or "-h" in sys.argv:
+        print("Usage: python test_mcp_server.py [options]")
+        print("\nOptions:")
+        print("  --server          Test server endpoints (default: enabled)")
+        print("  --wait            Wait for server to become available")
+        print("  --url=URL         Use custom server URL (default: http://localhost:7860)")
+        print("  --help, -h        Show this help message")
+        print("\nExamples:")
+        print("  python test_mcp_server.py")
+        print("  python test_mcp_server.py --wait")
+        print("  python test_mcp_server.py --url=https://myspace.hf.space")
+        sys.exit(0)
+    
+    sys.exit(main())

units/en/_toctree.yml

@@ -1,54 +0,0 @@
-- 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/quiz1
-    title: Quiz 1 - MCP Fundamentals
-  - local: unit1/communication-protocol
-    title: The Communication Protocol
-  - local: unit1/capabilities
-    title: Understanding MCP Capabilities
-  - local: unit1/sdk
-    title: MCP SDK
-  - local: unit1/quiz2
-    title: Quiz 2 - MCP SDK
-  - local: unit1/mcp-clients
-    title: MCP Clients
-  - local: unit1/gradio-mcp
-    title: Gradio MCP Integration
-  - local: unit1/unit1-recap
-    title: Unit 1 Recap
-  - local: unit1/certificate
-    title: Get your certificate!
-
-- 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 Tiny Agents with MCP and the Hugging Face Hub
-
-- 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

@@ -1,137 +0,0 @@
-# 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.
-
-## 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 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](https://discord.gg/UrrTSsSyjb): 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 on building LLM applications, with post training and agentic approaches. [Follow Ben on the Hub](https://huggingface.co/burtenshaw) to see his latest projects.
-
-<!-- ## 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](https://github.com/huggingface/mcp-course/issues/new) and **describe the problem**.
-* If you _want to improve the course_, you can [open a Pull Request](https://github.com/huggingface/mcp-course/pulls).
-* If you _want to add a full section or a new unit_, the best is to [open an issue](https://github.com/huggingface/mcp-course/issues/new) 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

@@ -1,85 +0,0 @@
-# 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.

units/en/unit1/capabilities.mdx

@@ -1,243 +0,0 @@
-# Understanding MCP Capabilities
-
-MCP Servers expose a variety of capabilities to Clients through the communication protocol. These capabilities fall into four main categories, each with distinct characteristics and use cases. Let's explore these core primitives that form the foundation of MCP's functionality.
-
-<Tip>
-
-In this section, we'll show examples as framework agnostic functions in each language. This is to focus on the concepts and how they work together, rather than the complexities of any framework.
-
-In the coming units, we'll show how these concepts are implemented in MCP specific code.
-
-</Tip>
-
-## Tools
-
-Tools are executable functions or actions that the AI model can invoke through the MCP protocol.
-
-- **Control**: Tools are typically **model-controlled**, meaning that the AI model (LLM) decides when to call them based on the user's request and context.
-- **Safety**: Due to their ability to perform actions with side effects, tool execution can be dangerous. Therefore, they typically require explicit user approval.
-- **Use Cases**: Sending messages, creating tickets, querying APIs, performing calculations.
-
-**Example**: A weather tool that fetches current weather data for a given location:
-
-<hfoptions id="tool-example">
-<hfoption id="python">
-
-```python
-def get_weather(location: str) -> dict:
-    """Get the current weather for a specified location."""
-    # Connect to weather API and fetch data
-    return {
-        "temperature": 72,
-        "conditions": "Sunny",
-        "humidity": 45
-    }
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-```javascript
-function getWeather(location) {
-    // Connect to weather API and fetch data
-    return {
-        temperature: 72,
-        conditions: 'Sunny',
-        humidity: 45
-    };
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Resources
-
-Resources provide read-only access to data sources, allowing the AI model to retrieve context without executing complex logic.
-
-- **Control**: Resources are **application-controlled**, meaning the Host application typically decides when to access them.
-- **Nature**: They are designed for data retrieval with minimal computation, similar to GET endpoints in REST APIs.
-- **Safety**: Since they are read-only, they typically present lower security risks than Tools.
-- **Use Cases**: Accessing file contents, retrieving database records, reading configuration information.
-
-**Example**: A resource that provides access to file contents:
-
-<hfoptions id="resource-example">
-<hfoption id="python">
-
-```python
-def read_file(file_path: str) -> str:
-    """Read the contents of a file at the specified path."""
-    with open(file_path, 'r') as f:
-        return f.read()
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-```javascript
-function readFile(filePath) {
-    // Using fs.readFile to read file contents
-    const fs = require('fs');
-    return new Promise((resolve, reject) => {
-        fs.readFile(filePath, 'utf8', (err, data) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            resolve(data);
-        });
-    });
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Prompts
-
-Prompts are predefined templates or workflows that guide the interaction between the user, the AI model, and the Server's capabilities.
-
-- **Control**: Prompts are **user-controlled**, often presented as options in the Host application's UI.
-- **Purpose**: They structure interactions for optimal use of available Tools and Resources.
-- **Selection**: Users typically select a prompt before the AI model begins processing, setting context for the interaction.
-- **Use Cases**: Common workflows, specialized task templates, guided interactions.
-
-**Example**: A prompt template for generating a code review:
-
-<hfoptions id="prompt-example">
-<hfoption id="python">
-
-```python
-def code_review(code: str, language: str) -> list:
-    """Generate a code review for the provided code snippet."""
-    return [
-        {
-            "role": "system",
-            "content": f"You are a code reviewer examining {language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement."
-        },
-        {
-            "role": "user",
-            "content": f"Please review this {language} code:\n\n```{language}\n{code}\n```"
-        }
-    ]
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-```javascript
-function codeReview(code, language) {
-    return [
-        {
-            role: 'system',
-            content: `You are a code reviewer examining ${language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement.`
-        },
-        {
-            role: 'user',
-            content: `Please review this ${language} code:\n\n\`\`\`${language}\n${code}\n\`\`\``
-        }
-    ];
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Sampling
-
-Sampling allows Servers to request the Client (specifically, the Host application) to perform LLM interactions.
-
-- **Control**: Sampling is **server-initiated** but requires Client/Host facilitation.
-- **Purpose**: It enables server-driven agentic behaviors and potentially recursive or multi-step interactions.
-- **Safety**: Like Tools, sampling operations typically require user approval.
-- **Use Cases**: Complex multi-step tasks, autonomous agent workflows, interactive processes.
-
-**Example**: A Server might request the Client to analyze data it has processed:
-
-<hfoptions id="sampling-example">
-<hfoption id="python">
-
-```python
-def request_sampling(messages, system_prompt=None, include_context="none"):
-    """Request LLM sampling from the client."""
-    # In a real implementation, this would send a request to the client
-    return {
-        "role": "assistant",
-        "content": "Analysis of the provided data..."
-    }
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-```javascript
-function requestSampling(messages, systemPrompt = null, includeContext = 'none') {
-    // In a real implementation, this would send a request to the client
-    return {
-        role: 'assistant',
-        content: 'Analysis of the provided data...'
-    };
-}
-
-function handleSamplingRequest(request) {
-    const { messages, systemPrompt, includeContext } = request;
-    // In a real implementation, this would process the request and return a response
-    return {
-        role: 'assistant',
-        content: 'Response to the sampling request...'
-    };
-}
-```
-
-</hfoption>
-</hfoptions>
-
-The sampling flow follows these steps:
-1. Server sends a `sampling/createMessage` request to the client
-2. Client reviews the request and can modify it
-3. Client samples from an LLM
-4. Client reviews the completion
-5. Client returns the result to the server
-
-<Tip>
-
-This human-in-the-loop design ensures users maintain control over what the LLM sees and generates. When implementing sampling, it's important to provide clear, well-structured prompts and include relevant context.
-
-</Tip>
-
-## How Capabilities Work Together
-
-Let's look at how these capabilities work together to enable complex interactions. In the table below, we've outlined the capabilities, who controls them, the direction of control, and some other details.
-
-| Capability | Controlled By | Direction | Side Effects | Approval Needed | Typical Use Cases |
-|------------|---------------|-----------|--------------|-----------------|-------------------|
-| Tools      | Model (LLM)   | Client → Server | Yes (potentially) | Yes | Actions, API calls, data manipulation |
-| Resources  | Application   | Client → Server | No (read-only) | Typically no | Data retrieval, context gathering |
-| Prompts    | User          | Server → Client | No | No (selected by user) | Guided workflows, specialized templates |
-| Sampling   | Server        | Server → Client → Server | Indirectly | Yes | Multi-step tasks, agentic behaviors |
-
-These capabilities are designed to work together in complementary ways:
-
-1. A user might select a **Prompt** to start a specialized workflow
-2. The Prompt might include context from **Resources**
-3. During processing, the AI model might call **Tools** to perform specific actions
-4. For complex operations, the Server might use **Sampling** to request additional LLM processing
-
-The distinction between these primitives provides a clear structure for MCP interactions, enabling AI models to access information, perform actions, and engage in complex workflows while maintaining appropriate control boundaries.
-
-## Discovery Process
-
-One of MCP's key features is dynamic capability discovery. When a Client connects to a Server, it can query the available Tools, Resources, and Prompts through specific list methods:
-
-- `tools/list`: Discover available Tools
-- `resources/list`: Discover available Resources
-- `prompts/list`: Discover available Prompts
-
-This dynamic discovery mechanism allows Clients to adapt to the specific capabilities each Server offers without requiring hardcoded knowledge of the Server's functionality.
-
-## Conclusion
-
-Understanding these core primitives is essential for working with MCP effectively. By providing distinct types of capabilities with clear control boundaries, MCP enables powerful interactions between AI models and external systems while maintaining appropriate safety and control mechanisms.
-
-In the next section, we'll explore how Gradio integrates with MCP to provide easy-to-use interfaces for these capabilities. 

units/en/unit1/certificate.mdx

@@ -1,19 +0,0 @@
-# Get your certificate!
-
-Well done! You've completed the first unit of the MCP course. Now it's time to take the exam to get your certificate.
-
-Below is a quiz to check your understanding of the unit. 
-
-<iframe
-	src="https://mcp-course-unit-1-quiz.hf.space"
-	frameborder="0"
-	width="850"
-	height="450"
-></iframe>
-
-<Tip>
-
-If you're struggling to use the quiz above, go to the space directly [on the Hugging Face Hub](https://huggingface.co/spaces/mcp-course/unit_1_quiz). If you find errors, you can report them in the space's [Community tab](https://huggingface.co/spaces/mcp-course/unit_1_quiz/discussions).
-
-</Tip>
-

units/en/unit1/communication-protocol.mdx

@@ -1,223 +0,0 @@
-# The Communication Protocol
-
-MCP defines a standardized communication protocol that enables Clients and Servers to exchange messages in a consistent, predictable way. This standardization is critical for interoperability across the community. In this section, we'll explore the protocol structure and transport mechanisms used in MCP.
-
-<Tip warning={true}>
-
-We're getting down to the nitty-gritty details of the MCP protocol. You won't need to know all of this to build with MCP, but it's good to know that it exists and how it works.
-
-</Tip>
-
-## JSON-RPC: The Foundation
-
-At its core, MCP uses **JSON-RPC 2.0** as the message format for all communication between Clients and Servers. JSON-RPC is a lightweight remote procedure call protocol encoded in JSON, which makes it:
-
-- Human-readable and easy to debug
-- Language-agnostic, supporting implementation in any programming environment
-- Well-established, with clear specifications and widespread adoption
-
-![message types](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/5.png)
-
-The protocol defines three types of messages:
-
-### 1. Requests
-
-Sent from Client to Server to initiate an operation. A Request message includes:
-- A unique identifier (`id`)
-- The method name to invoke (e.g., `tools/call`)
-- Parameters for the method (if any)
-
-Example Request:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "tools/call",
-  "params": {
-    "name": "weather",
-    "arguments": {
-      "location": "San Francisco"
-    }
-  }
-}
-```
-
-### 2. Responses
-
-Sent from Server to Client in reply to a Request. A Response message includes:
-- The same `id` as the corresponding Request
-- Either a `result` (for success) or an `error` (for failure)
-
-Example Success Response:
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "temperature": 62,
-    "conditions": "Partly cloudy"
-  }
-}
-```
-
-Example Error Response:
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "error": {
-    "code": -32602,
-    "message": "Invalid location parameter"
-  }
-}
-```
-
-### 3. Notifications
-
-One-way messages that don't require a response. Typically sent from Server to Client to provide updates or notifications about events.
-
-Example Notification:
-```json
-{
-  "jsonrpc": "2.0",
-  "method": "progress",
-  "params": {
-    "message": "Processing data...",
-    "percent": 50
-  }
-}
-```
-
-## Transport Mechanisms
-
-JSON-RPC defines the message format, but MCP also specifies how these messages are transported between Clients and Servers. Two primary transport mechanisms are supported:
-
-### stdio (Standard Input/Output)
-
-The stdio transport is used for local communication, where the Client and Server run on the same machine:
-
-The Host application launches the Server as a subprocess and communicates with it by writing to its standard input (stdin) and reading from its standard output (stdout).
-
-<Tip>
-
-**Use cases** for this transport are local tools like file system access or running local scripts.
-
-</Tip>
-
-The main **Advantages** of this transport are that it's simple, no network configuration required, and securely sandboxed by the operating system.
-
-### HTTP + SSE (Server-Sent Events) / Streamable HTTP
-
-The HTTP+SSE transport is used for remote communication, where the Client and Server might be on different machines:
-
-Communication happens over HTTP, with the Server using Server-Sent Events (SSE) to push updates to the Client over a persistent connection.
-
-<Tip>
-
-**Use cases** for this transport are connecting to remote APIs, cloud services, or shared resources.
-
-</Tip>
-
-The main **Advantages** of this transport are that it works across networks, enables integration with web services, and is compatible with serverless environments.
-
-Recent updates to the MCP standard have introduced or refined "Streamable HTTP," which offers more flexibility by allowing servers to dynamically upgrade to SSE for streaming when needed, while maintaining compatibility with serverless environments.
-
-## The Interaction Lifecycle
-
-In the previous section, we discussed the lifecycle of a single interaction between a Client (💻) and a Server (🌐). Let's now look at the lifecycle of a complete interaction between a Client and a Server in the context of the MCP protocol.
-
-The MCP protocol defines a structured interaction lifecycle between Clients and Servers:
-
-### Initialization
-
-The Client connects to the Server and they exchange protocol versions and capabilities, and the Server responds with its supported protocol version and capabilities.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>initialize</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>initialized</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-The Client confirms the initialization is complete via a notification message.
-
-### Discovery
-
-The Client requests information about available capabilities and the Server responds with a list of available tools.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>tools/list</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-This process could be repeated for each tool, resource, or prompt type.
-
-### Execution
-
-The Client invokes capabilities based on the Host's needs.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>tools/call</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>notification (optional progress)</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-### Termination
-
-The connection is gracefully closed when no longer needed and the Server acknowledges the shutdown request.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>shutdown</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>exit</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-The Client sends the final exit message to complete the termination.
-
-## Protocol Evolution
-
-The MCP protocol is designed to be extensible and adaptable. The initialization phase includes version negotiation, allowing for backward compatibility as the protocol evolves. Additionally, capability discovery enables Clients to adapt to the specific features each Server offers, enabling a mix of basic and advanced Servers in the same ecosystem.

units/en/unit1/gradio-mcp.mdx

@@ -1,154 +0,0 @@
-# Gradio MCP Integration
-
-We've now explored the core concepts of the MCP protocol and how to implement MCP Servers and Clients. In this section, we're going to make things slightly easier by using Gradio to create an MCP Server!
-
-<Tip>
-
-Gradio is a popular Python library for quickly creating customizable web interfaces for machine learning models. 
-
-</Tip>
-
-## Introduction to Gradio
-
-Gradio allows developers to create UIs for their models with just a few lines of Python code. It's particularly useful for:
-
-- Creating demos and prototypes
-- Sharing models with non-technical users
-- Testing and debugging model behavior
-
-With the addition of MCP support, Gradio now offers a straightforward way to expose AI model capabilities through the standardized MCP protocol.
-
-Combining Gradio with MCP allows you to create both human-friendly interfaces and AI-accessible tools with minimal code. But best of all, Gradio is already well-used by the AI community, so you can use it to share your MCP Servers with others.
-
-## Prerequisites
-
-To use Gradio with MCP support, you'll need to install Gradio with the MCP extra:
-
-```bash
-pip install "gradio[mcp]"
-```
-
-You'll also need an LLM application that supports tool calling using the MCP protocol, such as Cursor ( known as "MCP Hosts").
-
-## Creating an MCP Server with Gradio
-
-Let's walk through a basic example of creating an MCP Server using Gradio:
-
-```python
-import gradio as gr
-
-def letter_counter(word: str, letter: str) -> int:
-    """
-    Count the number of occurrences of a letter in a word or text.
-
-    Args:
-        word (str): The input text to search through
-        letter (str): The letter to search for
-
-    Returns:
-        int: The number of times the letter appears in the text
-    """
-    word = word.lower()
-    letter = letter.lower()
-    count = word.count(letter)
-    return count
-
-# Create a standard Gradio interface
-demo = gr.Interface(
-    fn=letter_counter,
-    inputs=["textbox", "textbox"],
-    outputs="number",
-    title="Letter Counter",
-    description="Enter text and a letter to count how many times the letter appears in the text."
-)
-
-# Launch both the Gradio web interface and the MCP server
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-With this setup, your letter counter function is now accessible through:
-
-1. A traditional Gradio web interface for direct human interaction
-2. An MCP Server that can be connected to compatible clients
-
-The MCP server will be accessible at:
-```
-http://your-server:port/gradio_api/mcp/sse
-```
-
-The application itself will still be accessible and it looks like this:
-
-![Gradio MCP Server](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/7.png)
-
-## How It Works Behind the Scenes
-
-When you set `mcp_server=True` in `launch()`, several things happen:
-
-1. Gradio functions are automatically converted to MCP Tools
-2. Input components map to tool argument schemas
-3. Output components determine the response format
-4. The Gradio server now also listens for MCP protocol messages
-5. JSON-RPC over HTTP+SSE is set up for client-server communication
-
-## Key Features of the Gradio <> MCP Integration
-
-1. **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 tools and schemas, visit `http://your-server:port/gradio_api/mcp/schema` or go to the "View API" link in the footer of your Gradio app, and then click on "MCP".
-
-2. **Environment Variable Support**: There are two ways to enable the MCP server functionality:
-- Using the `mcp_server` parameter in `launch()`:
-  ```python
-  demo.launch(mcp_server=True)
-  ```
-- Using environment variables:
-  ```bash
-  export GRADIO_MCP_SERVER=True
-  ```
-
-3. **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 that input images and files be passed as full URLs ("http://..." or "https://...") as MCP Clients do not always handle local files correctly.
-
-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
-
-## 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.
-
-2. **String Inputs**: When in doubt, accept input arguments as `str` and convert them to the desired type inside the function.
-
-3. **SSE Support**: Some MCP Hosts don't support SSE-based MCP Servers. In those cases, you can use `mcp-remote`:
-   ```json
-   {
-     "mcpServers": {
-       "gradio": {
-         "command": "npx",
-         "args": [
-           "mcp-remote",
-           "http://your-server:port/gradio_api/mcp/sse"
-         ]
-       }
-     }
-   }
-   ```
-
-4. **Restart**: If you encounter connection issues, try restarting both your MCP Client and MCP Server.
-
-## Share your MCP Server
-
-You can share your MCP Server by publishing your Gradio app to Hugging Face Spaces. The video below shows how to create a Hugging Face Space.
-
-<Youtube id="3bSVKNKb_PY" />
-
-Now, you can share your MCP Server with others by sharing your Hugging Face Space.
-
-## Conclusion
-
-Gradio's integration with MCP provides an accessible entry point to the MCP ecosystem. By leveraging Gradio's simplicity and adding MCP's standardization, developers can quickly create both human-friendly interfaces and AI-accessible tools with minimal code.
-
-As we progress through this course, we'll explore more sophisticated MCP implementations, but Gradio offers an excellent starting point for understanding and experimenting with the protocol.
-
-In the next unit, we'll dive deeper into building MCP applications, focusing on setting up development environments, exploring SDKs, and implementing more advanced MCP Servers and Clients. 

units/en/unit1/introduction.mdx

@@ -1,33 +0,0 @@
-# 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/key-concepts.mdx

@@ -1,92 +0,0 @@
-# Key Concepts and Terminology
-
-Before diving deeper into the Model Context Protocol, it's important to understand the key concepts and terminology that form the foundation of MCP. This section will introduce the fundamental ideas that underpin the protocol and provide a common vocabulary for discussing MCP implementations throughout the course.
-
-MCP is often described as the "USB-C for AI applications." Just as USB-C provides a standardized physical and logical interface for connecting various peripherals to computing devices, MCP offers a consistent protocol for linking AI models to external capabilities. This standardization benefits the entire ecosystem:
-
-- **users** enjoy simpler and more consistent experiences across AI applications
-- **AI application developers** gain easy integration with a growing ecosystem of tools and data sources
-- **tool and data providers** need only create a single implementation that works with multiple AI applications
-- the broader ecosystem benefits from increased interoperability, innovation, and reduced fragmentation
-
-## The Integration Problem
-
-The **M×N Integration Problem** refers to the challenge of connecting M different AI applications to N different external tools or data sources without a standardized approach. 
-
-### Without MCP (M×N Problem)
-
-Without a protocol like MCP, developers would need to create M×N custom integrations—one for each possible pairing of an AI application with an external capability. 
-
-![Without MCP](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/1.png)
-
-Each AI application would need to integrate with each tool/data source individually. This is a very complex and expensive process which introduces a lot of friction for developers, and high maintenance costs.
-
-Once we have multiple models and multiple tools, the number of integrations becomes too large to manage, each with its own unique interface.
-
-![Multiple Models and Tools](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/1a.png)
-
-### With MCP (M+N Solution)
-
-MCP transforms this into an M+N problem by providing a standard interface: each AI application implements the client side of MCP once, and each tool/data source implements the server side once. This dramatically reduces integration complexity and maintenance burden.
-
-![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.
-
-<Tip>
-
-MCP is a standard like HTTP or USB-C, and is a protocol for connecting AI applications to external tools and data sources. Therefore, using standard terminology is crucial to making the MCP work effectively. 
-
-When documenting our applications and communicating with the community, we should use the following terminology.
-
-</Tip>
-
-### Components
-
-Just like client server relationships in HTTP, MCP has a client and a server.
-
-![MCP Components](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/3.png)
-
-- **Host**: The user-facing AI application that end-users interact with directly. Examples include Anthropic's Claude Desktop, AI-enhanced IDEs like Cursor, inference libraries like Hugging Face Python SDK, or custom applications built in libraries like LangChain or smolagents. Hosts initiate connections to MCP Servers and orchestrate the overall flow between user requests, LLM processing, and external tools.
-
-- **Client**: A component within the host application that manages communication with a specific MCP Server. Each Client maintains a 1:1 connection with a single Server, handling the protocol-level details of MCP communication and acting as an intermediary between the Host's logic and the external Server.
-
-- **Server**: An external program or service that exposes capabilities (Tools, Resources, Prompts) via the MCP protocol.
-
-<Tip warning={true}>
-
-A lot of content uses 'Client' and 'Host' interchangeably. Technically speaking, the host is the user-facing application, and the client is the component within the host application that manages communication with a specific MCP Server.
-
-</Tip>
-
-### Capabilities
-
-Of course, your application's value is the sum of the capabilities it offers. So the capabilities are the most important part of your application. MCP's can connect with any software service, but there are some common capabilities that are used for many AI applications.
-
-| Capability | Description | Example |
-| ---------- | ----------- | ------- |
-| **Tools** | Executable functions that the AI model can invoke to perform actions or retrieve computed data. Typically relating to the use case of the application. | A tool for a weather application might be a function that returns the weather in a specific location. |
-| **Resources** | Read-only data sources that provide context without significant computation. | A researcher assistant might have a resource for scientific papers. |
-| **Prompts** | Pre-defined templates or workflows that guide interactions between users, AI models, and the available capabilities. | A summarization prompt. |
-| **Sampling** | Server-initiated requests for the Client/Host to perform LLM interactions, enabling recursive actions where the LLM can review generated content and make further decisions. | A writing application reviewing its own output and decides to refine it further. |
-
-In the following diagram, we can see the collective capabilities applied to a use case for a code agent.
-
-![collective diagram](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/8.png)
-
-This application might use their MCP entities in the following way:
-
-| Entity | Name | Description |
-| --- | --- | --- |
-| Tool | Code Interpreter | A tool that can execute code that the LLM writes. |
-| Resource | Documentation | A resource that contains the documentation of the application. |
-| Prompt | Code Style | A prompt that guides the LLM to generate code. |
-| Sampling | Code Review | A sampling that allows the LLM to review the code and make further decisions. |
-
-### Conclusion
-
-Understanding these key concepts and terminology provides the foundation for working with MCP effectively. In the following sections, we'll build on this foundation to explore the architectural components, communication protocol, and capabilities that make up the Model Context Protocol. 

units/en/unit1/mcp-clients.mdx

@@ -1,357 +0,0 @@
-# MCP Clients
-
-Now that we have a basic understanding of the Model Context Protocol, we can explore the essential role of MCP Clients in the Model Context Protocol ecosystem.
-
- In this part of Unit 1, we'll explore the essential role of MCP Clients in the Model Context Protocol ecosystem.
-
-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
-* See practical examples of MCP Client usage
-
-<Tip>
-
-In this page we're going to show examples of how to set up MCP Clients in a few different ways using the JSON notation. For now, we will use *examples* like `path/to/server.py` to represent the path to the MCP Server. In the next unit, we'll implement this with real MCP Servers.  
-
-For now, focus on understanding the MCP Client notation. We'll implement the MCP Servers in the next unit.
-
-</Tip>
-
-## Understanding MCP Clients
-
-MCP Clients are crucial components that act as the bridge between AI applications (Hosts) and external capabilities provided by MCP Servers. Think of the Host as your main application (like an AI assistant or IDE) and the Client as a specialized module within that Host responsible for handling MCP communications.
-
-## User Interface Client
-
-Let's start by exploring the user interface clients that are available for the MCP.
-
-### Chat Interface Clients
-
-Anthropic's Claude Desktop stands as one of the most prominent MCP Clients, providing integration with various MCP Servers.
-
-### 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.
-
-Continue.dev is another example of an interactive development client that supports MCP and connects to an MCP server from VS Code.
-
-## Configuring MCP Clients
-
-Now that we've covered the core of the MCP protocol, let's look at how to configure your MCP servers and clients.
-
-Effective deployment of MCP servers and clients requires proper configuration. 
-
-<Tip>
-
-The MCP specification is still evolving, so the configuration methods are subject to evolution. We'll focus on the current best practices for configuration.
-
-</Tip>
-
-### MCP Configuration Files
-
-MCP hosts use configuration files to manage server connections. These files define which servers are available and how to connect to them.
-
-Fortunately, the configuration files are very simple, easy to understand, and consistent across major MCP hosts.
-
-#### `mcp.json` Structure
-
-The standard configuration file for MCP is named `mcp.json`. Here's the basic structure:
-
-This is the basic structure of the `mcp.json` can be passed to applications like Claude Desktop, Cursor, or VS Code.
-
-```json
-{
-  "servers": [
-    {
-      "name": "Server Name",
-      "transport": {
-        "type": "stdio|sse",
-        // Transport-specific configuration
-      }
-    }
-  ]
-}
-```
-
-In this example, we have a single server with a name and a transport type. The transport type is either `stdio` or `sse`.
-
-#### Configuration for stdio Transport
-
-For local servers using stdio transport, the configuration includes the command and arguments to launch the server process:
-
-```json
-{
-  "servers": [
-    {
-      "name": "File Explorer",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/file_explorer_server.py"] // This is an example, we'll use a real server in the next unit
-      }
-    }
-  ]
-}
-```
-
-Here, we have a server called "File Explorer" that is a local script.
-
-#### Configuration for HTTP+SSE Transport
-
-For remote servers using HTTP+SSE transport, the configuration includes the server URL:
-
-```json
-{
-  "servers": [
-    {
-      "name": "Remote API Server",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/mcp-server"
-      }
-    }
-  ]
-}
-```
-
-#### Environment Variables in Configuration
-
-Environment variables can be passed to server processes using the `env` field. Here's how to access them in your server code:
-
-<hfoptions id="env-variables">
-<hfoption id="python">
-
-In Python, we use the `os` module to access environment variables:
-
-```python
-import os
-
-# Access environment variables
-github_token = os.environ.get("GITHUB_TOKEN")
-if not github_token:
-    raise ValueError("GITHUB_TOKEN environment variable is required")
-
-# Use the token in your server code
-def make_github_request():
-    headers = {"Authorization": f"Bearer {github_token}"}
-    # ... rest of your code
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-In JavaScript, we use the `process.env` object to access environment variables:
-
-```javascript
-// Access environment variables
-const githubToken = process.env.GITHUB_TOKEN;
-if (!githubToken) {
-    throw new Error("GITHUB_TOKEN environment variable is required");
-}
-
-// Use the token in your server code
-function makeGithubRequest() {
-    const headers = { "Authorization": `Bearer ${githubToken}` };
-    // ... rest of your code
-}
-```
-
-</hfoption>
-</hfoptions>
-
-The corresponding configuration in `mcp.json` would look like this:
-
-```json
-{
-  "servers": [
-    {
-      "name": "GitHub API",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/github_server.py"], // This is an example, we'll use a real server in the next unit
-        "env": {
-          "GITHUB_TOKEN": "your_github_token"
-        }
-      }
-    }
-  ]
-}
-```
-
-### Configuration Examples
-
-Let's look at some real-world configuration scenarios:
-
-#### Scenario 1: Local Server Configuration
-
-In this scenario, we have a local server that is a Python script which could be a file explorer or a code editor.
-
-```json
-{
-  "servers": [
-    {
-      "name": "File Explorer",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/file_explorer_server.py"] // This is an example, we'll use a real server in the next unit
-      }
-    }
-  ]
-}
-```
-
-#### Scenario 2: Remote Server Configuration
-
-In this scenario, we have a remote server that is a weather API.
-
-```json
-{
-  "servers": [
-    {
-      "name": "Weather API",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/mcp-server" // This is an example, we'll use a real server in the next unit
-      }
-    }
-  ]
-}
-```
-
-Proper configuration is essential for successfully deploying MCP integrations. By understanding these aspects, you can create robust and reliable connections between AI applications and external capabilities.
-
-In the next section, we'll explore the ecosystem of MCP servers available on Hugging Face Hub and how to publish your own servers there. 
-
-## Tiny Agents Clients
-
-Now, let's explore how to use MCP Clients within code.
-
-You can also use tiny agents as MCP Clients to connect directly to MCP servers from your code. Tiny agents provide a simple way to create AI agents that can use tools from MCP servers.
-
-Tiny Agent can run MCP servers with a command line environment. To do this, we will need to install `npm` and run the server with `npx`. **We'll need these for both Python and JavaScript.**
-
-Let's install `npx` with `npm`. If you don't have `npm` installed, check out the [npm documentation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
-
-### Setup
-
-First, we will need to install `npx` if you don't have it installed. You can do this with the following command:
-
-```bash
-# install npx
-npm install -g npx
-```
-
-Then, we will need to install the huggingface_hub package with the MCP support. This will allow us to run MCP servers and clients.
-
-```bash
-pip install "huggingface_hub[mcp]>=0.32.0"
-```
-
-Then, we will need to log in to the Hugging Face Hub to access the MCP servers. You can do this with the `huggingface-cli` command line tool. You will need a [login token](https://huggingface.co/docs/huggingface_hub/v0.32.3/en/quick-start#authentication) to do this.
-
-```bash
-huggingface-cli login
-```
-
-<hfoptions id="language">
-<hfoption id="python">
-
-### Connecting to MCP Servers
-
-Now, let's create an agent configuration file `agent.json`.
-
-```json
-{
-    "model": "Qwen/Qwen2.5-72B-Instruct",
-    "provider": "nebius",
-    "servers": [
-        {
-            "type": "stdio",
-            "config": {
-                "command": "npx",
-                "args": ["@playwright/mcp@latest"]
-            }
-        }
-    ]
-}
-```
-
-In this configuration, we are using the `@playwright/mcp` MCP server. This is a MCP server that can control a browser with Playwright.
-
-Now you can run the agent:
-
-```bash
-tiny-agents run agent.json
-```
-</hfoption>
-<hfoption id="javascript">
-
-First, install the tiny agents package with [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
-
-```bash
-npm install @huggingface/tiny-agents
-```
-
-### Connecting to MCP Servers
-
-Make an agent project directory and create an `agent.json` file.
-
-```bash
-mkdir my-agent
-touch my-agent/agent.json
-```
-
-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"]
-			}
-		}
-	]
-}
-```
-
-Now you can run the agent:
-
-```bash
-npx @huggingface/tiny-agents run ./my-agent
-```
-
-</hfoption>
-</hfoptions>
-
-In the video below, we run the agent and ask it to open a new tab in the browser.
-
-The following example shows a web-browsing agent configured to use the [Qwen/Qwen2.5-72B-Instruct](https://huggingface.co/Qwen/Qwen2.5-72B-Instruct) model via Nebius inference provider, and it comes equipped with a playwright MCP server, which lets it use a web browser! The agent config is loaded specifying [its path in the `tiny-agents/tiny-agents`](https://huggingface.co/datasets/tiny-agents/tiny-agents/tree/main/celinah/web-browser) Hugging Face dataset.
-
-<video controls autoplay loop>
-  <source src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/python-tiny-agents/web_browser_agent.mp4" type="video/mp4">
-</video>
-
-When you run the agent, you'll see it load, listing the tools it has discovered from its connected MCP servers. Then, it's ready for your prompts!
-
-Prompt used in this demo:
-
-> do a Web Search for HF inference providers on Brave Search and open the first result and then give me the list of the inference providers supported on Hugging Face 
-
-## Next Steps
-
-Now that you understand MCP Clients, you're ready to:
-* Explore specific MCP Server implementations
-* Learn about creating custom MCP Clients
-* Dive into advanced MCP integration patterns
-
-Let's continue our journey into the world of Model Context Protocol!

units/en/unit1/quiz1.mdx

@@ -1,125 +0,0 @@
-# Quiz 1: MCP Fundamentals
-
-Test your knowledge of the core concepts of Model Context Protocol.
-
-### Q1: What is the primary purpose of Model Context Protocol (MCP)?
-
-<Question
-  choices={[
-    {
-      text: "To limit the training data of AI models",
-      explain: "MCP aims to expand, not limit, the contexts AI models can access."
-    },
-    {
-      text: "To enable AI models to connect with external data sources, tools, and environments",
-      explain: "Correct! MCP's main goal is to facilitate interoperability.",
-      correct: true
-    },
-    {
-      text: "To replace prompting when using Large Language Models",
-      explain: "MCP is a protocol that enhances prompting, not a replacement for it."
-    },
-    {
-      text: "To create a new programming language for AI",
-      explain: "MCP is a protocol, not a programming language."
-    }
-  ]}
-/>
-
-### Q2: What problem does MCP primarily aim to solve?
-
-<Question
-  choices={[
-    {
-      text: "The lack of AI models",
-      explain: "MCP addresses integration challenges, not the availability of AI models themselves."
-    },
-    {
-      text: "The high cost of training LLMs",
-      explain: "While MCP can improve efficiency, its primary focus is not on reducing training costs directly."
-    },
-    {
-      text: "The M×N Integration Problem",
-      explain: "Correct! MCP standardizes connections to avoid M×N custom integrations.",
-      correct: true
-    },
-    {
-      text: "The difficulty in creating new AI algorithms",
-      explain: "MCP facilitates using existing algorithms and tools, not creating new ones from scratch."
-    }
-  ]}
-/>
-
-### Q3: Which of the following is a key benefit of MCP?
-
-<Question
-  choices={[
-    {
-      text: "Reduced AI model accuracy",
-      explain: "MCP aims to enhance AI capabilities, which should ideally lead to improved or maintained accuracy, not reduced."
-    },
-    {
-      text: "Increased complexity in AI development",
-      explain: "MCP aims to simplify integration, thereby reducing complexity."
-    },
-    {
-      text: "Standardization and interoperability in the AI ecosystem",
-      explain: "Correct! This is a primary goal and benefit of MCP.",
-      correct: true
-    },
-    {
-      text: "Isolation of AI models from external systems",
-      explain: "MCP promotes connection and interaction, not isolation."
-    }
-  ]}
-/>
-
-### Q4: In MCP terminology, what is a "Host"?
-
-<Question
-  choices={[
-    {
-      text: "The external program exposing capabilities",
-      explain: "This describes an MCP Server."
-    },
-    {
-      text: "The user-facing AI application",
-      explain: "Correct! The Host is the application users interact with.",
-      correct: true
-    },
-    {
-      text: "A read-only data source",
-      explain: "This describes a type of MCP Capability (Resource)."
-    },
-    {
-      text: "A pre-defined template for interactions",
-      explain: "This describes a type of MCP Capability (Prompt)."
-    }
-  ]}
-/>
-
-### Q5: What does "M×N Integration Problem" refer to in the context of AI applications?
-
-<Question
-  choices={[
-    {
-      text: "The difficulty of training M models with N datasets",
-      explain: "This relates to model training, not the integration problem MCP addresses."
-    },
-    {
-      text: "The challenge of connecting M AI applications to N external tools without a standard",
-      explain: "Correct! MCP provides the standard to solve this M*N complexity.",
-      correct: true
-    },
-    {
-      text: "The problem of managing M users across N applications",
-      explain: "This is a user management or identity problem, not the focus of MCP."
-    },
-    {
-      text: "The complexity of developing M features for N different user segments",
-      explain: "This relates to product development strategy, not system integration in the way MCP defines."
-    }
-  ]}
-/>
-
-Congrats on finishing this Quiz 🥳! If you need to review any elements, take the time to revisit the chapter to reinforce your knowledge. 

units/en/unit1/quiz2.mdx

@@ -1,125 +0,0 @@
-# Quiz 2: MCP SDK
-
-Test your knowledge of the MCP SDKs and their functionalities.
-
-### Q1: What is the main purpose of the MCP SDKs?
-
-<Question
-  choices={[
-    {
-      text: "To define the MCP protocol specification",
-      explain: "The SDKs implement the protocol, they don't define it. The specification is separate."
-    },
-    {
-      text: "To make it easier to implement MCP clients and servers",
-      explain: "Correct! SDKs abstract away low-level protocol details.",
-      correct: true
-    },
-    {
-      text: "To provide a visual interface for MCP interactions",
-      explain: "While some tools might offer this (like MCP Inspector), it's not the primary purpose of the SDKs themselves."
-    },
-    {
-      text: "To replace the need for programming languages",
-      explain: "SDKs are libraries used within programming languages."
-    }
-  ]}
-/>
-
-### Q2: Which of the following functionalities do the MCP SDKs typically handle?
-
-<Question
-  choices={[
-    {
-      text: "Optimizing MCP Servers",
-      explain: "This is outside the scope of MCP SDKs, which focus on protocol implementation."
-    },
-    {
-      text: "Defining new AI algorithms",
-      explain: "This is outside the scope of MCP SDKs, which focus on protocol implementation."
-    },
-    {
-      text: "Message serialization/deserialization",
-      explain: "Correct! This is a core function for handling JSON-RPC messages.",
-      correct: true
-    },
-    {
-      text: "Hosting Large Language Models",
-      explain: "MCP enables connection to LLMs, but the SDKs themselves don't host them."
-    }
-  ]}
-/>
-
-### Q3: According to the provided text, which company maintains the official Python SDK for MCP?
-
-<Question
-  choices={[
-    {
-      text: "Google",
-      explain: "The text lists Anthropic as the maintainer."
-    },
-    {
-      text: "Anthropic",
-      explain: "Correct! The course material indicates Anthropic maintains the Python SDK.",
-      correct: true
-    },
-    {
-      text: "Microsoft",
-      explain: "Microsoft maintains the C# SDK according to the text."
-    },
-    {
-      text: "JetBrains",
-      explain: "JetBrains maintains the Kotlin SDK according to the text."
-    }
-  ]}
-/>
-
-### Q4: What command is used to start a development MCP server using a Python file named `server.py`?
-
-<Question
-  choices={[
-    {
-      text: "python server.py run",
-      explain: "While you run Python scripts with `python`, MCP has a specific CLI command."
-    },
-    {
-      text: "mcp start server.py",
-      explain: "The command is `mcp dev`, not `mcp start`."
-    },
-    {
-      text: "mcp dev server.py",
-      explain: "Correct! This command initializes the development server.",
-      correct: true
-    },
-    {
-      text: "serve mcp server.py",
-      explain: "This is not the standard MCP CLI command shown in the course material."
-    }
-  ]}
-/>
-
-### Q5: What is the role of JSON-RPC 2.0 in MCP?
-
-<Question
-  choices={[
-    {
-      text: "As a primary transport mechanism for remote communication",
-      explain: "HTTP+SSE or Streamable HTTP are transport mechanisms; JSON-RPC is the message format."
-    },
-    {
-      text: "As the message format for all communication between Clients and Servers",
-      explain: "Correct! MCP uses JSON-RPC 2.0 for structuring messages.",
-      correct: true
-    },
-    {
-      text: "As a tool for debugging AI models",
-      explain: "While its human-readable nature helps in debugging communications, it's not a debugging tool for AI models themselves."
-    },
-    {
-      text: "As a method for defining AI capabilities like Tools and Resources",
-      explain: "Capabilities are defined by their own schemas; JSON-RPC is used to invoke them and exchange data."
-    }
-  ]}
-/>
-
-Congrats on finishing this Quiz 🥳! If you need to review any elements, take the time to revisit the chapter to reinforce your knowledge. 

units/en/unit1/sdk.mdx

@@ -1,169 +0,0 @@
-# MCP SDK
-
-The Model Context Protocol provides official SDKs for both JavaScript, Python and other languages. This makes it easy to implement MCP clients and servers in your applications. These SDKs handle the low-level protocol details, allowing you to focus on building your application's capabilities.
-
-## SDK Overview
-
-Both SDKs provide similar core functionality, following the MCP protocol specification we discussed earlier. They handle:
-
-- Protocol-level communication
-- Capability registration and discovery
-- Message serialization/deserialization
-- Connection management
-- Error handling
-
-## Core Primitives Implementation
-
-Let's explore how to implement each of the core primitives (Tools, Resources, and Prompts) using both SDKs.
-
-<hfoptions id="server-implementation">
-<hfoption id="python">
-
-<Youtube id="exzrb5QNUis" />
-
-```python
-from mcp.server.fastmcp import FastMCP
-
-# Create an MCP server
-mcp = FastMCP("Weather Service")
-
-# Tool implementation
-@mcp.tool()
-def get_weather(location: str) -> str:
-    """Get the current weather for a specified location."""
-    return f"Weather in {location}: Sunny, 72°F"
-
-# Resource implementation
-@mcp.resource("weather://{location}")
-def weather_resource(location: str) -> str:
-    """Provide weather data as a resource."""
-    return f"Weather data for {location}: Sunny, 72°F"
-
-# Prompt implementation
-@mcp.prompt()
-def weather_report(location: str) -> str:
-    """Create a weather report prompt."""
-    return f"""You are a weather reporter. Weather report for {location}?"""
-
-
-# Run the server
-if __name__ == "__main__":
-    mcp.run()
-
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-```javascript
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// Create an MCP server
-const server = new McpServer({
-    name: "Weather Service",
-    version: "1.0.0"
-});
-
-// Tool implementation
-server.tool("get_weather",
-    { location: z.string() },
-    async ({ location }) => ({
-        content: [{
-            type: "text",
-            text: `Weather in ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Resource implementation
-server.resource(
-    "weather",
-    new ResourceTemplate("weather://{location}", { list: undefined }),
-    async (uri, { location }) => ({
-        contents: [{
-            uri: uri.href,
-            text: `Weather data for ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Prompt implementation
-server.prompt(
-    "weather_report",
-    { location: z.string() },
-    async ({ location }) => ({
-        messages: [
-            {
-                role: "assistant",
-                content: {
-                    type: "text",
-                    text: "You are a weather reporter."
-                }
-            },
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Weather report for ${location}?`
-                }
-            }
-        ]
-    })
-);
-
-// Run the server
-const transport = new StdioServerTransport();
-await server.connect(transport);
-```
-
-</hfoption>
-</hfoptions>
-
-Once you have your server implemented, you can start it by running the server script.
-
-```bash
-mcp dev server.py
-```
-
-This will initialize a development server running the file `server.py`. And log the following output:
-
-```bash
-Starting MCP inspector...
-⚙️ Proxy server listening on port 6277
-Spawned stdio transport
-Connected MCP client to backing server transport
-Created web app transport
-Set up MCP proxy
-🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀
-```
-
-You can then open the MCP Inspector at [http://127.0.0.1:6274](http://127.0.0.1:6274) to see the server's capabilities and interact with them.
-
-You'll see the server's capabilities and the ability to call them via the UI.
-
-![MCP Inspector](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/6.png)
-
-## MCP SDKs
-
-MCP is designed to be language-agnostic, and there are official SDKs available for several popular programming languages:
-
-| Language | Repository | Maintainer(s) | Status |
-|----------|------------|---------------|--------|
-| TypeScript | [github.com/modelcontextprotocol/typescript-sdk](https://github.com/modelcontextprotocol/typescript-sdk) | Anthropic | Active |
-| Python | [github.com/modelcontextprotocol/python-sdk](https://github.com/modelcontextprotocol/python-sdk) | Anthropic | Active |
-| Java | [github.com/modelcontextprotocol/java-sdk](https://github.com/modelcontextprotocol/java-sdk) | Spring AI (VMware) | Active |
-| Kotlin | [github.com/modelcontextprotocol/kotlin-sdk](https://github.com/modelcontextprotocol/kotlin-sdk) | JetBrains | Active |
-| C# | [github.com/modelcontextprotocol/csharp-sdk](https://github.com/modelcontextprotocol/csharp-sdk) | Microsoft | Active (Preview) |
-| Swift | [github.com/modelcontextprotocol/swift-sdk](https://github.com/modelcontextprotocol/swift-sdk) | loopwork-ai | Active |
-| Rust | [github.com/modelcontextprotocol/rust-sdk](https://github.com/modelcontextprotocol/rust-sdk) | Anthropic/Community | Active |
-| Dart | [https://github.com/leehack/mcp_dart](https://github.com/leehack/mcp_dart) | Flutter Community | Active |
-
-These SDKs provide language-specific abstractions that simplify working with the MCP protocol, allowing you to focus on implementing the core logic of your servers or clients rather than dealing with low-level protocol details.
-
-## Next Steps
-
-We've only scratched the surface of what you can do with the MCP but you've already got a basic server running. In fact, you've also connected to it using the MCP Client in the browser.
-
-In the next section, we'll look at how to connect to your server from an LLM.

units/en/unit1/unit1-recap.mdx

@@ -1,45 +0,0 @@
-# Unit1 recap
-
-## Model Context Protocol (MCP)
-
-The MCP is a standardized protocol designed to connect AI models with external tools, data sources, and environments. It addresses the limitations of existing AI systems by enabling interoperability and access to real-time information.
-
-## Key Concepts
-
-### Client-Server Architecture
-MCP follows a client-server model where clients manage communication between users and servers. This architecture promotes modularity, allowing for easy addition of new servers without requiring changes to existing hosts.
-
-### Components
-#### Host
-The user-facing AI application that serves as the interface for end-users.
-
-##### Client
-A component within the host application responsible for managing communication with a specific MCP server. Clients maintain 1:1 connections with servers and handle protocol-level details.
-
-#### Server
-An external program or service that provides access to tools, data sources, or services via the MCP protocol. Servers act as lightweight wrappers around existing functionalities.
-
-### Capabilities
-#### Tools
-Executable functions that can perform actions (e.g., sending messages, querying APIs). Tools are typically model-controlled and require user approval due to their ability to perform actions with side effects.
-
-#### Resources
-Read-only data sources for context retrieval without significant computation. Resources are application-controlled and designed for data retrieval similar to GET endpoints in REST APIs.
-
-#### Prompts
-Pre-defined templates or workflows that guide interactions between users, AI models, and available capabilities. Prompts are user-controlled and set the context for interactions.
-
-#### Sampling
-Server-initiated requests for LLM processing, enabling server-driven agentic behaviors and potentially recursive or multi-step interactions. Sampling operations typically require user approval.
-
-### Communication Protocol
-The MCP protocol uses JSON-RPC 2.0 as the message format for communication between clients and servers. Two primary transport mechanisms are supported: stdio (for local communication) and HTTP+SSE (for remote communication). Messages include requests, responses, and notifications.
-
-### Discovery Process
-MCP allows clients to dynamically discover available tools, resources, and prompts through list methods (e.g., `tools/list`). This dynamic discovery mechanism enables clients to adapt to the specific capabilities each server offers without requiring hardcoded knowledge of server functionality.
-
-### MCP SDKs
-Official SDKs are available in various programming languages for implementing MCP clients and servers. These SDKs handle protocol-level communication, capability registration, and error handling, simplifying the development process.
-
-### 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.

units/en/unit2/clients.mdx

@@ -1,136 +0,0 @@
-# Building MCP Clients
-
-In this section, we'll create clients that can interact with our MCP server using different programming languages. We'll implement both a JavaScript client using HuggingFace.js and a Python client using smolagents.
-
-## Configuring MCP Clients
-
-Effective deployment of MCP servers and clients requires proper configuration. The MCP specification is still evolving, so the configuration methods are subject to evolution. We'll focus on the current best practices for configuration.
-
-### MCP Configuration Files
-
-MCP hosts use configuration files to manage server connections. These files define which servers are available and how to connect to them.
-
-The configuration files are very simple, easy to understand, and consistent across major MCP hosts.
-
-#### `mcp.json` Structure
-
-The standard configuration file for MCP is named `mcp.json`. Here's the basic structure:
-
-```json
-{
-  "servers": [
-    {
-      "name": "MCP Server",
-      "transport": {
-        "type": "sse",
-        "url": "http://localhost:7860/gradio_api/mcp/sse"
-      }
-    }
-  ]
-}
-```
-
-In this example, we have a single server configured to use SSE transport, connecting to a local Gradio server running on port 7860.
-
-<Tip>
-
-We've connected to the Gradio app via SSE transport because we assume that the gradio app is running on a remote server. However, if you want to connect to a local script, `stdio` transport instead of `sse` transport is a better option.
-
-</Tip>
-
-#### Configuration for HTTP+SSE Transport
-
-For remote servers using HTTP+SSE transport, the configuration includes the server URL:
-
-```json
-{
-  "servers": [
-    {
-      "name": "Remote MCP Server",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/gradio_api/mcp/sse"
-      }
-    }
-  ]
-}
-```
-
-This configuration allows your UI client to communicate with the Gradio MCP server using the MCP protocol, enabling seamless integration between your frontend and the MCP service.
-
-## Configuring a UI MCP Client
-
-When working with Gradio MCP servers, you can configure your UI client to connect to the server using the MCP protocol. Here's how to set it up:
-
-### Basic Configuration
-
-Create a new file called `config.json` with the following configuration:
-
-```json
-{
-  "mcpServers": {
-    "mcp": {
-      "url": "http://localhost:7860/gradio_api/mcp/sse"
-    }
-  }
-}
-```
-
-This configuration allows your UI client to communicate with the Gradio MCP server using the MCP protocol, enabling seamless integration between your frontend and the MCP service.
-
-## Configuring a MCP Client within Cursor IDE
-
-Cursor provides built-in MCP support, allowing you to connect your deployed MCP servers directly to your development environment.
-
-### Configuration
-
-Open Cursor settings (`Ctrl + Shift + J` / `Cmd + Shift + J`) → **MCP** tab → **Add new global MCP server**:
-
-**macOS:**
-```json
-{
-  "mcpServers": {
-    "sentiment-analysis": {
-      "command": "npx",
-      "args": [
-        "-y", 
-        "mcp-remote", 
-        "https://YOURUSENAME-mcp-sentiment.hf.space/gradio_api/mcp/sse", 
-        "--transport", 
-        "sse-only"
-      ]
-    }
-  }
-}
-```
-
-**Windows:**
-```json
-{
-  "mcpServers": {
-    "sentiment-analysis": {
-      "command": "cmd",
-      "args": [
-        "/c", 
-        "npx", 
-        "-y", 
-        "mcp-remote", 
-        "https://YOURUSENAME-mcp-sentiment.hf.space/gradio_api/mcp/sse", 
-        "--transport", 
-        "sse-only"
-      ]
-    }
-  }
-}
-```
-
-### 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:
-
-- Runs locally on your machine
-- Forwards requests from Cursor to the remote MCP server
-- 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.
-

units/en/unit2/gradio-client.mdx

@@ -1,179 +0,0 @@
-# Gradio as an MCP Client
-
-In the previous section, we explored how to create an MCP Server using Gradio and connect to it using an MCP Client. In this section, we're going to explore how to use Gradio as an MCP Client to connect to an MCP Server.
-
-<Tip>
-
-Gradio is best suited to the creation of UI clients and MCP servers, but it is also possible to use it as an MCP Client and expose that as a UI.
-
-</Tip>
-
-We'll connect to the MCP server we created in the previous section and use it to answer questions.
-
-## MCP Client in Gradio
-
-### Connect to an example MCP Server
-
-Let's connect to an example MCP Server that is already running on Hugging Face. We'll use [this one](https://huggingface.co/spaces/abidlabs/mcp-tools2) for this example. It's a space that contains a collection of MCP tools.
-
-```python
-from smolagents.mcp_client import MCPClient
-
-with MCPClient(
-    {"url": "https://abidlabs-mcp-tools2.hf.space/gradio_api/mcp/sse"}
-) as tools:
-    # Tools from the remote server are available
-    print("\n".join(f"{t.name}: {t.description}" for t in tools))
-
-```
-
-<details>
-<summary>Output</summary>
-<pre>
-<code>
-prime_factors: Compute the prime factorization of a positive integer.
-generate_cheetah_image: Generate a cheetah image.
-image_orientation: Returns whether image is portrait or landscape.
-sepia: Apply a sepia filter to the input image.
-</code>
-</pre>
-</details>
-
-### Connect to your MCP Server from Gradio
-
-Great, now that you've connected to an example MCP Server, let's connect to your own MCP Server from Gradio.
-
-First, we need to install the `smolagents`, Gradio and mcp-client libraries, if we haven't already:
-
-```bash
-pip install "smolagents[mcp]" "gradio[mcp]" mcp fastmcp
-```
-
-Now, we can import the necessary libraries and create a simple Gradio interface that uses the MCP Client to connect to the MCP Server.
-
-
-```python
-import gradio as gr
-import os
-
-from mcp import StdioServerParameters
-from smolagents import InferenceClientModel, CodeAgent, ToolCollection, MCPClient
-```
-
-Next, we'll connect to the MCP Server and get the tools that we can use to answer questions.
-
-```python
-mcp_client = MCPClient(
-    {"url": "http://localhost:7860/gradio_api/mcp/sse"} # This is the MCP Server we created in the previous section
-)
-tools = mcp_client.get_tools()
-```
-
-Now that we have the tools, we can create a simple agent that uses them to answer questions. We'll just use a simple `InferenceClientModel` and the default model from `smolagents` for now.
-
-It is important to pass your api_key to the InferenceClientModel. You can access the token from your huggingface account. [check here.](https://huggingface.co/docs/hub/en/security-tokens), and set the access token with the environment variable  `HF_TOKEN`.
-
-```python
-model = InferenceClientModel(token=os.getenv("HF_TOKEN"))
-agent = CodeAgent(tools=[*tools], model=model)
-```
-
-Now, we can create a simple Gradio interface that uses the agent to answer questions.
-
-```python
-demo = gr.ChatInterface(
-    fn=lambda message, history: str(agent.run(message)),
-    type="messages",
-    examples=["Prime factorization of 68"],
-    title="Agent with MCP Tools",
-    description="This is a simple agent that uses MCP tools to answer questions."
-)
-
-demo.launch()
-```
-
-And that's it! We've created a simple Gradio interface that uses the MCP Client to connect to the MCP Server and answer questions.
-
-<iframe
-	src="https://mcp-course-unit2-gradio-client.hf.space"
-	frameborder="0"
-	width="850"
-	height="450"
-></iframe>
-
-
-## Complete Example
-
-Here's the complete example of the MCP Client in Gradio:
-
-```python
-import gradio as gr
-import os
-
-from mcp import StdioServerParameters
-from smolagents import InferenceClientModel, CodeAgent, ToolCollection, MCPClient
-
-
-try:
-    mcp_client = MCPClient(
-        {"url": "http://localhost:7860/gradio_api/mcp/sse"} # This is the MCP Server we created in the previous section
-    )
-    tools = mcp_client.get_tools()
-
-    model = InferenceClientModel(token=os.getenv("HUGGINGFACE_API_TOKEN"))
-    agent = CodeAgent(tools=[*tools], model=model)
-
-    demo = gr.ChatInterface(
-        fn=lambda message, history: str(agent.run(message)),
-        type="messages",
-        examples=["Prime factorization of 68"],
-        title="Agent with MCP Tools",
-        description="This is a simple agent that uses MCP tools to answer questions.",
-    )
-
-    demo.launch()
-finally:
-    mcp_client.disconnect()
-```
-
-You'll notice that we're closing the MCP Client in the `finally` block. This is important because the MCP Client is a long-lived object that needs to be closed when the program exits.
-
-## Deploying to Hugging Face Spaces
-
-To make your server available to others, you can deploy it to Hugging Face Spaces, just like we did in the previous section.
-To deploy your Gradio MCP client 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
-   - Name your space (e.g., "mcp-client")
-
-2. Update MCP Server URL in the code:
-
-```python
-mcp_client = MCPClient(
-    {"url": "http://localhost:7860/gradio_api/mcp/sse"} # This is the MCP Server we created in the previous section
-)
-```
-
-3. Create a `requirements.txt` file:
-```txt
-gradio[mcp]
-smolagents[mcp]
-```
-
-4. Push your code to the Space:
-```bash
-git init
-git add server.py requirements.txt
-git commit -m "Initial commit"
-git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/mcp-client
-git push -u origin main
-```
-
-## Conclusion
-
-In this section, we've explored how to use Gradio as an MCP Client to connect to an MCP Server. We've also seen how to deploy the MCP Client in Hugging Face Spaces.
-
-

units/en/unit2/gradio-server.mdx

@@ -1,190 +0,0 @@
-# Building the Gradio MCP Server
-
-In this section, we'll create our sentiment analysis MCP server using Gradio. This server will expose a sentiment analysis tool that can be used by both human users through a web interface and AI models through the MCP protocol.
-
-## Introduction to Gradio MCP Integration
-
-Gradio provides a straightforward way to create MCP servers by automatically converting your Python functions into MCP tools. When you set `mcp_server=True` in `launch()`, Gradio:
-
-1. Automatically converts your functions into MCP Tools
-2. Maps input components to tool argument schemas
-3. Determines response formats from output components
-4. Sets up JSON-RPC over HTTP+SSE for client-server communication
-5. Creates both a web interface and an MCP server endpoint
-
-## Setting Up the Project
-
-First, let's create a new directory for our project and set up the required dependencies:
-
-```bash
-mkdir mcp-sentiment
-cd mcp-sentiment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install "gradio[mcp]" textblob
-```
-
-## Creating the Server
-
-> Hugging face spaces needs an app.py file to build the space. So the name of the python file has to be app.py 
-
-Create a new file called `app.py` with the following code:
-
-```python
-import gradio as gr
-from textblob import TextBlob
-
-def sentiment_analysis(text: str) -> dict:
-    """
-    Analyze the sentiment of the given text.
-
-    Args:
-        text (str): The text to analyze
-
-    Returns:
-        dict: A dictionary containing polarity, subjectivity, and assessment
-    """
-    blob = TextBlob(text)
-    sentiment = blob.sentiment
-    
-    return {
-        "polarity": round(sentiment.polarity, 2),  # -1 (negative) to 1 (positive)
-        "subjectivity": round(sentiment.subjectivity, 2),  # 0 (objective) to 1 (subjective)
-        "assessment": "positive" if sentiment.polarity > 0 else "negative" if sentiment.polarity < 0 else "neutral"
-    }
-
-# Create the Gradio interface
-demo = gr.Interface(
-    fn=sentiment_analysis,
-    inputs=gr.Textbox(placeholder="Enter text to analyze..."),
-    outputs=gr.JSON(),
-    title="Text Sentiment Analysis",
-    description="Analyze the sentiment of text using TextBlob"
-)
-
-# Launch the interface and MCP server
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-## Understanding the Code
-
-Let's break down the key components:
-
-1. **Function Definition**:
-   - The `sentiment_analysis` function takes a text input and returns a 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
-
-2. **Gradio Interface**:
-   - `gr.Interface` creates both the web UI and MCP server
-   - The function is exposed as an MCP tool automatically
-   - Input and output components define the tool's schema
-   - The JSON output component ensures proper serialization
-
-3. **MCP Server**:
-   - Setting `mcp_server=True` enables the MCP server
-   - The server will be available at `http://localhost:7860/gradio_api/mcp/sse`
-   - You can also enable it using the environment variable:
-     ```bash
-     export GRADIO_MCP_SERVER=True
-     ```
-
-## Running the Server
-
-Start the server by running:
-
-```bash
-python app.py
-```
-
-You should see output indicating that both the web interface and MCP server are running. The web interface will be available at `http://localhost:7860`, and the MCP server at `http://localhost:7860/gradio_api/mcp/sse`.
-
-## Testing the Server
-
-You can test the server in two ways:
-
-1. **Web Interface**:
-   - Open `http://localhost:7860` in your browser
-   - Enter some text and click "Submit"
-   - You should see the sentiment analysis results
-
-2. **MCP Schema**:
-   - Visit `http://localhost:7860/gradio_api/mcp/schema`
-   - This shows the MCP tool schema that clients will use
-   - You can also find this in the "View API" link in the footer of your Gradio app
-
-## Troubleshooting Tips
-
-1. **Type Hints and Docstrings**:
-   - Always provide type hints for your function parameters and return values
-   - Include a docstring with an "Args:" block for each parameter
-   - This helps Gradio generate accurate MCP tool schemas
-
-2. **String Inputs**:
-   - When in doubt, accept input arguments as `str`
-   - Convert them to the desired type inside the function
-   - This provides better compatibility with MCP clients
-
-3. **SSE Support**:
-   - Some MCP clients don't support SSE-based MCP Servers
-   - In those cases, use `mcp-remote`:
-     ```json
-     {
-       "mcpServers": {
-         "gradio": {
-           "command": "npx",
-           "args": [
-             "mcp-remote",
-             "http://localhost:7860/gradio_api/mcp/sse"
-           ]
-         }
-       }
-     }
-     ```
-
-4. **Connection Issues**:
-   - If you encounter connection problems, try restarting both the client and server
-   - Check that the server is running and accessible
-   - Verify that the MCP schema is available at the expected URL
-
-## Deploying to Hugging Face Spaces
-
-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
-   - Name your space (e.g., "mcp-sentiment")
-
-2. Create a `requirements.txt` file:
-```txt
-gradio[mcp]
-textblob
-```
-
-3. Push your code to the Space:
-```bash
-git init
-git add app.py requirements.txt
-git commit -m "Initial commit"
-git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/mcp-sentiment
-git push -u origin main
-```
-
-Your MCP server will now be available at:
-```
-https://YOUR_USERNAME-mcp-sentiment.hf.space/gradio_api/mcp/sse
-```
-
-## Next Steps
-
-Now that we have our MCP server running, we'll create clients to interact with it. In the next sections, we'll:
-
-1. Create a HuggingFace.js-based client inspired by Tiny Agents
-2. Implement a SmolAgents-based Python client
-3. Test both clients with our deployed server
-
-Let's move on to building our first client! 

units/en/unit2/introduction.mdx

@@ -1,64 +0,0 @@
-# Building an End-to-End MCP Application
-
-Welcome to Unit 2 of the MCP Course! 
-
-In this unit, we'll build a complete MCP application from scratch, focusing on creating a server with Gradio and connecting it with multiple clients. This hands-on approach will give you practical experience with the entire MCP ecosystem.
-
-<Tip>
-
-In this unit, we're going to build a simple MCP server and client using Gradio and the HuggingFace hub. In the next unit, we'll build a more complex server that tackles a real-world use case.
-
-</Tip>
-
-## What You'll Learn
-
-In this unit, you will:
-
-- Create an MCP Server using Gradio's built-in MCP support
-- Build a sentiment analysis tool that can be used by AI models
-- Connect to the server using different client implementations:
-  - A HuggingFace.js-based client
-  - A SmolAgents-based client for Python
-- Deploy your MCP Server to Hugging Face Spaces
-- Test and debug the complete system
-
-By the end of this unit, you'll have a working MCP application that demonstrates the power and flexibility of the protocol.
-
-## Prerequisites
-
-Before proceeding with this unit, make sure you:
-
-- Have completed Unit 1 or have a basic understanding of MCP concepts
-- Are comfortable with both Python and JavaScript/TypeScript
-- Have a basic understanding of APIs and client-server architecture
-- Have a development environment with:
-  - Python 3.10+
-  - Node.js 18+
-  - A Hugging Face account (for deployment)
-
-## Our End-to-End Project
-
-We'll build a sentiment analysis application that consists of three main parts: the server, the client, and the deployment.
-
-![sentiment analysis application](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit2/1.png)
-
-### Server Side
-
-- Uses Gradio to create a web interface and MCP server via `gr.Interface`
-- Implements a sentiment analysis tool using TextBlob
-- Exposes the tool through both HTTP and MCP protocols
-
-### Client Side
-
-- Implements a HuggingFace.js client
-- Or, creates a smolagents Python client
-- Demonstrates how to use the same server with different client implementations
-
-### Deployment
-
-- Deploys the server to Hugging Face Spaces
-- Configures the clients to work with the deployed server
-
-## Let's Get Started!
-
-Are you ready to build your first end-to-end MCP application? Let's begin by setting up the development environment and creating our Gradio MCP server.

units/en/unit2/tiny-agents.mdx

@@ -1,274 +0,0 @@
-# Building Tiny Agents with MCP and the Hugging Face Hub
-
-Now that we've built MCP servers in Gradio and learned about creating MCP clients, let's complete our end-to-end application by building an agent that can seamlessly interact with our sentiment analysis tool. This section builds on the project [Tiny Agents](https://huggingface.co/blog/tiny-agents), which demonstrates a super simple way of deploying MCP clients that can connect to services like our Gradio sentiment analysis server.
-
-In this final exercise of Unit 2, we will walk you through how to implement both TypeScript (JS) and Python MCP clients that can communicate with any MCP server, including the Gradio-based sentiment analysis server we built in the previous sections. This completes our end-to-end MCP application flow: from building a Gradio MCP server exposing a sentiment analysis tool, to creating a flexible agent that can use this tool alongside other capabilities.
-
-![meme](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/tiny-agents/thumbnail.jpg)
-<figcaption>Image credit https://x.com/adamdotdev</figcaption>
-
-## Installation
-
-Let's install the necessary packages to build our Tiny Agents.
-
-<Tip>
-
-Some MCP Clients, notably Claude Desktop, do not yet support SSE-based MCP Servers. In those cases, you can use a tool such as [mcp-remote](https://github.com/geelen/mcp-remote). First install Node.js. Then, add the following to your own MCP Client config:
-
-</Tip>
-
-Tiny Agent can run MCP servers with a command line environment. To do this, we will need to install `npm` and run the server with `npx`. **We'll need these for both Python and JavaScript.**
-
-Let's install `npx` with `npm`. If you don't have `npm` installed, check out the [npm documentation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
-
-```bash
-# install npx
-npm install -g npx
-```
-
-Then, we need to install the `mcp-remote` package.
-
-```bash
-npm i mcp-remote
-```
-
-<hfoptions id="tiny-agents">
-<hfoption id="typescript">
-
-For JavaScript, we need to install the `tiny-agents` package.
-
-```bash
-npm install @huggingface/tiny-agents
-```
-
-</hfoption>
-<hfoption id="python">
-
-For Python, you need to install the latest version of `huggingface_hub` with the `mcp` extra to get all the necessary components.
-
-```bash
-pip install "huggingface_hub[mcp]>=0.32.0"
-```
-
-</hfoption>
-</hfoptions>
-
-## Tiny Agents MCP Client in the Command Line
-
-Let's repeat the example from [Unit 1](../unit1/mcp-clients.mdx) to create a basic Tiny Agent. Tiny Agents can create MCP clients from the command line based on JSON configuration files.
-
-<hfoptions id="tiny-agents">
-<hfoption id="typescript">
-
-Let's setup a project with a basic Tiny Agent.
-
-```bash
-mkdir my-agent
-touch my-agent/agent.json
-```
-
-The JSON file will look like this:
-
-```json
-{
-	"model": "Qwen/Qwen2.5-72B-Instruct",
-	"provider": "nebius",
-	"servers": [
-		{
-			"type": "stdio",
-			"config": {
-				"command": "npx",
-				"args": [
-					"mcp-remote",
-					"http://localhost:7860/gradio_api/mcp/sse" // This is the MCP Server we created in the previous section
-				]
-			}
-		}
-	]
-}
-```
-
-We can then run the agent with the following command:
-
-```bash
-npx @huggingface/tiny-agents run ./my-agent
-```
-
-</hfoption>
-<hfoption id="python">
-
-Let's setup a project with a basic Tiny Agent.
-
-```bash
-mkdir my-agent
-touch my-agent/agent.json
-cd my-agent
-```
-
-The JSON file will look like this:
-
-```json
-{
-	"model": "Qwen/Qwen2.5-72B-Instruct",
-	"provider": "nebius",
-	"servers": [
-		{
-			"type": "stdio",
-			"config": {
-				"command": "npx",
-				"args": [
-					"mcp-remote", 
-					"http://localhost:7860/gradio_api/mcp/sse"
-				]
-			}
-		}
-	]
-}
-```
-
-We can then run the agent with the following command:
-
-```bash
-tiny-agents run agent.json
-```
-
-</hfoption>
-</hfoptions>
-
-Here we have a basic Tiny Agent that can connect to our Gradio MCP server. It includes a model, provider, and a server configuration.
-
-| Field | Description |
-|-------|-------------|
-| `model` | The open source model to use for the agent |
-| `provider` | The inference provider to use for the agent |
-| `servers` | The servers to use for the agent. We'll use the `mcp-remote` server for our Gradio MCP server. |
-
-<Tip>
-
-We could also use an open source model running locally with Tiny Agents. If we start a local inference server with 
-
-```json
-{
-	"model": "Qwen/Qwen3-32B",
-	"endpointUrl": "http://localhost:1234/v1",
-	"servers": [
-		{
-			"type": "stdio",
-			"config": {
-				"command": "npx",
-				"args": [
-					"mcp-remote",
-					"http://localhost:1234/v1/mcp/sse"
-				]
-			}
-		}
-	]
-}
-```
-
-
-Here we have a Tiny Agent that can connect to a local model. It includes a model, endpoint URL (`http://localhost:1234/v1`), and a server configuration. The endpoint should be an OpenAI-compatible endpoint.
-
-</Tip>
-
-## Custom Tiny Agents MCP Client
-
-Now that we understand both Tiny Agents and Gradio MCP servers, let's see how they work together! The beauty of MCP is that it provides a standardized way for agents to interact with any MCP-compatible server, including our Gradio-based sentiment analysis server from earlier sections.
-
-### Using the Gradio Server with Tiny Agents
-
-To connect our Tiny Agent to the Gradio sentiment analysis server we built earlier in this unit, we just need to add it to our list of servers. Here's how we can modify our agent configuration:
-
-<hfoptions id="tiny-agents">
-<hfoption id="typescript">
-
-```ts
-const agent = new Agent({
-    provider: process.env.PROVIDER ?? "nebius",
-    model: process.env.MODEL_ID ?? "Qwen/Qwen2.5-72B-Instruct",
-    apiKey: process.env.HF_TOKEN,
-    servers: [
-        // ... existing servers ...
-        {
-            command: "npx",
-            args: [
-                "mcp-remote",
-                "http://localhost:7860/gradio_api/mcp/sse"  // Your Gradio MCP server
-            ]
-        }
-    ],
-});
-```
-
-</hfoption>
-<hfoption id="python">
-
-```python
-import os
-
-from huggingface_hub import Agent
-
-agent = Agent(
-    model="Qwen/Qwen2.5-72B-Instruct",
-    provider="nebius",
-    servers=[
-        {
-            "command": "npx",
-            "args": [
-                "mcp-remote",
-                "http://localhost:7860/gradio_api/mcp/sse"  # Your Gradio MCP server
-            ]
-        }
-    ],
-)
-```
-
-</hfoption>
-</hfoptions>
-
-Now our agent can use the sentiment analysis tool alongside other tools! For example, it could:
-1. Read text from a file using the filesystem server
-2. Analyze its sentiment using our Gradio server
-3. Write the results back to a file
-
-### Deployment Considerations
-
-When deploying your Gradio MCP server to Hugging Face Spaces, you'll need to update the server URL in your agent configuration to point to your deployed space:
-
-
-```json
-{
-    command: "npx",
-    args: [
-        "mcp-remote",
-        "https://YOUR_USERNAME-mcp-sentiment.hf.space/gradio_api/mcp/sse"
-    ]
-}
-```
-
-
-This allows your agent to use the sentiment analysis tool from anywhere, not just locally!
-
-## Conclusion: Our Complete End-to-End MCP Application
-
-In this unit, we've gone from understanding MCP basics to building a complete end-to-end application:
-
-1. We created a Gradio MCP server that exposes a sentiment analysis tool
-2. We learned how to connect to this server using MCP clients
-3. We built a tiny agent in TypeScript and Python that can interact with our tool
-
-This demonstrates the power of the Model Context Protocol - we can create specialized tools using frameworks we're familiar with (like Gradio), expose them through a standardized interface (MCP), and then have agents seamlessly use these tools alongside other capabilities.
-
-The complete flow we've built allows an agent to:
-- Connect to multiple tool providers
-- Dynamically discover available tools
-- Use our custom sentiment analysis tool
-- Combine it with other capabilities like file system access and web browsing
-
-This modular approach is what makes MCP so powerful for building flexible AI applications.
-
-## Next Steps
-
-- Check out the Tiny Agents blog posts in [Python](https://huggingface.co/blog/python-tiny-agents) and [TypeScript](https://huggingface.co/blog/tiny-agents)
-- Review the [Tiny Agents documentation](https://huggingface.co/docs/huggingface.js/main/en/tiny-agents/README)
-- Build something with Tiny Agents!

units/en/unit3/introduction.mdx

@@ -1,3 +0,0 @@
-# Coming Soon
-
-This will be another use case that dives deeper into the MCP protocol and how to use it in more complex ways.

units/en/unit4/introduction.mdx

@@ -1,5 +0,0 @@
-# Coming Soon
-
-This unit will be a collaboration with partners from the AI community.
-
-If you're building tools for MCP, please reach out to us and we'll add you to the unit. Open a [discussion](https://huggingface.co/spaces/mcp-course/README/discussions) on the hub organization.

units/vi/_toctree.yml

@@ -1,46 +0,0 @@
-- title: "0. Chào mừng đến với Khóa học MCP"
-  sections:
-  - local: unit0/introduction
-    title: Chào mừng đến với Khóa học MCP
-    
-- title: "1. Giới thiệu về Giao Thức Ngữ Cảnh Mô Hình (MCP)"
-  sections:
-  - local: unit1/introduction
-    title: Giới thiệu về Giao Thức Ngữ Cảnh Mô Hình (MCP)
-  - local: unit1/key-concepts
-    title: Khái niệm và Thuật ngữ chính
-  - local: unit1/architectural-components
-    title: Các thành phần kiến trúc
-  - local: unit1/communication-protocol
-    title: Giao thức truyền thông
-  - local: unit1/capabilities
-    title: Hiểu về khả năng của MCP
-  - local: unit1/sdk
-    title: MCP SDK
-  - local: unit1/mcp-clients
-    title: MCP Clients
-  - local: unit1/gradio-mcp
-    title: Tích hợp Gradio với MCP
-
-- title: "2. Trường hợp sử dụng: Ứng dụng MCP đầu cuối"
-  sections:
-  - local: unit2/introduction
-    title: Giới thiệu về Xây dựng Ứng dụng MCP
-  - local: unit2/gradio-server
-    title: Xây dựng Máy chủ Gradio MCP
-  - local: unit2/clients
-    title: Sử dụng MCP Clients với ứng dụng của bạn
-  - local: unit2/gradio-client
-    title: Xây dựng MCP Clients bằng Gradio
-  - local: unit2/tiny-agents
-    title: Xây dựng Tiny Agent với TypeScript
-
-- title: "3. Trường hợp sử dụng: Phát triển MCP Nâng cao"
-  sections:
-  - local: unit3/introduction
-    title: Sắp ra mắt
-
-- title: "Các chương bổ trợ"
-  sections:
-  - local: unit4/introduction
-    title: Sắp ra mắt

units/vi/unit0/introduction.mdx

@@ -1,135 +0,0 @@
-# Chào mừng bạn đến với 🤗 Khóa học Giao Thức Ngữ Cảnh Mô Hình (MCP)
-
-![MCP Course thumbnail](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/1.png)
-
-Chào mừng các bạn đến với chủ đề thú vị nhất trong AI hiện nay: **Giao Thức Ngữ Cảnh Mô Hình (MCP)**!
-
-Khóa học miễn phí này sẽ dẫn dắt các bạn **từ người mới bắt đầu trở thành người am hiểu** về cách sử dụng và xây dựng ứng dụng với MCP.
-
-Chương đầu tiên sẽ giúp bạn làm quen:
-* Khám phá **giáo trình khóa học**
-* **Nhận thêm thông tin về quy trình cấp chứng chỉ và lịch trình**
-* Làm quen với đội ngũ xây dựng khóa học
-* Tạo **tài khoản** của bạn
-* **Tham gia Discord** để gặp gỡ bạn học và chúng mình
-
-Cùng bắt đầu thôi!
-
-## Bạn sẽ học được gì từ khóa học này?
-
-Trong khóa học này, các bạn sẽ:
-* 📖 Nghiên cứu MCP về **lý thuyết, thiết kế và thực hành**
-* 🧑‍💻 Học cách **sử dụng các SDK và framework MCP phổ biến**
-* 💾 **Chia sẻ dự án** và khám phá ứng dụng từ cộng đồng
-* 🏆 Tham gia các bài tập lớn để **đánh giá cách triển khai MCP của bạn so với các học viên khác**
-* 🎓 **Nhận chứng chỉ hoàn thành** bằng cách hoàn thành các bài tập
-
-Và còn nhiều hơn thế!
-
-Kết thúc khóa học, bạn sẽ hiểu **cách MCP hoạt động và cách xây dựng ứng dụng AI sử dụng dữ liệu/công cụ bên ngoài theo chuẩn MCP mới nhất**.
-
-Đừng quên [**đăng ký khóa học!**](https://huggingface.co/mcp-course)
-
-## Cấu trúc khóa học như thế nào?
-
-Khóa học bao gồm:
-* _Chương nền tảng_: nơi bạn học **khái niệm lý thuyết** về MCP
-* _Thực hành_: nơi bạn học **cách sử dụng SDK MCP** để xây dựng ứng dụng. Các phần thực hành sẽ có môi trường được cấu hình sẵn
-* _Bài tập tình huống_: nơi bạn áp dụng kiến thức đã học để giải quyết vấn đề thực tế do bạn lựa chọn
-* _Hợp tác_: Chúng tôi hợp tác với các đối tác của Hugging Face để mang đến cho bạn những triển khai MCP mới nhất
-
-**Khóa học này là dự án sống, phát triển cùng phản hồi và đóng góp của bạn!** Hãy thoải mái tạo issue/PR trên GitHub và thảo luận tại Discord server của chúng ta.
-
-Sau khi hoàn thành khóa học, bạn có thể gửi phản hồi 👉 qua [biểu mẫu này]
-
-## Giáo trình chi tiết
-
-Dưới đây là **giáo trình tổng quan**. Danh sách chi tiết sẽ được cập nhật theo từng chương.
-
-| Chương | Chủ đề                                       | Mô tả                                                                                                            |
-| ------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| 0       | Làm quen                                  | Thiết lập công cụ và nền tảng cần dùng                                                             |
-| 1       | Nguyên lý, kiến trúc và khái niệm cốt lõi của MCP | Giải thích khái niệm cơ bản, kiến trúc và thành phần của MCP. Minh họa trường hợp sử dụng đơn giản với MCP       |
-| 2       | Ứng dụng end-to-end: MCP trong thực tế              | Xây dựng ứng dụng MCP end-to-end đơn giản để chia sẻ với cộng đồng |
-| 3       | Triển khai ứng dụng: MCP trong thực tế               | Xây dựng ứng dụng MCP triển khai thực tế sử dụng hệ sinh thái Hugging Face và dịch vụ đối tác                                        |
-| 4       | Chương bổ trợ                                  | Các chương nâng cao giúp bạn tận dụng tối đa khóa học, làm việc với thư viện và dịch vụ đối tác                                        |
-
-## Yêu cầu đầu vào
-
-Để theo học hiệu quả, bạn cần:
-* Hiểu biết cơ bản về AI và các khái niệm LLM
-* Quen thuộc với nguyên tắc phát triển phần mềm và khái niệm API
-* Có kinh nghiệm với ít nhất một ngôn ngữ lập trình (ví dụ Python hoặc TypeScript sẽ được sử dụng minh họa)
-
-Nếu bạn chưa có những kiến thức này, đừng lo! Dưới đây là một số tài nguyên hữu ích:
-
-* [LLM Course](https://huggingface.co/learn/llm-course/) sẽ hướng dẫn bạn những kiến thức cơ bản về sử dụng và xây dựng với LLMs.
-* [Agents Course](https://huggingface.co/learn/agents-course/) sẽ hướng dẫn bạn cách xây dựng AI Agents với LLMs.
-
-<Tip>
-
-Các khóa học trên không phải là điều kiện bắt buộc, vì vậy nếu bạn đã hiểu các khái niệm về LLM và Agents, các bạn có thể bắt đầu khóa học ngay bây giờ!
-
-</Tip>
-
-## Tôi cần những công cụ gì?
-
-Bạn chỉ cần 2 thứ:
-
-* _Một máy tính_ có kết nối internet.
-* _Tài khoản_: để truy cập tài nguyên khóa học và tạo dự án. Nếu chưa có tài khoản, bạn có thể tạo [tại đây](https://huggingface.co/join) (miễn phí).
-
-## Quy trình cấp chứng chỉ
-
-Bạn có thể chọn học khóa học này ở _chế độ audit_, hoặc hoàn thành các hoạt động và _nhận một trong hai chứng chỉ mà chúng tôi cấp_. Nếu chọn audit, bạn vẫn có thể tham gia tất cả bài tập lớn và làm bài tập nếu muốn, **bạn không cần thông báo với chúng tôi**.
-
-Quy trình cấp chứng chỉ **hoàn toàn miễn phí**:
-
-* _Để nhận chứng chỉ kiến thức cơ bản_: bạn cần hoàn thành Chương 1. Dành cho học viên muốn cập nhật xu hướng mới nhất về MCP mà không cần xây dựng ứng dụng đầy đủ.
-* _Để nhận chứng chỉ hoàn thành_: bạn cần hoàn thành các chương ứng dụng (2 và 3). Dành cho học viên muốn xây dựng ứng dụng hoàn chỉnh và chia sẻ với cộng đồng.
-
-## Tốc độ học được khuyến nghị?
-
-Mỗi chương trong khóa học được thiết kế **để hoàn thành trong 1 tuần, với khoảng 3-4 giờ học mỗi tuần**.
-
-Vì có thời hạn cụ thể, chúng tôi đưa ra lộ trình khuyến nghị:
-
-![Recommended Pace](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/2.png)
-
-## Làm thế nào để học hiệu quả nhất?
-
-Để học hiệu quả nhất, chúng tôi có vài lời khuyên:
-
-1. Tham gia nhóm học tập trên Discord: học cùng nhau luôn dễ dàng hơn. Hãy tham gia Discord của chúng tôi và xác thực tài khoản.
-2. **Làm bài kiểm tra và bài tập**: cách học tốt nhất là qua thực hành và tự đánh giá.
-3. **Lập lịch học để theo kịp tiến độ**: bạn có thể dùng lộ trình khuyến nghị bên dưới hoặc tự tạo lịch riêng.
-
-![Course advice](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit0/3.png)
-
-## Về chúng tôi
-
-Thông tin tác giả:
-
-### Ben Burtenshaw
-
-Ben là Kỹ sư Máy học tại Hugging Face, tập trung vào xây dựng các ứng dụng LLM với phương pháp hậu huấn luyện và agentic.
-
-<!-- ## 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 -->
-
-## Tôi phát hiện lỗi hoặc muốn cải thiện khóa học
-
-Mọi đóng góp đều **được chào đón** 🤗
-
-* Nếu bạn _phát hiện lỗi 🐛 trong notebook_, hãy mở một issue và **mô tả vấn đề**.
-* Nếu bạn _muốn cải thiện khóa học_, bạn có thể mở một Pull Request.
-* Nếu bạn _muốn thêm một mục đầy đủ hoặc một Chương mới_, cách tốt nhất là mở một issue và **mô tả nội dung bạn muốn thêm trước khi bắt đầu viết để chúng tôi có thể hướng dẫn bạn**.
-
-## Tôi vẫn còn thắc mắc
-
-Hãy đặt câu hỏi của bạn trên máy chủ Discord của chúng tôi tại kênh #mcp-course-questions.
-
-Giờ bạn đã có đầy đủ thông tin, hãy cùng nhau lên đường ⛵

units/vi/unit1/architectural-components.mdx

@@ -1,85 +0,0 @@
-# Các thành phần kiến trúc của MCP
-
-Ở chương trước, chúng ta đã thảo luận về các khái niệm và thuật ngữ chính của MCP. Giờ hãy cùng đi sâu hơn vào các thành phần kiến trúc tạo nên hệ sinh thái MCP.
-
-## Host, Client và Server
-
-Giao Thức Ngữ Cảnh Mô Hình (MCP) được xây dựng trên kiến trúc client-server để kích hoạt giao tiếp có cấu trúc giữa các mô hình AI và hệ thống bên ngoài.
-
-![MCP Architecture](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/4.png)
-
-Kiến trúc MCP bao gồm ba thành phần chính với vai trò và trách nhiệm được xác định rõ ràng: Host, Client và Server. Chúng ta đã đề cập sơ qua ở phần trước, giờ hãy phân tích kỹ hơn từng thành phần.
-
-### Host
-
-**Host** là ứng dụng AI tiếp xúc trực tiếp với người dùng cuối. 
-
-Ví dụ bao gồm:
-- Ứng dụng chat AI như OpenAI ChatGPT hay Claude Desktop của Anthropic
-- IDE tích hợp AI như Cursor, hoặc các công cụ như Continue.dev
-- Các agent AI tùy chỉnh và ứng dụng xây dựng bằng thư viện như LangChain hay smolagents
-
-Trách nhiệm của Host:
-- Quản lý tương tác và quyền hạn người dùng
-- Thiết lập kết nối tới MCP Server thông qua MCP Client
-- Điều phối luồng xử lý giữa yêu cầu người dùng, xử lý LLM và công cụ bên ngoài
-- Hiển thị kết quả cho người dùng dưới định dạng mạch lạc
-
-Thông thường, người dùng sẽ chọn ứng dụng Host dựa trên nhu cầu cá nhân. Ví dụ, nhà phát triển có thể chọn Cursor cho khả năng chỉnh sửa mã mạnh mẽ, trong khi chuyên gia nghiệp vụ có thể dùng ứng dụng tùy chỉnh xây bằng smolagents.
-
-### Client
-
-**Client** là thành phần trong ứng dụng Host quản lý giao tiếp với một MCP Server cụ thể. Đặc điểm chính:
-
-- Mỗi Client duy trì kết nối 1:1 với một Server
-- Xử lý các chi tiết giao thức của MCP
-- Đóng vai trò trung gian giữa logic của Host và Server bên ngoài
-
-### Server
-
-**Server** là chương trình/dịch vụ bên ngoài cung cấp khả năng truy cập vào các công cụ, nguồn dữ liệu hoặc dịch vụ thông qua giao thức MCP. Server:
-
-- Cung cấp quyền truy cập vào các công cụ/dịch vụ bên ngoài
-- Đóng vai trò lớp bao bọc nhẹ cho chức năng có sẵn
-- Có thể chạy cục bộ (cùng máy với Host) hoặc từ xa (qua mạng)
-- Cung cấp khả năng dưới định dạng chuẩn để Client khám phá và sử dụng
-
-## Luồng giao tiếp
-
-Cùng xem cách các thành phần tương tác trong quy trình MCP điển hình:
-
-<Tip>
-
-Trong phần tiếp theo, chúng ta sẽ khám phá sâu hơn về giao thức giao tiếp với các ví dụ thực tế.
-
-</Tip>
-
-1. **Tương tác người dùng**: Người dùng tương tác với ứng dụng **Host**, thể hiện nhu cầu hoặc truy vấn.
-
-2. **Xử lý Host**: **Host** xử lý đầu vào, có thể dùng LLM để hiểu yêu cầu và xác định cần dùng công cụ nào.
-
-3. **Kết nối Client**: **Host** hướng dẫn **Client** kết nối tới Server phù hợp.
-
-4. **Khám phá khả năng**: **Client** truy vấn **Server** để biết các khả năng (Công cụ, Tài nguyên, Prompt) mà nó cung cấp.
-
-5. **Kích hoạt khả năng**: Dựa trên nhu cầu người dùng hoặc quyết định của LLM, Host yêu cầu **Client** kích hoạt khả năng cụ thể từ **Server**.
-
-6. **Thực thi Server**: **Server** thực thi chức năng được yêu cầu và trả kết quả về **Client**.
-
-7. **Tích hợp kết quả**: **Client** chuyển kết quả về **Host**, nơi tích hợp chúng vào ngữ cảnh LLM hoặc hiển thị trực tiếp cho người dùng.
-
-Ưu điểm chính của kiến trúc này là tính mô-đun. Một Host duy nhất có thể kết nối với nhiều Server cùng lúc thông qua các Client khác nhau. Có thể thêm Server mới vào hệ sinh thái mà không cần thay đổi Host hiện có. Có thể dễ dàng kết hợp các khả năng trên nhiều Server khác nhau.
-
-<Tip>
-
-Như đã thảo luận ở phần trước, tính mô-đun này biến bài toán tích hợp M×N truyền thống (khi M ứng dụng AI kết nối với N công cụ/dịch vụ) thành một bài toán M+N dễ quản lý hơn - nơi mỗi Host và Server chỉ cần triển khai chuẩn MCP một lần.
-
-</Tip>
-
-Kiến trúc này trông có vẻ đơn giản, nhưng sức mạnh thực sự nằm ở việc chuẩn hóa giao thức truyền thông và sự phân tách rõ ràng trách nhiệm giữa các thành phần. Thiết kế này cho phép tạo ra một hệ sinh thái gắn kết nơi các mô hình AI có thể kết nối liền mạch với một mảng các công cụ và nguồn dữ liệu bên ngoài ngày càng phát triển.
-
-## Kết luận
-
-Những mẫu tương tác này được định hướng bởi các nguyên tắc chính định hình thiết kế và sự phát triển của MCP. Giao thức nhấn mạnh **tính chuẩn hóa** thông qua việc cung cấp một giao thức kết nối phổ quát cho AI, đồng thời duy trì **sự đơn giản** bằng cách giữ phần lõi giao thức dễ hiểu nhưng vẫn hỗ trợ các tính năng nâng cao. **An toàn** được ưu tiên thông qua yêu cầu phê duyệt rõ ràng từ người dùng cho các thao tác nhạy cảm, trong khi khả năng khám phá cho phép phát hiện động các chức năng. Giao thức được xây dựng với tư duy **mở rộng**, hỗ trợ phát triển thông qua phiên bản hóa và đàm phán chức năng, đồng thời đảm bảo **khả năng tương tác** giữa các triển khai và môi trường khác nhau.
-
-Trong phần tiếp theo, chúng ta sẽ khám phá giao thức truyền thông giúp các thành phần này phối hợp hiệu quả với nhau.

units/vi/unit1/capabilities.mdx

@@ -1,377 +0,0 @@
-# Hiểu về Khả năng của MCP
-
-Các MCP Server cung cấp nhiều khả năng khác nhau cho Client thông qua giao thức truyền thông. Những khả năng này được chia thành bốn loại chính, mỗi loại có đặc điểm và trường hợp sử dụng riêng. Hãy cùng khám phá các nguyên thủy cốt lõi tạo nền tảng cho chức năng của MCP.
-
-<Tip>
-
-Trong phần này, chúng ta sẽ xem các ví dụ dưới dạng hàm độc lập với framework trong mỗi ngôn ngữ. Mục đích là tập trung vào khái niệm và cách chúng phối hợp với nhau, thay vì sự phức tạp của bất kỳ framework cụ thể nào.
-
-Trong các chương tiếp theo, chúng ta sẽ xem cách triển khai các khái niệm này trong mã cụ thể của MCP.
-
-</Tip>
-
-## Công cụ (Tools)
-
-Công cụ là các hàm hoặc hành động có thể thực thi mà mô hình AI có thể gọi thông qua giao thức MCP.
-
-- **Kiểm soát**: Công cụ thường **được kiểm soát bởi mô hình** (model-controlled), nghĩa là mô hình AI (LLM) quyết định khi nào gọi chúng dựa trên yêu cầu và ngữ cảnh của người dùng.
-- **An toàn**: Do khả năng thực hiện các hành động có tác dụng phụ, việc thực thi công cụ có thể nguy hiểm. Vì vậy chúng thường yêu cầu sự chấp thuận rõ ràng từ người dùng.
-- **Trường hợp sử dụng**: Gửi tin nhắn, tạo ticket, truy vấn API, thực hiện tính toán.
-
-**Ví dụ**: Một công cụ thời tiết lấy dữ liệu thời tiết hiện tại cho một địa điểm:
-
-<hfoptions id="tool-example">
-<hfoption id="python">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```python
-def get_weather(location: str) -> dict:
-    """Nhận thông tin thời tiết hiện tại ở một địa điểm cụ thể."""
-    # Connect to weather API and fetch data
-    return {
-        "temperature": 72,
-        "conditions": "Sunny",
-        "humidity": 45
-    }
-```
-</details>
-
-```python
-def get_weather(location: str) -> dict:
-    """Get the current weather for a specified location."""
-    # Connect to weather API and fetch data
-    return {
-        "temperature": 72,
-        "conditions": "Sunny",
-        "humidity": 45
-    }
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```javascript
-function getWeather(location) {
-    // Kết nối đến API thời tiết và lấy dữ liệu
-    return {
-        temperature: 72,
-        conditions: 'Sunny',
-        humidity: 45
-    };
-}
-```
-</details>
-
-```javascript
-function getWeather(location) {
-    // Connect to weather API and fetch data
-    return {
-        temperature: 72,
-        conditions: 'Sunny',
-        humidity: 45
-    };
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Tài nguyên (Resources)
-
-Tài nguyên cung cấp quyền truy cập chỉ đọc (read-only) vào các nguồn dữ liệu, cho phép mô hình AI truy xuất ngữ cảnh mà không cần thực thi logic phức tạp.
-
-- **Kiểm soát**: Tài nguyên **được kiểm soát bởi ứng dụng** (application-controlled), nghĩa là ứng dụng Host thường quyết định khi nào truy cập chúng.
-- **Bản chất**: Được thiết kế để truy xuất dữ liệu với tính toán tối thiểu, tương tự các endpoint GET trong REST API.
-- **An toàn**: Vì chỉ đọc nên chúng thường ít rủi ro bảo mật hơn so với Công cụ.
-- **Trường hợp sử dụng**: Truy cập nội dung file, lấy bản ghi cơ sở dữ liệu, đọc thông tin cấu hình.
-
-**Ví dụ**: Một tài nguyên cung cấp quyền truy cập vào nội dung file:
-
-<hfoptions id="resource-example">
-<hfoption id="python">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```python
-def read_file(file_path: str) -> str:
-    """Đọc nội dung của file tại đường dẫn được chỉ định."""
-    with open(file_path, 'r') as f:
-        return f.read()
-```
-</details>
-
-```python
-def read_file(file_path: str) -> str:
-    """Read the contents of a file at the specified path."""
-    with open(file_path, 'r') as f:
-        return f.read()
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```javascript
-function readFile(filePath) {
-    // Sử dụng fs.readFile để đọc nội dung file
-    const fs = require('fs');
-    return new Promise((resolve, reject) => {
-        fs.readFile(filePath, 'utf8', (err, data) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            resolve(data);
-        });
-    });
-}
-```
-</details>
-
-```javascript
-function readFile(filePath) {
-    // Using fs.readFile to read file contents
-    const fs = require('fs');
-    return new Promise((resolve, reject) => {
-        fs.readFile(filePath, 'utf8', (err, data) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            resolve(data);
-        });
-    });
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Lời nhắc
-
-Lời nhắc (Prompts) là các mẫu hoặc quy trình làm việc được định nghĩa trước nhằm hướng dẫn tương tác giữa người dùng, Mô hình AI và khả năng của Server.
-
-- **Kiểm soát**: Lời nhắc **do người dùng kiểm soát**, thường được hiển thị dưới dạng các tùy chọn trong giao diện ứng dụng Host.
-- **Mục đích**: Chúng cấu trúc các tương tác để tối ưu hóa việc sử dụng Công cụ và Tài nguyên sẵn có.
-- **Lựa chọn**: Người dùng thường chọn một lời nhắc trước khi Mô hình AI bắt đầu xử lý, thiết lập ngữ cảnh cho tương tác.
-- **Trường hợp sử dụng**: Quy trình làm việc phổ biến, mẫu tác vụ chuyên biệt, tương tác có hướng dẫn.
-
-**Ví dụ**: Mẫu lời nhắc để tạo đánh giá mã nguồn:
-
-<hfoptions id="prompt-example">
-<hfoption id="python">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```python
-def code_review(code: str, language: str) -> list:
-    """Tạo đánh giá mã nguồn cho đoạn code được cung cấp."""
-    return [
-        {
-            "role": "system",
-            "content": f"You are a code reviewer examining {language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement."
-        },
-        {
-            "role": "user",
-            "content": f"Please review this {language} code:\n\n```{language}\n{code}\n```"
-        }
-    ]
-```
-</details>
-
-```python
-def code_review(code: str, language: str) -> list:
-    """Generate a code review for the provided code snippet."""
-    return [
-        {
-            "role": "system",
-            "content": f"You are a code reviewer examining {language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement."
-        },
-        {
-            "role": "user",
-            "content": f"Please review this {language} code:\n\n```{language}\n{code}\n```"
-        }
-    ]
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-
-```javascript
-function codeReview(code, language) {
-    return [
-        {
-            role: 'system',
-            content: `You are a code reviewer examining ${language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement.`
-        },
-        {
-            role: 'user',
-            content: `Please review this ${language} code:\n\n\`\`\`${language}\n${code}\n\`\`\``
-        }
-    ];
-}
-```
-</details>
-
-```javascript
-function codeReview(code, language) {
-    return [
-        {
-            role: 'system',
-            content: `You are a code reviewer examining ${language} code. Provide a detailed review highlighting best practices, potential issues, and suggestions for improvement.`
-        },
-        {
-            role: 'user',
-            content: `Please review this ${language} code:\n\n\`\`\`${language}\n${code}\n\`\`\``
-        }
-    ];
-}
-```
-
-</hfoption>
-</hfoptions>
-
-## Lấy mẫu (Sampling)
-
-Lấy mẫu cho phép Server yêu cầu Client (cụ thể là ứng dụng Host) thực hiện các tương tác LLM.
-
-- **Kiểm soát**: Lấy mẫu **do Server khởi xướng** nhưng cần sự hỗ trợ từ Client/Host.
-- **Mục đích**: Kích hoạt các hành vi tự chủ từ Server và các tương tác đệ quy/đa bước tiềm năng.
-- **An toàn**: Giống như Công cụ, các thao tác lấy mẫu thường yêu cầu sự chấp thuận của người dùng.
-- **Trường hợp sử dụng**: Các tác vụ đa bước phức tạp, quy trình làm việc của agent tự động, quá trình tương tác.
-
-**Ví dụ**: Server có thể yêu cầu Client phân tích dữ liệu đã xử lý:
-
-<hfoptions id="sampling-example">
-<hfoption id="python">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-def request_sampling(messages, system_prompt=None, include_context="none"):
-    """Yêu cầu lấy mẫu LLM từ máy khách."""
-    # Trong triển khai thực tế, phần này sẽ gửi yêu cầu đến máy khách
-    return {
-        "role": "assistant",
-        "content": "Analysis of the provided data..."
-    }
-```
-</details>
-
-```python
-def request_sampling(messages, system_prompt=None, include_context="none"):
-    """Request LLM sampling from the client."""
-    # In a real implementation, this would send a request to the client
-    return {
-        "role": "assistant",
-        "content": "Analysis of the provided data..."
-    }
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```javascript
-function requestSampling(messages, systemPrompt = null, includeContext = 'none') {
-    // Trong triển khai thực tế, phần này sẽ gửi yêu cầu đến máy khách
-    return {
-        role: 'assistant',
-        content: 'Analysis of the provided data...'
-    };
-}
-
-function handleSamplingRequest(request) {
-    const { messages, systemPrompt, includeContext } = request;
-    // Trong triển khai thực tế, phần này sẽ xử lý yêu cầu và trả về phản hồi
-    return {
-        role: 'assistant',
-        content: 'Response to the sampling request...'
-    };
-}
-```
-</details>
-
-```javascript
-function requestSampling(messages, systemPrompt = null, includeContext = 'none') {
-    // In a real implementation, this would send a request to the client
-    return {
-        role: 'assistant',
-        content: 'Analysis of the provided data...'
-    };
-}
-
-function handleSamplingRequest(request) {
-    const { messages, systemPrompt, includeContext } = request;
-    // In a real implementation, this would process the request and return a response
-    return {
-        role: 'assistant',
-        content: 'Response to the sampling request...'
-    };
-}
-```
-
-</hfoption>
-</hfoptions>
-
-Quy trình lấy mẫu (sampling) diễn ra theo các bước sau:
-1. Server gửi yêu cầu `sampling/createMessage` đến client
-2. Client xem xét và có thể chỉnh sửa yêu cầu này
-3. Client lấy mẫu từ một LLM
-4. Client kiểm tra kết quả hoàn thiện
-5. Client trả kết quả về cho server
-
-<Tip>
-
-Thiết kế human-in-the-loop (có sự tham gia của con người trong vòng lặp) này đảm bảo người dùng duy trì quyền kiểm soát những gì LLM nhìn thấy và tạo ra. Khi triển khai sampling, điều quan trọng là phải cung cấp các lời nhắc rõ ràng, được cấu trúc tốt và bao gồm ngữ cảnh liên quan.
-
-</Tip>
-
-## Cách Các Khả Năng Phối Hợp
-
-Hãy cùng xem cách các khả năng này phối hợp với nhau để tạo ra các tương tác phức tạp. Trong bảng dưới đây, chúng ta đã liệt kê các khả năng, đối tượng kiểm soát, hướng kiểm soát và một số chi tiết khác.
-
-| Khả năng    | Được kiểm soát bởi | Hướng     | Tác dụng phụ       | Cần phê duyệt | Trường hợp sử dụng điển hình       |
-|------------|-------------------|-----------|--------------------|---------------|-----------------------------------|
-| Tools      | Mô hình (LLM)     | Client → Server | Có (có thể)       | Có            | Hành động, gọi API, thao tác dữ liệu |
-| Resources  | Ứng dụng          | Client → Server | Không (chỉ đọc)   | Thường không  | Truy xuất dữ liệu, thu thập ngữ cảnh |
-| Prompts    | Người dùng        | Server → Client | Không              | Không (do người dùng chọn) | Quy trình làm việc có hướng dẫn, mẫu chuyên biệt |
-| Sampling   | Server            | Server → Client → Server | Gián tiếp | Có            | Tác vụ nhiều bước, hành vi agentic |
-
-Các khả năng này được thiết kế để bổ trợ cho nhau theo những cách sau:
-
-1. Người dùng có thể chọn **Prompt** để bắt đầu quy trình làm việc chuyên biệt
-2. Prompt có thể bao gồm ngữ cảnh từ **Tài nguyên**
-3. Trong quá trình xử lý, mô hình AI có thể gọi **Công cụ** để thực hiện hành động cụ thể
-4. Với các thao tác phức tạp, Server có thể sử dụng **Sampling** để yêu cầu xử lý LLM bổ sung
-
-Sự phân biệt giữa chúng tạo ra cấu trúc rõ ràng cho các tương tác MCP, cho phép các mô hình AI truy cập thông tin, thực hiện hành động và tham gia vào các quy trình làm việc phức tạp trong khi vẫn duy trì các ranh giới kiểm soát phù hợp.
-
-## Quá Trình Khám Phá
-
-Một tính năng chính của MCP là khả năng khám phá động. Khi Client kết nối với Server, nó có thể truy vấn các Tools, Resources và Prompts khả dụng thông qua các phương thức danh sách cụ thể:
-
-- `tools/list`: Khám phá Tools khả dụng
-- `resources/list`: Khám phá Resources khả dụng
-- `prompts/list`: Khám phá Prompts khả dụng
-
-Cơ chế khám phá động này cho phép Client thích ứng với các khả năng cụ thể mà mỗi Server cung cấp mà không cần biết trước về chức năng của Server.
-
-## Kết Luận
-
-Hiểu rõ các yếu tố cốt lõi này là điều cần thiết để làm việc hiệu quả với MCP. Bằng cách cung cấp các loại khả năng riêng biệt với ranh giới kiểm soát rõ ràng, MCP cho phép các tương tác mạnh mẽ giữa mô hình AI và hệ thống bên ngoài trong khi vẫn duy trì các cơ chế an toàn và kiểm soát phù hợp.
-
-Trong phần tiếp theo, chúng ta sẽ khám phá cách Gradio tích hợp với MCP để cung cấp các giao diện dễ sử dụng cho các khả năng này.

units/vi/unit1/communication-protocol.mdx

@@ -1,223 +0,0 @@
-# Giao Thức Truyền Thông
-
-MCP định nghĩa một giao thức truyền thông chuẩn hóa cho phép Client và Server trao đổi thông điệp một cách nhất quán, dễ dự đoán. Sự chuẩn hóa này rất quan trọng để đảm bảo khả năng tương tác trong cộng đồng. Trong phần này, chúng ta sẽ khám phá cấu trúc giao thức và cơ chế vận chuyển được sử dụng trong MCP.
-
-<Tip warning={true}>
-
-Chúng ta đang đi sâu vào những chi tiết phức tạp của giao thức MCP (nguyên văn: "nitty-gritty" - chỉ những chi tiết quan trọng và phức tạp). Bạn không cần biết tất cả những điều này để xây dựng với MCP, nhưng nên biết về sự tồn tại và cách hoạt động của nó.
-
-</Tip>
-
-## JSON-RPC: Nền Tảng
-
-Cốt lõi của MCP sử dụng **JSON-RPC 2.0** làm định dạng thông điệp cho mọi giao tiếp giữa Client và Server. JSON-RPC là giao thức gọi thủ tục từ xa nhẹ được mã hóa bằng JSON, mang lại các ưu điểm:
-
-- Dễ đọc và dễ gỡ lỗi
-- Không phụ thuộc ngôn ngữ, hỗ trợ triển khai trên mọi môi trường lập trình
-- Được thiết lập tốt với đặc tả rõ ràng và được áp dụng rộng rãi
-
-![message types](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/5.png)
-
-Giao thức định nghĩa ba loại thông điệp:
-
-### 1. Yêu Cầu (Requests)
-
-Được gửi từ Client đến Server để khởi tạo một thao tác. Thông điệp Yêu cầu bao gồm:
-- Định danh duy nhất (`id`)
-- Tên phương thức cần gọi (ví dụ: `tools/call`)
-- Tham số cho phương thức (nếu có)
-
-Ví dụ Yêu cầu:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "tools/call",
-  "params": {
-    "name": "weather",
-    "arguments": {
-      "location": "San Francisco"
-    }
-  }
-}
-```
-
-### 2. Phản Hồi (Responses)
-
-Được gửi từ Server đến Client để trả lời Yêu cầu. Thông điệp Phản hồi bao gồm:
-- `id` giống với Yêu cầu tương ứng
-- Hoặc `result` (thành công) hoặc `error` (thất bại)
-
-Ví dụ Phản hồi Thành công:
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "temperature": 62,
-    "conditions": "Partly cloudy"
-  }
-}
-```
-
-Ví dụ Phản hồi Lỗi:
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "error": {
-    "code": -32602,
-    "message": "Invalid location parameter"
-  }
-}
-```
-
-### 3. Thông Báo
-
-Thông điệp một chiều không yêu cầu phản hồi. Thường được gửi từ Server đến Client để cập nhật tiến trình hoặc thông báo sự kiện.
-
-Ví dụ Thông Báo:
-```json
-{
-  "jsonrpc": "2.0",
-  "method": "progress",
-  "params": {
-    "message": "Processing data...",
-    "percent": 50
-  }
-}
-```
-
-## Cơ Chế Vận Chuyển
-
-JSON-RPC định nghĩa định dạng thông điệp, nhưng MCP cũng chỉ định cách thức các thông điệp này được truyền tải giữa Server đến Client. Hai cơ chế vận chuyển chính được hỗ trợ:
-
-### stdio (Đầu vào/Đầu ra chuẩn)
-
-Cơ chế stdio được dùng cho giao tiếp cục bộ, khi Client và Server chạy trên cùng máy:
-
-Ứng dụng chủ khởi chạy Server như một tiến trình con và giao tiếp bằng cách ghi vào đầu vào chuẩn (stdin) và đọc từ đầu ra chuẩn (stdout).
-
-<Tip>
-
-**Trường hợp sử dụng** cho phương thức truyền tải này là các công cụ local như truy cập hệ thống file hoặc chạy script local.
-
-</Tip>
-
-**Ưu điểm** chính của phương thức này là đơn giản, không yêu cầu cấu hình mạng và được hệ điều hành cách ly an toàn.
-
-### HTTP + SSE (Server-Sent Events) / HTTP có thể streaming
-
-Phương thức HTTP + SSE được dùng cho giao tiếp từ xa khi Client và Server có thể ở các máy khác nhau:
-
-Giao tiếp diễn ra qua HTTP, với Server sử dụng Server-Sent Events (SSE) để đẩy các cập nhật tới Client qua kết nối liên tục.
-
-<Tip>
-
-**Trường hợp sử dụng** cho phương thức này là kết nối tới API từ xa, dịch vụ đám mây hoặc tài nguyên dùng chung.
-
-</Tip>
-
-**Ưu điểm** chính là hoạt động được qua mạng, tích hợp được với dịch vụ web và tương thích với môi trường serverless.
-
-Các bản cập nhật gần đây của chuẩn MCP đã giới thiệu hoặc cải tiến "Streamable HTTP", mang lại tính linh hoạt cao hơn bằng cách cho phép Server nâng cấp động lên SSE để streaming khi cần, đồng thời vẫn giữ được tính tương thích với môi trường serverless.
-
-## Vòng đời tương tác
-
-Ở phần trước, chúng ta đã thảo luận về vòng đời của một lượt tương tác đơn lẻ giữa Client (💻) và Server (🌐). Giờ h��y xem xét vòng đời của một lượt tương tác hoàn chỉnh trong ngữ cảnh giao thức MCP.
-
-Giao thức MCP định nghĩa vòng đời tương tác có cấu trúc giữa Client và Server:
-
-### Khởi tạo
-
-Client kết nối tới Server và hai bên trao đổi phiên bản giao thức cùng các tính năng hỗ trợ, Server phản hồi với phiên bản giao thức và tính năng mà nó hỗ trợ.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>initialize</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>initialized</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-Client xác nhận hoàn tất khởi tạo qua thông báo.
-
-### Khám phá
-
-Client yêu cầu thông tin về các tính năng khả dụng và Server phản hồi với danh sách công cụ có sẵn.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>tools/list</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>response</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-Quá trình này có thể được lặp lại cho từng công cụ, tài nguyên hoặc loại prompt.
-
-### Thực thi
-
-Client kích hoạt các khả năng dựa trên nhu cầu của Host.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>tools/call</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>thông báo (tiến trình tùy chọn)</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>phản hồi</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-### Kết thúc
-
-Kết nối được đóng một cách hợp lệ khi không còn cần thiết và Server xác nhận yêu cầu tắt.
-
-<table style="width: 100%;">
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>tắt máy</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">←<br>phản hồi</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-  <tr>
-    <td style="background-color: lightgreen; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">💻</td>
-    <td style="text-align: center;">→<br>thoát</td>
-    <td style="background-color: lightblue; text-align: center; padding: 10px; border: 1px solid #ccc; border-radius: 4px;">🌐</td>
-  </tr>
-</table>
-
-Client gửi thông điệp thoát cuối cùng để hoàn tất việc kết thúc.
-
-## Tiến h��a của Giao thức
-
-Giao thức MCP được thiết kế để có thể mở rộng và thích ứng. Giai đoạn khởi tạo bao gồm thương lượng phiên bản, cho phép tương thích ngược khi giao thức phát triển. Bên cạnh đó, việc khám phá khả năng cho phép Client thích ứng với các tính năng cụ thể mà mỗi Server cung cấp, cho phép kết hợp cả Máy chủ cơ bản và nâng cao trong cùng một hệ sinh thái.

units/vi/unit1/gradio-mcp.mdx

@@ -1,188 +0,0 @@
-# Tích hợp Gradio với MCP
-
-Giờ chúng ta đã tìm hiểu các khái niệm cốt lõi của Giao Thức Ngữ Cảnh Mô Hình (MCP) và cách triển khai MCP Servers và Clients. Trong phần này, chúng ta sẽ làm mọi thứ dễ dàng hơn bằng cách sử dụng Gradio để tạo một MCP Server!
-
-<Tip>
-
-Gradio là thư viện Python nổi tiếng giúp tạo giao diện web tùy chỉnh nhanh chóng cho các mô hình học máy.
-
-</Tip>
-
-## Giới thiệu về Gradio
-
-Gradio cho phép các nhà phát triển tạo giao diện người dùng (UI) cho mô hình của họ chỉ với vài dòng mã Python. Thư viện này đặc biệt hữu ích cho:
-
-- Tạo demo và nguyên mẫu
-- Chia sẻ mô hình với người dùng không chuyên về kỹ thuật
-- Kiểm tra và gỡ lỗi hành vi của mô hình
-
-Với việc hỗ trợ thêm MCP, Gradio giờ đây cung cấp cách đơn giản để hiển thị các khả năng của mô hình AI thông qua giao thức MCP chuẩn hóa.
-
-Kết hợp Gradio với MCP cho phép bạn tạo cả giao diện thân thiện với con người và công cụ truy cập được bằng AI với mã tối thiểu. Điều tuyệt nhất là Gradio đã được cộng đồng AI sử dụng rộng rãi, vì vậy bạn có thể dùng nó để chia sẻ MCP Servers của mình với người khác.
-
-## Điều kiện tiên quyết
-
-Để sử dụng Gradio với hỗ trợ MCP, bạn cần cài đặt Gradio với phần mở rộng MCP:
-
-```bash
-pip install "gradio[mcp]"
-```
-
-Bạn cũng cần một ứng dụng LLM hỗ trợ gọi công cụ sử dụng giao thức MCP, như Cursor (được gọi là "MCP Hosts").
-
-## Tạo MCP Server với Gradio
-
-Hãy cùng xem qua ví dụ cơ bản về cách tạo MCP Server bằng Gradio:
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-import gradio as gr
-
-def letter_counter(word: str, letter: str) -> int:
-    """
-    Đếm số lần xuất hiện của một ký tự trong từ hoặc văn bản.
-
-    Args:
-        word (str): Văn bản đầu vào để tìm kiếm
-        letter (str): Ký tự cần tìm
-
-    Returns:
-        int: Số lần ký tự xuất hiện trong văn bản
-    """
-    word = word.lower()
-    letter = letter.lower()
-    count = word.count(letter)
-    return count
-
-# Tạo giao diện Gradio tiêu chuẩn
-demo = gr.Interface(
-    fn=letter_counter,
-    inputs=["textbox", "textbox"],
-    outputs="number",
-    title="Bộ đếm ký tự",
-    description="Nhập văn bản và một ký tự để đếm số lần ký tự đó xuất hiện trong văn bản."
-)
-
-# Khởi chạy cả giao diện web Gradio và MCP Server
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-</details>
-
-```python
-import gradio as gr
-
-def letter_counter(word: str, letter: str) -> int:
-    """
-    Count the number of occurrences of a letter in a word or text.
-
-    Args:
-        word (str): The input text to search through
-        letter (str): The letter to search for
-
-    Returns:
-        int: The number of times the letter appears in the text
-    """
-    word = word.lower()
-    letter = letter.lower()
-    count = word.count(letter)
-    return count
-
-# Create a standard Gradio interface
-demo = gr.Interface(
-    fn=letter_counter,
-    inputs=["textbox", "textbox"],
-    outputs="number",
-    title="Letter Counter",
-    description="Enter text and a letter to count how many times the letter appears in the text."
-)
-
-# Launch both the Gradio web interface and the MCP server
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-Với thiết lập này, hàm đếm ký tự của bạn giờ có thể truy cập qua:
-
-1. Giao diện web Gradio truyền thống cho tương tác trực tiếp của con người
-2. MCP Server có thể kết nối với các clients tương thích
-
-MCP server sẽ truy cập được tại:
-```
-http://your-server:port/gradio_api/mcp/sse
-```
-
-Ứng dụng trông như thế này:
-
-![Gradio MCP Server](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/7.png)
-
-## Cách thức hoạt động đằng sau hậu trường
-
-Khi bạn thiết lập `mcp_server=True` trong `launch()`, những điều sau sẽ xảy ra:
-
-1. Các hàm Gradio được tự động chuyển đổi thành MCP Tools
-2. Các thành phần đầu vào ánh xạ thành lược đồ tham số công cụ
-3. Các thành phần đầu xác định định dạng phản hồi
-4. Server Gradio giờ cũng lắng nghe các tin nhắn theo giao thức MCP
-5. JSON-RPC qua HTTP+SSE được thiết lập cho giao tiếp client-server
-
-## Tính năng chính của tích hợp Gradio <> MCP
-
-1. **Chuyển đổi công cụ**: Mỗi API endpoint trong ứng dụng Gradio của bạn sẽ tự động chuyển thành MCP tool với tên, mô tả và lược đồ đầu vào tương ứng. Để xem các công cụ và lược đồ, truy cập `http://your-server:port/gradio_api/mcp/schema` hoặc vào link "View API" ở footer ứng dụng Gradio, sau đó click vào "MCP".
-
-2. **Hỗ trợ biến môi trường**: Có hai cách để kích hoạt chức năng MCP server:
-- Dùng tham số `mcp_server` trong `launch()`:
-  ```python
-  demo.launch(mcp_server=True)
-  ```
-- Dùng biến môi trường:
-  ```bash
-  export GRADIO_MCP_SERVER=True
-  ```
-
-3. **Xử lý file**: Server tự động xử lý chuyển đổi dữ liệu file bao gồm:
-   - Chuyển đổi chuỗi mã hóa base64 thành dữ liệu file
-   - Xử lý file ảnh và trả về đúng định dạng
-   - Quản lý bộ nhớ file tạm
-
-   Chúng ta **nên** truyền ảnh/file đầu vào dưới dạng URL đầy đủ ("http://..." hoặc "https://...") vì MCP Client không phải lúc nào cũng xử lý đúng file local.
-
-4. **Server MCP được host trên 🤗 Spaces**: Bạn có thể publish ứng dụng Gradio miễn phí trên Hugging Face Spaces để có MCP server được host miễn phí. Đây là ví dụ một Space như vậy: https://huggingface.co/spaces/abidlabs/mcp-tools
-
-## Mẹo xử lý sự cố
-
-1. **Gợi ý kiểu và chuỗi tài liệu**: Đảm bảo bạn cung cấp gợi ý kiểu và chuỗi tài liệu hợp lệ cho hàm. Chuỗi tài liệu cần có khối "Args:" với các tham số được thụt lề.
-
-2. **Đầu vào dạng chuỗi**: Khi không chắc chắn, hãy chấp nhận đối số đầu vào dạng `str` và chuyển đổi sang kiểu mong muốn bên trong hàm.
-
-3. **Hỗ trợ SSE**: Một số MCP Host không hỗ trợ MCP Server dùng SSE. Trong trường hợp đó, bạn có thể dùng `mcp-remote`:
-   ```json
-   {
-     "mcpServers": {
-       "gradio": {
-         "command": "npx",
-         "args": [
-           "mcp-remote",
-           "http://your-server:port/gradio_api/mcp/sse"
-         ]
-       }
-     }
-   }
-   ```
-
-4. **Khởi động lại**: Nếu gặp vấn đề kết nối, hãy thử khởi động lại cả MCP Client và MCP Server.
-
-## Chia sẻ MCP Server của bạn
-
-Bạn có thể chia sẻ MCP Server bằng cách publish ứng dụng Gradio lên Hugging Face Spaces. Video dưới đây hướng dẫn cách tạo Hugging Face Space.
-
-<Youtube id="3bSVKNKb_PY" />
-
-Giờ bạn có thể chia sẻ MCP Server với người khác bằng cách chia sẻ Hugging Face Space của mình.
-
-## Kết luận
-
-Việc tích hợp Gradio với MCP mang đến điểm khởi đầu dễ tiếp cận vào hệ sinh thái MCP. Bằng cách tận dụng sự đơn giản của Gradio và thêm chuẩn hóa từ MCP, các bạn có thể nhanh chóng tạo cả giao diện thân thiện với người dùng lẫn công cụ truy cập được bằng AI với ít code nhất.
-
-Trong suốt khóa học này, chúng ta sẽ khám phá thêm nhiều cách triển khai MCP phức tạp hơn, nhưng Gradio vẫn là điểm khởi đầu tuyệt vời để hiểu và thử nghiệm với giao thức

units/vi/unit1/introduction.mdx

@@ -1,33 +0,0 @@
-# Giới thiệu về Giao Thức Ngữ Cảnh Mô Hình (MCP)
-
-Chào mừng các bạn đến với Chương 1 của Khóa học MCP! Trong chương này, chúng ta sẽ cùng khám phá những nguyên tắc cơ bản của Giao Thức Ngữ Cảnh Mô Hình.
-
-## Những gì bạn sẽ học
-
-Trong chương này, các bạn sẽ:
-
-* Hiểu MCP là gì và tại sao nó quan trọng
-* Nắm được các khái niệm chính và thuật ngữ liên quan đến MCP
-* Khám phá những thách thức tích hợp mà MCP giải quyết
-* Tìm hiểu các lợi ích và mục tiêu chính của MCP
-* Xem ví dụ đơn giản về tích hợp MCP trong thực tế
-
-Khi kết thúc chương này, các bạn sẽ nắm vững những khái niệm nền tảng về MCP và sẵn sàng đi sâu vào kiến trúc và cách triển khai ở chương tiếp theo.
-
-## Tầm quan trọng của MCP
-
-Hệ sinh thái AI đang phát triển nhanh chóng với các Mô hình Ngôn ngữ Lớn (LLMs) và hệ thống AI khác ngày càng mạnh mẽ. Tuy nhiên, các mô hình này thường bị giới hạn bởi dữ liệu huấn luyện và thiếu khả năng truy cập thông tin thời gian thực hay các công cụ chuyên biệt. Hạn chế này cản trở tiềm năng của hệ thống AI trong việc đưa ra phản hồi thực sự phù hợp, chính xác và hữu ích.
-
-Đây chính là lúc Giao Thức Ngữ Cảnh Mô Hình (MCP) phát huy tác dụng. MCP cho phép các mô hình AI kết nối với nguồn dữ liệu bên ngoài, công cụ và môi trường, tạo điều kiện trao đổi thông tin liền mạch giữa hệ thống AI và thế giới số. Khả năng tương tác này rất quan trọng cho sự phát triển và ứng dụng rộng rãi của các ứng dụng AI thực sự hữu ích.
-
-## Tổng quan Chương 1
-
-Dưới đây là những nội dung chính chúng ta sẽ đề cập:
-
-1. **MCP là gì?** - Bắt đầu với định nghĩa về MCP và vai trò của nó trong hệ sinh thái AI
-2. **Khái niệm chính** - Khám phá những khái niệm nền tảng và thuật ngữ liên quan
-3. **Thách thức tích hợp** - Phân tích các vấn đề MCP hướng tới giải quyết, đặc biệt là "Bài toán tích hợp M×N"
-4. **Lợi ích và mục tiêu** - Thảo luận về các ưu điểm và mục đích chính của MCP như chuẩn hóa, nâng cao khả năng AI và khả năng tương tác
-5. **Ví dụ đơn giản** - Cùng xem qua ví dụ thực tế về tích hợp MCP
-
-Hãy cùng bắt đầu hành trình khám phá thế giới thú vị của Giao Thức Ngữ Cảnh Mô Hình!

units/vi/unit1/key-concepts.mdx

@@ -1,88 +0,0 @@
-# Các Khái Niệm và Thuật Ngữ Chính
-
-Trước khi đi sâu vào Giao Thức Ngữ Cảnh Mô Hình (MCP), chúng ta cần hiểu các khái niệm và thuật ngữ then chốt tạo nền tảng cho MCP. Chương này sẽ giới thiệu những ý tưởng cốt lõi cùng bộ từ vựng chung để thảo luận về các triển khai MCP xuyên suốt khóa học.
-
-MCP thường được ví như "USB-C cho các ứng dụng AI". Giống như USB-C cung cấp giao diện vật lý và logic chuẩn hóa để kết nối các thiết bị ngoại vi với máy tính, MCP đưa ra giao thức đồng nhất để liên kết các mô hình AI với khả năng mở rộng. Sự chuẩn hóa này mang lợi ích cho toàn bộ hệ sinh thái:
-
-- **Người dùng** được trải nghiệm đơn giản và nhất quán hơn trên mọi ứng dụng AI
-- **Nhà phát triển ứng dụng AI** dễ dàng tích hợp với hệ sinh thái công cụ và nguồn dữ liệu ngày càng phong phú
-- **Nhà cung cấp công cụ/dữ liệu** chỉ cần xây dựng một triển khai duy nhất tương thích với nhiều ứng dụng AI
-- **Toàn hệ sinh thái** hưởng lợi từ khả năng tương tác cao hơn, đổi mới mạnh mẽ hơn và giảm phân mảnh
-
-## Bài Toán Tích Hợp
-
-**Bài Toán Tích Hợp M×N** ám chỉ thách thức khi kết nối M ứng dụng AI khác nhau với N công cụ/nguồn dữ liệu ngoài mà không có phương pháp chuẩn hóa.
-
-### Không có MCP (Bài Toán M×N)
-
-Không có giao thức như MCP, nhà phát triển phải tạo M×N tích hợp tùy biến - mỗi tích hợp cho một cặp ứng dụng AI với khả năng mở rộng.
-
-![Without MCP](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/1.png)
-
-Mỗi ứng dụng AI cần tích hợp riêng lẻ với từng công cụ/nguồn dữ liệu. Quá trình này rất phức tạp, tốn kém và gây nhiều khó khăn cho nhà phát triển, đồng thời làm tăng chi phí bảo trì.
-
-### Với MCP (Giải Pháp M+N)
-
-MCP biến bài toán này thành M+N bằng cách cung cấp giao diện chuẩn: mỗi ứng dụng AI triển khai phía Máy khách MCP một lần, mỗi công cụ/nguồn dữ liệu triển khai phía Máy chủ một lần. Cách này giảm đáng kể độ phức tạp tích hợp và gánh nặng bảo trì.
-
-![With MCP](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/2.png)
-
-Mỗi ứng dụng AI triển khai phía Máy khách MCP một lần, mỗi công cụ/nguồn dữ liệu triển khai phía Máy chủ một lần.
-
-## Thuật ngữ cốt lõi trong MCP
-
-Giờ chúng ta đã hiểu vấn đề mà MCP giải quyết, hãy cùng khám phá các thuật ngữ và khái niệm cốt lõi tạo nên giao thức MCP.
-
-<Tip>
-
-MCP là một chuẩn như HTTP hay USB-C, và là giao thức để kết nối các ứng dụng AI với công cụ và nguồn dữ liệu bên ngoài. Vì vậy, việc sử dụng thuật ngữ chuẩn là cực kỳ quan trọng để MCP hoạt động hiệu quả.
-
-Khi viết tài liệu ứng dụng và trao đổi với cộng đồng, chúng ta nên sử dụng các thuật ngữ sau đây.
-
-</Tip>
-
-### Thành phần
-
-Tương tự như mối quan hệ client-server trong HTTP, MCP có client (máy khách) và server (máy chủ).
-
-![MCP Components](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/3.png)
-
-- **Host**: Ứng dụng AI mà người dùng cuối tương tác trực tiếp. Ví dụ: Claude Desktop của Anthropic, các IDE tích hợp AI như Cursor, thư viện inference như Hugging Face Python SDK, hoặc ứng dụng tùy chỉnh xây dựng bằng thư viện như LangChain hay smolagents. Host khởi tạo kết nối đến Máy chủ MCP và điều phối luồng làm việc giữa yêu cầu người dùng, xử lý LLM và công cụ bên ngoài.
-
-- **Client**: Thành phần trong ứng dụng Host quản lý giao tiếp với một MCP Server cụ thể. Mỗi Client duy trì kết nối 1:1 với một Server, xử lý các chi tiết giao thức của MCP và đóng vai trò trung gian giữa logic của Host và Server bên ngoài.
-
-- **Server**: Chương trình hoặc dịch vụ bên ngoài cung cấp các khả năng (Tools, Resources, Prompts) thông qua giao thức MCP.
-
-<Tip warning={true}>
-
-Nhiều tài liệu sử dụng 'Client' và 'Host' thay thế cho nhau. Về mặt kỹ thuật, Host là ứng dụng hướng đến người dùng, còn Client là thành phần bên trong ứng dụng Host quản lý giao tiếp với MCP Server.
-
-</Tip>
-
-### Khả năng
-
-Tất nhiên, giá trị ứng dụng của bạn được quyết định bởi tổng các khả năng mà nó cung cấp. Các khả năng là phần quan trọng nhất trong ứng dụng. MCP có thể kết nối với mọi dịch vụ phần mềm, nhưng có một số khả năng phổ biến được dùng cho nhiều ứng dụng AI.
-
-| Khả năng     | Mô tả         | Ví dụ         |
-| ------------ | ------------- | ------------- |
-| **Tools**    | Các hàm có thể thực thi mà mô hình AI có thể gọi để thực hiện hành động hoặc truy xuất dữ liệu đã tính toán. Thường liên quan đến use case của ứng dụng. | Một tool cho ứng dụng thời tiết có thể là hàm trả về thời tiết ở địa điểm cụ thể. |
-| **Resources** | Nguồn dữ liệu chỉ đọc cung cấp ngữ cảnh mà không cần tính toán phức tạp. | Trợ lý nghiên cứu có thể có nguồn về các bài báo khoa học. |
-| **Prompts**   | Các mẫu hoặc quy trình làm việc được định nghĩa sẵn để hướng dẫn tương tác giữa người dùng, mô hình AI và các khả năng có sẵn. | Prompt tóm tắt văn bản. |
-| **Sampling**  | Các yêu cầu do Máy chủ khởi tạo để Client/Host thực hiện tương tác LLM, cho phép hành động đệ quy nơi LLM có thể xem xét nội dung đã tạo và đưa ra quyết định tiếp theo. | Ứng dụng viết lách tự đánh giá output và quyết định cải thiện thêm. |
-
-Trong sơ đồ sau, chúng ta có thể thấy các khả năng được áp dụng cho use case của một CodeAgent.
-
-![collective diagram](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/8.png)
-
-Ứng dụng này có thể sử dụng các thực thể MCP theo cách sau:
-
-| Thực thể | Tên            | Mô tả                     |
-| -------- | -------------- | ------------------------- |
-| Tool     | Code Interpreter | Công cụ có thể thực thi mã mà LLM viết. |
-| Resource | Documentation  | Tài nguyên chứa tài liệu hướng dẫn của ứng dụng. |
-| Prompt   | Code Style     | Prompt hướng dẫn LLM tạo mã. |
-| Sampling | Code Review    | Sampling cho phép LLM review mã và đưa ra quyết định tiếp theo.|
-
-### Kết luận
-
-Hiểu rõ những khái niệm và thuật ngữ chính này sẽ tạo nền tảng để làm việc hiệu quả với MCP (Giao Thức Ngữ Cảnh Mô Hình). Trong các phần tiếp theo, chúng ta sẽ xây dựng dựa trên nền tảng này để khám phá các thành phần kiến trúc, giao thức truyền thông và tính năng tạo nên Giao Thức Ngữ Cảnh Mô Hình.

units/vi/unit1/mcp-clients.mdx

@@ -1,422 +0,0 @@
-# MCP Clients
-
-Giờ khi đã hiểu cơ bản về Giao Thức Ngữ Cảnh Mô Hình (MCP), chúng ta có thể khám phá vai trò quan trọng của Client MCP trong hệ sinh thái MCP.
-
-Trong phần này của Chương 1, chúng ta sẽ khám phá vai trò thiết yếu của Client MCP trong hệ sinh thái MCP.
-
-Trong phần này, các bạn sẽ:
-
-* Hiểu Client MCP là gì và vai trò của chúng trong kiến trúc MCP
-* Tìm hiểu về các trách nhiệm chính của Client MCP
-* Khám phá các triển khai Client MCP chính
-* Khám phá cách sử dụng triển khai Client MCP của Hugging Face
-* Xem các ví dụ thực tế về cách sử dụng Client MCP
-
-## Hiểu về Client MCP
-
-Client MCP là thành phần quan trọng đóng vai trò cầu nối giữa các ứng dụng AI (Server) và các khả năng bên ngoài được cung cấp bởi Server MCP. Hãy hình dung Server như ứng dụng chính của bạn (ví dụ: trợ lý AI hoặc IDE) và Client như một mô-đun chuyên biệt trong Server đó chịu trách nhiệm xử lý các giao tiếp MCP.
-
-## Client giao diện người dùng
-
-Hãy bắt đầu bằng cách khám phá các Client giao diện người dùng có sẵn cho MCP.
-
-### Client giao diện chat
-
-Claude Desktop của Anthropic là một trong những Client MCP nổi bật nhất, cung cấp tích hợp với nhiều Server MCP khác nhau.
-
-### Client phát triển tương tác
-
-Triển khai Client MCP của Cursor cho phép trợ lý lập trình hỗ trợ AI thông qua tích hợp trực tiếp với các tính năng chỉnh sửa code. Nó hỗ trợ nhiều kết nối Server MCP và cung cấp khả năng gọi công cụ thời gian thực khi lập trình, biến nó thành công cụ mạnh mẽ cho các nhà phát triển.
-
-Continue.dev là một ví dụ khác về Client phát triển tương tác hỗ trợ MCP và kết nối với Server MCP từ VS Code.
-
-## Cấu hình Client MCP
-
-Giờ khi đã nắm được phần cốt lõi của giao thức MCP, hãy xem cách cấu hình các Server và Client MCP của bạn.
-
-Triển khai hiệu quả các Server và Client MCP yêu cầu cấu hình đúng cách.
-
-<Tip>
-
-Đặc tả MCP vẫn đang phát triển, vì vậy các phương pháp cấu hình có thể thay đổi. Chúng ta sẽ tập trung vào các phương pháp tốt nhất hiện tại để cấu hình.
-
-</Tip>
-
-### Tệp cấu hình MCP
-
-Các Server MCP sử dụng các tệp cấu hình để quản lý kết nối với Server. Những tệp này xác định các Server nào có sẵn và cách kết nối với chúng.
-
-May mắn là các tệp cấu hình rất đơn giản, dễ hiểu và thống nhất giữa các Server MCP chính.
-
-#### Cấu trúc `mcp.json`
-
-Tệp cấu hình tiêu chuẩn cho MCP có tên `mcp.json`. Đây là cấu trúc cơ bản:
-
-```json
-{
-  "servers": [
-    {
-      "name": "Server Name",
-      "transport": {
-        "type": "stdio|sse",
-        // Cấu hình cụ thể cho phương thức truyền tải
-      }
-    }
-  ]
-}
-```
-
-Trong ví dụ này, chúng ta có một Server duy nhất với tên và loại phương thức truyền tải. Loại phương thức truyền tải có thể là `stdio` hoặc `sse`.
-
-#### Cấu hình cho phương thức truyền tải stdio
-
-Đối với các Server cục bộ sử dụng phương thức truyền tải stdio, cấu hình bao gồm lệnh và các đối số để khởi chạy tiến trình Server:
-
-```json
-{
-  "servers": [
-    {
-      "name": "File Explorer",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/file_explorer_server.py"]
-      }
-    }
-  ]
-}
-```
-
-Ở đây, chúng ta có một Server có tên "File Explorer" là một tập lệnh cục bộ.
-
-#### Cấu hình cho phương thức truyền tải HTTP+SSE
-
-Đối với các Server từ xa sử dụng phương thức truyền tải HTTP+SSE, cấu hình bao gồm URL của Server:
-
-```json
-{
-  "servers": [
-    {
-      "name": "Remote API Server",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/mcp-server"
-      }
-    }
-  ]
-}
-```
-
-#### Biến môi trường trong cấu hình
-
-Các biến môi trường có thể được truyền vào tiến trình Server bằng cách sử dụng trường `env`. Đây là cách truy cập chúng trong mã Server của bạn:
-
-<hfoptions id="env-variables">
-<hfoption id="python">
-
-Trong Python, chúng ta sử dụng module `os` để truy cập các biến môi trường:
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```
-import os
-
-# Truy cập các biến môi trường
-github_token = os.environ.get("GITHUB_TOKEN")
-if not github_token:
-    raise ValueError("GITHUB_TOKEN environment variable is required")
-
-# Sử dụng token trong mã Server
-def make_github_request():
-    headers = {"Authorization": f"Bearer {github_token}"}
-    # ... phần còn lại của mã
-```
-</details>
-```
-import os
-
-# Access environment variables
-github_token = os.environ.get("GITHUB_TOKEN")
-if not github_token:
-    raise ValueError("GITHUB_TOKEN environment variable is required")
-
-# Use the token in your server code
-def make_github_request():
-    headers = {"Authorization": f"Bearer {github_token}"}
-    # ... rest of your code
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-Trong JavaScript, chúng ta sử dụng object `process.env` để truy cập các biến môi trường:
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```
-// Truy cập các biến môi trường
-const githubToken = process.env.GITHUB_TOKEN;
-if (!githubToken) {
-    throw new Error("GITHUB_TOKEN environment variable is required");
-}
-
-// Sử dụng token trong mã Server
-function makeGithubRequest() {
-    const headers = { "Authorization": `Bearer ${githubToken}` };
-    // ... phần còn lại của mã
-}
-```
-</details>
-```
-// Access environment variables
-const githubToken = process.env.GITHUB_TOKEN;
-if (!githubToken) {
-    throw new Error("GITHUB_TOKEN environment variable is required");
-}
-
-// Use the token in your server code
-function makeGithubRequest() {
-    const headers = { "Authorization": `Bearer ${githubToken}` };
-    // ... rest of your code
-}
-```
-
-</hfoption>
-</hfoptions>
-
-Cấu hình tương ứng trong `mcp.json` sẽ trông như thế này:
-
-```json
-{
-  "servers": [
-    {
-      "name": "GitHub API",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/github_server.py"],
-        "env": {
-          "GITHUB_TOKEN": "your_github_token"
-        }
-      }
-    }
-  ]
-}
-```
-
-### Ví dụ về Cấu hình
-
-Hãy cùng xem qua một số kịch bản cấu hình trong thực tế:
-
-#### Kịch bản 1: Cấu hình Server Cục bộ
-
-Trong kịch bản này, chúng ta có một Server cục bộ là script Python có thể là trình khám phá file hoặc trình chỉnh sửa code.
-
-```json
-{
-  "servers": [
-    {
-      "name": "File Explorer",
-      "transport": {
-        "type": "stdio",
-        "command": "python",
-        "args": ["/path/to/file_explorer_server.py"]
-      }
-    }
-  ]
-}
-```
-
-#### Kịch bản 2: Cấu hình Server Từ xa
-
-Trong kịch bản này, chúng ta có một Server từ xa là API thời tiết.
-
-```json
-{
-  "servers": [
-    {
-      "name": "Weather API",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/mcp-server"
-      }
-    }
-  ]
-}
-```
-
-Việc cấu hình đúng cách là yếu tố thiết yếu để triển khai thành công các tích hợp MCP. Bằng cách hiểu rõ các khía cạnh này, các bạn có thể tạo ra các kết nối mạnh mẽ và đáng tin cậy giữa các ứng dụng AI và các khả năng bên ngoài.
-
-Trong phần tiếp theo, chúng ta sẽ khám phá hệ sinh thái các Server MCP có sẵn trên Hugging Face Hub và cách xuất bản Server của riêng bạn tại đó.
-
-## Code Clients
-
-Bạn cũng có thể sử dụng MCP Client trong code để các công cụ có sẵn cho LLM. Hãy cùng khám phá một số ví dụ trong `smolagents`.
-
-Đầu tiên, hãy xem qua Server thời tiết từ trang trước. Trong `smolagents`, chúng ta có thể sử dụng lớp `ToolCollection` để tự động phát hiện và đăng ký các công cụ từ Server MCP. Việc này được thực hiện bằng cách truyền `StdioServerParameters` hoặc `SSEServerParameters` vào phương thức `ToolCollection.from_mcp`. Sau đó chúng ta có thể in các công cụ ra console.
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-from smolagents import ToolCollection, CodeAgent
-from mcp.client.stdio import StdioServerParameters
-
-server_parameters = StdioServerParameters(command="uv", args=["run", "server.py"])
-
-with ToolCollection.from_mcp(
-    server_parameters, trust_remote_code=True
-) as tools:
-    print("\n".join(f"{t.name}: {t.description}" for t in tools))
-```
-</details>
-```python
-from smolagents import ToolCollection, CodeAgent
-from mcp.client.stdio import StdioServerParameters
-
-server_parameters = StdioServerParameters(command="uv", args=["run", "server.py"])
-
-with ToolCollection.from_mcp(
-    server_parameters, trust_remote_code=True
-) as tools:
-    print("\n".join(f"{t.name}: {t.description}" for t in tools))
-
-```
-
-<details>
-<summary>
-Kết quả
-</summary>
-
-```sh
-Weather API: Get the weather in a specific location
-
-```
-
-</details>
-
-Chúng ta cũng có thể kết nối đến Server MCP được host trên máy từ xa. Trong trường hợp này, chúng ta cần truyền `SSEServerParameters` vào phương thức `ToolCollection.from_mcp`.
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-from smolagents.mcp_client import MCPClient
-
-with MCPClient(
-    {"url": "https://abidlabs-mcp-tools2.hf.space/gradio_api/mcp/sse"}
-) as tools:
-    # Tools from the remote server are available
-    print("\n".join(f"{t.name}: {t.description}" for t in tools))
-```
-</details>
-```python
-from smolagents.mcp_client import MCPClient
-
-with MCPClient(
-    {"url": "https://abidlabs-mcp-tools2.hf.space/gradio_api/mcp/sse"}
-) as tools:
-    # Tools from the remote server are available
-    print("\n".join(f"{t.name}: {t.description}" for t in tools))
-```
-
-<details>
-<summary>
-Kết quả
-</summary>
-
-```sh
-prime_factors: Compute the prime factorization of a positive integer.
-generate_cheetah_image: Generate a cheetah image.
-image_orientation: Returns whether image is portrait or landscape.
-sepia: Apply a sepia filter to the input image.
-```
-
-</details>
-
-Bây giờ hãy xem cách sử dụng MCP Client trong một code agent.
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-from smolagents import ToolCollection, CodeAgent
-from mcp.client.stdio import StdioServerParameters
-from smolagents import CodeAgent, InferenceClientModel
-
-model = InferenceClientModel()
-
-server_parameters = StdioServerParameters(command="uv", args=["run", "server.py"])
-
-with ToolCollection.from_mcp(
-    server_parameters, trust_remote_code=True
-) as tool_collection:
-    agent = CodeAgent(tools=[*tool_collection.tools], model=model)
-    agent.run("What's the weather in Tokyo?")
-```
-</details>
-```python
-from smolagents import ToolCollection, CodeAgent
-from mcp.client.stdio import StdioServerParameters
-from smolagents import CodeAgent, InferenceClientModel
-
-model = InferenceClientModel()
-
-server_parameters = StdioServerParameters(command="uv", args=["run", "server.py"])
-
-with ToolCollection.from_mcp(
-    server_parameters, trust_remote_code=True
-) as tool_collection:
-    agent = CodeAgent(tools=[*tool_collection.tools], model=model)
-    agent.run("What's the weather in Tokyo?")
-
-```
-
-<details>
-<summary>
-Kết quả
-</summary>
-
-```sh
-The weather in Tokyo is sunny with a temperature of 20 degrees Celsius.
-```
-
-</details>
-
-Chúng ta cũng có thể kết nối đến các gói MCP. Đây là ví dụ về cách kết nối đến gói `pubmedmcp`.
-
-```python
-from smolagents import ToolCollection, CodeAgent
-from mcp import StdioServerParameters
-
-server_parameters = StdioServerParameters(
-    command="uv",
-    args=["--quiet", "pubmedmcp@0.1.3"],
-    env={"UV_PYTHON": "3.12", **os.environ},
-)
-
-with ToolCollection.from_mcp(server_parameters, trust_remote_code=True) as tool_collection:
-    agent = CodeAgent(tools=[*tool_collection.tools], add_base_tools=True)
-    agent.run("Please find a remedy for hangover.")
-```
-
-<details>
-<summary>Kết quả</summary>
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```sh
-Phương pháp chữa nôn nao là uống nước.
-```
-</details>
-```sh
-The remedy for hangover is to drink water.
-```
-
-</details>
-
-## Bước tiếp theo
-
-Giờ bạn đã hiểu về MCP Client, hãy sẵn sàng để:
-* Khám phá các triển khai MCP Server cụ thể
-* Tìm hiểu về cách tạo MCP Client tùy chỉnh
-* Đi sâu vào các mẫu tích hợp MCP nâng cao
-
-Hãy tiếp tục hành trình của chúng ta vào thế giới của Giao Thức Ngữ Cảnh Mô Hình!

units/vi/unit1/sdk.mdx

@@ -1,279 +0,0 @@
-# MCP SDK
-
-Giao Thức Ngữ Cảnh Mô Hình (MCP) cung cấp SDK chính thức cho cả JavaScript, Python và các ngôn ngữ khác. Điều này giúp việc triển khai Client và Server MCP trong ứng dụng của bạn trở nên dễ dàng. Các SDK này xử lý các chi tiết giao thức cấp thấp, cho phép bạn tập trung vào việc xây dựng chức năng ứng dụng.
-
-## Tổng quan về SDK
-
-Cả hai SDK đều cung cấp chức năng cốt lõi tương tự, tuân theo đặc tả giao thức MCP mà chúng ta đã thảo luận trước đó. Chúng xử lý:
-
-- Giao tiếp ở cấp độ giao thức
-- Đăng ký và khám phá tính năng
-- Tuần tự hóa/giải tuần tự hóa tin nhắn
-- Quản lý kết nối
-- Xử lý lỗi
-
-## Triển khai các thành phần cốt lõi
-
-Hãy cùng khám phá cách triển khai từng thành phần cốt lõi (Tools, Resources, và Prompts) bằng cả hai SDK.
-
-<hfoptions id="server-implementation">
-<hfoption id="python">
-
-<Youtube id="exzrb5QNUis" />
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-from mcp.server.fastmcp import FastMCP
-
-# Tạo Server MCP
-mcp = FastMCP("Dịch vụ Thời tiết")
-
-
-@mcp.tool()
-def get_weather(location: str) -> str:
-    """Nhận thông tin thời tiết hiện tại ở một địa điểm cụ thể."""
-    return f"Weather in {location}: Sunny, 72°F"
-
-
-@mcp.resource("weather://{location}")
-def weather_resource(location: str) -> str:
-    """Cung cấp dữ liệu thời tiết dưới dạng tài nguyên."""
-    return f"Weather data for {location}: Sunny, 72°F"
-
-
-@mcp.prompt()
-def weather_report(location: str) -> str:
-    """Tạo lời nhắc báo cáo thời tiết."""
-    return f"""You are a weather reporter. Weather report for {location}?"""
-
-
-# Chạy Server
-if __name__ == "__main__":
-    mcp.run()
-```
-</details>
-
-```python
-from mcp.server.fastmcp import FastMCP
-
-# Create an MCP server
-mcp = FastMCP("Weather Service")
-
-
-@mcp.tool()
-def get_weather(location: str) -> str:
-    """Get the current weather for a specified location."""
-    return f"Weather in {location}: Sunny, 72°F"
-
-
-@mcp.resource("weather://{location}")
-def weather_resource(location: str) -> str:
-    """Provide weather data as a resource."""
-    return f"Weather data for {location}: Sunny, 72°F"
-
-
-@mcp.prompt()
-def weather_report(location: str) -> str:
-    """Create a weather report prompt."""
-    return f"""You are a weather reporter. Weather report for {location}?"""
-
-
-# Run the server
-if __name__ == "__main__":
-    mcp.run()
-
-```
-
-</hfoption>
-<hfoption id="javascript">
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```javascript
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// Tạo Server MCP
-const server = new McpServer({
-    name: "Dịch vụ Thời tiết",
-    version: "1.0.0"
-});
-
-// Triển khai công cụ
-server.tool("get_weather",
-    { location: z.string() },
-    async ({ location }) => ({
-        content: [{
-            type: "text",
-            text: `Weather in ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Triển khai tài nguyên
-server.resource(
-    "weather",
-    new ResourceTemplate("weather://{location}", { list: undefined }),
-    async (uri, { location }) => ({
-        contents: [{
-            uri: uri.href,
-            text: `Weather data for ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Triển khai prompt
-server.prompt(
-    "weather_report",
-    { location: z.string() },
-    async ({ location }) => ({
-        messages: [
-            {
-                role: "assistant",
-                content: {
-                    type: "text",
-                    text: "You are a weather reporter."
-                }
-            },
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Weather report for ${location}?`
-                }
-            }
-        ]
-    })
-);
-
-// Chạy server
-const transport = new StdioServerTransport();
-await server.connect(transport);
-```
-</details>
-
-```javascript
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-// Create an MCP server
-const server = new McpServer({
-    name: "Weather Service",
-    version: "1.0.0"
-});
-
-// Tool implementation
-server.tool("get_weather",
-    { location: z.string() },
-    async ({ location }) => ({
-        content: [{
-            type: "text",
-            text: `Weather in ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Resource implementation
-server.resource(
-    "weather",
-    new ResourceTemplate("weather://{location}", { list: undefined }),
-    async (uri, { location }) => ({
-        contents: [{
-            uri: uri.href,
-            text: `Weather data for ${location}: Sunny, 72°F`
-        }]
-    })
-);
-
-// Prompt implementation
-server.prompt(
-    "weather_report",
-    { location: z.string() },
-    async ({ location }) => ({
-        messages: [
-            {
-                role: "assistant",
-                content: {
-                    type: "text",
-                    text: "You are a weather reporter."
-                }
-            },
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Weather report for ${location}?`
-                }
-            }
-        ]
-    })
-);
-
-// Run the server
-const transport = new StdioServerTransport();
-await server.connect(transport);
-```
-
-</hfoption>
-</hfoptions>
-
-Sau khi đã triển khai máy chủ của mình, bạn có thể khởi chạy nó bằng cách chạy script server.
-
-```bash
-mcp dev server.py
-```
-
-Lệnh này sẽ khởi tạo một máy chủ phát triển chạy file `server.py` và ghi lại output sau:
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```
-Starting MCP inspector...
-⚙️ Proxy server listening on port 6277
-Spawned stdio transport
-Connected MCP client to backing server transport
-Created web app transport
-Set up MCP proxy
-🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀
-```
-</details>
-```bash
-Starting MCP inspector...
-⚙️ Proxy server listening on port 6277
-Spawned stdio transport
-Connected MCP client to backing server transport
-Created web app transport
-Set up MCP proxy
-🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀
-```
-
-Bạn có thể mở MCP Inspector tại [http://127.0.0.1:6274](http://127.0.0.1:6274) để xem các tính năng của máy chủ và tương tác với chúng.
-
-Bạn sẽ thấy các tính năng của máy chủ và khả năng gọi chúng thông qua giao diện người dùng.
-
-![MCP Inspector](https://huggingface.co/datasets/mcp-course/images/resolve/main/unit1/6.png)
-
-## Bộ SDK MCP
-
-MCP được thiết kế để độc lập với ngôn ngữ lập trình, và hiện có các SDK chính thức cho nhiều ngôn ngữ phổ biến:
-
-| Ngôn ngữ | Kho lưu trữ | Người bảo trì | Trạng thái |
-|----------|------------|---------------|--------|
-| TypeScript | [github.com/modelcontextprotocol/typescript-sdk](https://github.com/modelcontextprotocol/typescript-sdk) | Anthropic | Hoạt động |
-| Python | [github.com/modelcontextprotocol/python-sdk](https://github.com/modelcontextprotocol/python-sdk) | Anthropic | Hoạt động |
-| Java | [github.com/modelcontextprotocol/java-sdk](https://github.com/modelcontextprotocol/java-sdk) | Spring AI (VMware) | Hoạt động |
-| Kotlin | [github.com/modelcontextprotocol/kotlin-sdk](https://github.com/modelcontextprotocol/kotlin-sdk) | JetBrains | Hoạt động |
-| C# | [github.com/modelcontextprotocol/csharp-sdk](https://github.com/modelcontextprotocol/csharp-sdk) | Microsoft | Hoạt động (Xem trước) |
-| Swift | [github.com/modelcontextprotocol/swift-sdk](https://github.com/modelcontextprotocol/swift-sdk) | loopwork-ai | Hoạt động |
-| Rust | [github.com/modelcontextprotocol/rust-sdk](https://github.com/modelcontextprotocol/rust-sdk) | Anthropic/Cộng đồng | Hoạt động |
-
-Các SDK này cung cấp các abstraction đặc thù cho từng ngôn ngữ, giúp đơn giản hóa việc làm việc với giao thức MCP, cho phép bạn tập trung vào việc triển khai logic cốt lõi của máy chủ hoặc máy khách thay vì xử lý các chi tiết giao thức cấp thấp.
-
-## Bước tiếp theo
-
-Chúng ta mới chỉ chạm vào bề mặt của những gì có thể làm với MCP nhưng bạn đã có một máy chủ cơ bản đang chạy. Thực tế, bạn cũng đã kết nối với nó bằng MCP Client trên trình duyệt.
-
-Trong phần tiếp theo, chúng ta sẽ xem cách kết nối với máy chủ từ một LLM.

units/vi/unit2/clients.mdx

@@ -1,79 +0,0 @@
-# Xây dựng MCP Clients
-
-Trong phần này, chúng ta sẽ tạo các client có thể tương tác với MCP server bằng các ngôn ngữ lập trình khác nhau. Chúng ta sẽ triển khai cả client JavaScript sử dụng HuggingFace.js và client Python sử dụng smolagents.
-
-## Cấu hình MCP Clients
-
-Việc triển khai hiệu quả MCP servers và clients yêu cầu cấu hình phù hợp. Đặc tả MCP vẫn đang phát triển, vì vậy các phương pháp cấu hình có thể thay đổi. Chúng ta sẽ tập trung vào các best practice hiện tại về cấu hình.
-
-### Cấu hình Files của MCP
-
-Các MCP hosts sử dụng configuration files để quản lý kết nối server. Những files này xác định các servers nào có sẵn và cách kết nối đến chúng.
-
-Các configuration files rất đơn giản, dễ hiểu và thống nhất giữa các MCP hosts chính.
-
-#### Cấu trúc `mcp.json`
-
-File cấu hình chuẩn cho MCP có tên `mcp.json`. Đây là cấu trúc cơ bản:
-
-```json
-{
-  "servers": [
-    {
-      "name": "MCP Server",
-      "transport": {
-        "type": "sse",
-        "url": "http://localhost:7860/gradio_api/mcp/sse"
-      }
-    }
-  ]
-}
-```
-
-Trong ví dụ này, chúng ta có một server được cấu hình sử dụng SSE transport, kết nối đến Gradio server local chạy trên cổng 7860.
-
-<Tip>
-
-Chúng ta đã kết nối đến ứng dụng Gradio qua giao thức SSE vì giả định rằng ứng dụng gradio đang chạy trên một Server từ xa. Tuy nhiên nếu bạn muốn kết nối đến script local, `stdio` transport thay vì `sse` transport là lựa chọn tốt hơn.
-
-</Tip>
-
-#### Cấu hình cho HTTP+SSE Transport
-
-Với các servers từ xa sử dụng HTTP+SSE transport, cấu hình bao gồm URL của server:
-
-```json
-{
-  "servers": [
-    {
-      "name": "Remote MCP Server",
-      "transport": {
-        "type": "sse",
-        "url": "https://example.com/gradio_api/mcp/sse"
-      }
-    }
-  ]
-}
-```
-
-Cấu hình này cho phép UI client của bạn giao tiếp với Gradio MCP server sử dụng MCP protocol, giúp tích hợp liền mạch giữa frontend và dịch vụ MCP.
-
-## Cấu hình UI MCP Client
-
-Khi làm việc với Gradio MCP servers, bạn có thể cấu hình UI client để kết nối đến server sử dụng MCP protocol. Cách thiết lập như sau:
-
-### Cấu hình cơ bản
-
-Tạo file mới tên `config.json` với cấu hình sau:
-
-```json
-{
-  "mcpServers": {
-    "mcp": {
-      "url": "http://localhost:7860/gradio_api/mcp/sse"
-    }
-  }
-}
-```
-
-Cấu hình này cho phép UI client của bạn giao tiếp với Gradio MCP server sử dụng MCP protocol, giúp tích hợp liền mạch giữa frontend và dịch vụ MCP.

units/vi/unit2/gradio-client.mdx

@@ -1,144 +0,0 @@
-# Gradio với vai trò Máy khách MCP
-
-Ở chương trước, chúng ta đã tìm hiểu cách tạo MCP Server bằng Gradio và kết nối đến nó bằng một MCP Client. Trong chương này, chúng ta sẽ khám phá cách sử dụng Gradio như một MCP Client để kết nối đến MCP Server.
-
-<Tip>
-
-Gradio phù hợp nhất để tạo UI client và MCP server, nhưng cũng có thể dùng nó như MCP Client và hiển thị dưới dạng UI.
-
-</Tip>
-
-Chúng ta sẽ kết nối đến MCP server đã tạo ở chương trước và dùng nó để trả lời câu hỏi.
-
-## MCP Client trong Gradio
-
-Đầu tiên, cần cài đặt các thư viện `smolagents`, gradio và mcp-client nếu chưa có:
-
-```bash
-pip install smolagents[mcp] gradio[mcp] mcp
-```
-
-Giờ chúng ta có thể import các thư viện cần thiết và tạo giao diện Gradio đơn giản sử dụng MCP Client để kết nối đến MCP Server.
-
-```python
-import gradio as gr
-
-from mcp.client.stdio import StdioServerParameters
-from smolagents import ToolCollection, CodeAgent
-from smolagents import CodeAgent, InferenceClientModel
-from smolagents.mcp_client import MCPClient
-```
-
-Tiếp theo, kết nối đến MCP Server và lấy các công cụ có thể dùng để trả lời câu hỏi.
-
-```python
-mcp_client = MCPClient(
-    {"url": "http://localhost:7860/gradio_api/mcp/sse"}
-)
-tools = mcp_client.get_tools()
-```
-
-Sau khi có các công cụ, ta có thể tạo một agent đơn giản sử dụng chúng để trả lời câu hỏi. Hiện tại chúng ta sẽ dùng `InferenceClientModel` và mô hình mặc định từ `smolagents`.
-
-```python
-model = InferenceClientModel()
-agent = CodeAgent(tools=[*tools], model=model)
-```
-
-Giờ tạo giao diện Gradio đơn giản sử dụng agent để trả lời câu hỏi.
-
-```python
-demo = gr.ChatInterface(
-    fn=lambda message, history: str(agent.run(message)),
-    type="messages",
-    examples=["Prime factorization of 68"],
-    title="Agent with MCP Tools",
-    description="Đây là agent đơn giản sử dụng các công cụ MCP để trả lời câu hỏi.",
-    messages=[],
-)
-
-demo.launch()
-```
-
-Vậy là xong! Chúng ta đã tạo một giao diện Gradio đơn giản dùng MCP Client để kết nối đến MCP Server và trả lời câu hỏi.
-
-<iframe
-	src="https://mcp-course-unit2-gradio-client.hf.space"
-	frameborder="0"
-	width="850"
-	height="450"
-></iframe>
-
-
-## Ví dụ hoàn chỉnh
-
-Dưới đây là ví dụ hoàn chỉnh của MCP Client trong Gradio:
-
-```python
-import gradio as gr
-
-from mcp.client.stdio import StdioServerParameters
-from smolagents import ToolCollection, CodeAgent
-from smolagents import CodeAgent, InferenceClientModel
-from smolagents.mcp_client import MCPClient
-
-
-try:
-    mcp_client = MCPClient(
-        # {"url": "https://abidlabs-mcp-tools.hf.space/gradio_api/mcp/sse"}
-        {"url": "http://localhost:7860/gradio_api/mcp/sse"}
-    )
-    tools = mcp_client.get_tools()
-
-    model = InferenceClientModel()
-    agent = CodeAgent(tools=[*tools], model=model)
-
-    def call_agent(message, history):
-        return str(agent.run(message))
-
-
-    demo = gr.ChatInterface(
-        fn=lambda message, history: str(agent.run(message)),
-        type="messages",
-        examples=["Prime factorization of 68"],
-        title="Agent with MCP Tools",
-        description="Đây là agent đơn giản sử dụng các công cụ MCP để trả lời câu hỏi.",
-        messages=[],
-    )
-
-    demo.launch()
-finally:
-    mcp_client.close()
-```
-
-Bạn sẽ thấy chúng ta đóng MCP Client trong khối `finally`. Điều này quan trọng vì MCP Client là đối tượng tồn tại lâu dài cần được đóng khi chương trình kết thúc.
-
-## Triển khai lên Hugging Face Spaces
-
-Để chia sẻ server của bạn với mọi người, bạn có thể triển khai lên Hugging Face Spaces như đã làm ở chương trước.
-Để triển khai Gradio MCP client lên Hugging Face Spaces:
-
-1. Tạo Space mới trên Hugging Face:
-   - Truy cập huggingface.co/spaces
-   - Click "Create new Space"
-   - Chọn "Gradio" làm SDK
-   - Đặt tên cho Space (ví dụ: "mcp-client")
-
-2. Tạo một tệp `requirements.txt`:
-```txt
-gradio[mcp]
-smolagents[mcp]
-```
-
-3. Đẩy code lên Space:
-```bash
-git init
-git add server.py requirements.txt
-git commit -m "Initial commit"
-git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/mcp-client
-git push -u origin main
-```
-
-## Kết luận
-
-Trong phần này, chúng ta đã tìm hiểu cách sử dụng Gradio như một MCP Client để kết nối đến một MCP Server. Chúng ta cũng đã xem qua cách triển khai MCP Client trên Hugging Face Spaces.

units/vi/unit2/gradio-server.mdx

@@ -1,228 +0,0 @@
-# Xây dựng Gradio MCP Server
-
-Trong phần này, chúng ta sẽ tạo một MCP server phân tích cảm xúc bằng Gradio. Server này sẽ cung cấp công cụ phân tích cảm xúc cho cả người dùng qua giao diện web và các mô hình AI thông qua giao thức MCP.
-
-## Giới thiệu tích hợp Gradio MCP
-
-Gradio cung cấp cách đơn giản để tạo MCP server bằng việc tự động chuyển đổi các hàm Python thành MCP Tools. Khi bạn đặt `mcp_server=True` trong `launch()`, Gradio sẽ:
-
-1. Tự động chuyển đổi các hàm thành MCP Tools
-2. Ánh xạ các thành phần đầu vào sang schema tham số công cụ
-3. Xác định định dạng phản hồi từ các thành phần đầu ra
-4. Thiết lập JSON-RPC qua HTTP+SSE cho giao tiếp client-server
-5. Tạo cả giao diện web và endpoint MCP server
-
-## Thiết lập dự án
-
-Đầu tiên, hãy tạo thư mục mới cho dự án và cài đặt các phụ thuộc cần thiết:
-
-```bash
-mkdir mcp-sentiment
-cd mcp-sentiment
-python -m venv venv
-source venv/bin/activate  # Trên Windows: venv\Scripts\activate
-pip install "gradio[mcp]" textblob
-```
-
-## Tạo Server
-
-Tạo một tệp mới có tên `server.py` với mã sau:
-
-<details>
-<summary>Bấm để xem bản dịch tiếng Việt</summary>
-```python
-import gradio as gr
-from textblob import TextBlob
-
-def sentiment_analysis(text: str) -> dict:
-    """
-    Phân tích cảm xúc của văn bản được cung cấp.
-
-    Args:
-        text (str): Văn bản cần phân tích
-
-    Returns:
-        dict: Từ điển chứa thông tin về độ phân cực, tính chủ quan và đánh giá
-    """
-    blob = TextBlob(text)
-    sentiment = blob.sentiment
-    
-    return {
-        "polarity": round(sentiment.polarity, 2),  # -1 (tiêu cực) đến 1 (tích cực)
-        "subjectivity": round(sentiment.subjectivity, 2),  # 0 (khách quan) đến 1 (chủ quan)
-        "assessment": "positive" if sentiment.polarity > 0 else "negative" if sentiment.polarity < 0 else "neutral"
-    }
-
-# Tạo giao diện Gradio
-demo = gr.Interface(
-    fn=sentiment_analysis,
-    inputs=gr.Textbox(placeholder="Nhập văn bản để phân tích..."),
-    outputs=gr.JSON(),
-    title="Phân Tích Cảm Xúc Văn Bản",
-    description="Phân tích cảm xúc văn bản sử dụng TextBlob"
-)
-
-# Khởi chạy giao diện và Server MCP
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-</details>
-
-```python
-import gradio as gr
-from textblob import TextBlob
-
-def sentiment_analysis(text: str) -> dict:
-    """
-    Analyze the sentiment of the given text.
-
-    Args:
-        text (str): The text to analyze
-
-    Returns:
-        dict: A dictionary containing polarity, subjectivity, and assessment
-    """
-    blob = TextBlob(text)
-    sentiment = blob.sentiment
-    
-    return {
-        "polarity": round(sentiment.polarity, 2),  # -1 (negative) to 1 (positive)
-        "subjectivity": round(sentiment.subjectivity, 2),  # 0 (objective) to 1 (subjective)
-        "assessment": "positive" if sentiment.polarity > 0 else "negative" if sentiment.polarity < 0 else "neutral"
-    }
-
-# Create the Gradio interface
-demo = gr.Interface(
-    fn=sentiment_analysis,
-    inputs=gr.Textbox(placeholder="Enter text to analyze..."),
-    outputs=gr.JSON(),
-    title="Text Sentiment Analysis",
-    description="Analyze the sentiment of text using TextBlob"
-)
-
-# Launch the interface and MCP server
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-## Hiểu về Mã
-
-Hãy cùng phân tích các thành phần chính:
-
-1. **Định nghĩa Hàm**:
-   - Hàm `sentiment_analysis` nhận đầu vào là văn bản và trả về một từ điển
-   - Sử dụng TextBlob để phân tích cảm xúc
-   - Docstring rất quan trọng vì giúp Gradio tạo lược đồ công cụ MCP
-   - Gợi ý kiểu dữ liệu (`str` và `dict`) giúp xác định lược đồ đầu vào/đầu ra
-
-2. **Giao diện Gradio**:
-   - `gr.Interface` tạo cả giao diện web và Server MCP
-   - Hàm được hiển thị như một công cụ MCP tự động
-   - Các thành phần đầu vào và đầu ra xác định lược đồ công cụ
-   - Thành phần đầu ra JSON đảm bảo tuần tự hóa đúng cách
-
-3. **Server MCP**:
-   - Thiết lập `mcp_server=True` kích hoạt Server MCP
-   - Server sẽ có sẵn tại `http://localhost:7860/gradio_api/mcp/sse`
-   - Bạn cũng có thể kích hoạt bằng biến môi trường:
-     ```bash
-     export GRADIO_MCP_SERVER=True
-     ```
-
-## Chạy Server
-
-Khởi động Server bằng cách chạy:
-
-```bash
-python server.py
-```
-
-Bạn sẽ thấy đầu ra cho biết cả giao diện web và Server MCP đang chạy. Giao diện web sẽ có sẵn tại `http://localhost:7860`, và Server MCP tại `http://localhost:7860/gradio_api/mcp/sse`.
-
-## Kiểm tra Server
-
-Bạn có thể kiểm tra Server bằng hai cách:
-
-1. **Giao diện Web**:
-   - Mở `http://localhost:7860` trong trình duyệt
-   - Nhập văn bản và nhấp "Submit"
-   - Bạn sẽ thấy kết quả phân tích cảm xúc
-
-2. **Lược đồ MCP**:
-   - Truy cập `http://localhost:7860/gradio_api/mcp/schema`
-   - Hiển thị lược đồ công cụ MCP mà các Client sẽ sử dụng
-   - Bạn cũng có thể tìm thấy liên kết này trong phần "View API" ở chân trang ứng dụng Gradio
-
-## Mẹo Xử lý Sự cố
-
-1. **Gợi ý Kiểu dữ liệu và Docstring**:
-   - Luôn cung cấp gợi ý kiểu dữ liệu cho tham số hàm và giá trị trả về
-   - Bao gồm docstring với khối "Args:" cho mỗi tham số
-   - Điều này giúp Gradio tạo lược đồ công cụ MCP chính xác
-
-2. **Đầu vào Chuỗi**:
-   - Khi không chắc chắn, hãy chấp nhận đối số đầu vào dưới dạng `str`
-   - Chuyển đổi chúng sang kiểu mong muốn bên trong hàm
-   - Cung cấp khả năng tương thích tốt hơn với các Client MCP
-
-3. **Hỗ trợ SSE**:
-   - Một số Client MCP không hỗ trợ Server MCP dựa trên SSE
-   - Trong trường hợp đó, sử dụng `mcp-remote`:
-     ```json
-     {
-       "mcpServers": {
-         "gradio": {
-           "command": "npx",
-           "args": [
-             "mcp-remote",
-             "http://localhost:7860/gradio_api/mcp/sse"
-           ]
-         }
-       }
-     }
-     ```
-
-4. **Sự cố Kết nối**:
-   - Nếu gặp vấn đề kết nối, thử khởi động lại cả Client và Server
-   - Kiểm tra xem Server đang chạy và có thể truy cập được không
-   - Xác nhận rằng lược đồ MCP có sẵn tại URL mong đợi
-
-## Triển khai lên Hugging Face Spaces
-
-Để làm cho Server của bạn có sẵn cho người khác, bạn có thể triển khai lên Hugging Face Spaces:
-
-1. Tạo một Space mới trên Hugging Face:
-   - Truy cập huggingface.co/spaces
-   - Nhấp "Create new Space"
-   - Chọn "Gradio" làm SDK
-   - Đặt tên cho Space của bạn (ví dụ: "mcp-sentiment")
-
-2. Tạo tệp `requirements.txt`:
-```txt
-gradio[mcp]
-textblob
-```
-
-3. Đẩy mã của bạn lên Space:
-```bash
-git init
-git add server.py requirements.txt
-git commit -m "Initial commit"
-git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/mcp-sentiment
-git push -u origin main
-```
-
-Server MCP của các bạn giờ đã có thể truy cập tại:
-```
-https://YOUR_USERNAME-mcp-sentiment.hf.space/gradio_api/mcp/sse
-```
-
-## Bước tiếp theo
-
-Giờ khi đã có Server MCP đang chạy, chúng ta sẽ tạo các Client để tương tác với nó. Trong các phần tiếp theo, chúng ta sẽ:
-
-1. Tạo một Client dựa trên HuggingFace.js lấy cảm hứng từ Tiny Agents
-2. Triển khai một Client Python dựa trên SmolAgents
-3. Kiểm tra cả hai Client với Server đã triển khai
-
-Hãy cùng chuyển sang phần xây dựng Client đầu tiên nào!