diff --git a/MyIA.AI.Notebooks/GenAI/SemanticKernel/08-SemanticKernel-MCP.ipynb b/MyIA.AI.Notebooks/GenAI/SemanticKernel/08-SemanticKernel-MCP.ipynb
index a74e9a7d5f..dc918d6e70 100644
--- a/MyIA.AI.Notebooks/GenAI/SemanticKernel/08-SemanticKernel-MCP.ipynb
+++ b/MyIA.AI.Notebooks/GenAI/SemanticKernel/08-SemanticKernel-MCP.ipynb
@@ -1,1968 +1 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "bd9f46f9",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# SK-8-MCP : Model Context Protocol et Integration\n",
-    "\n",
-    "**Navigation** : [<< 07-MultiModal](07-SemanticKernel-MultiModal.ipynb) | [Index](README.md)\n",
-    "\n",
-    "***\n",
-    "\n",
-    "## Objectifs d'apprentissage\n",
-    "\n",
-    "A la fin de ce notebook, vous saurez :\n",
-    "1. Comprendre le **Model Context Protocol (MCP)**\n",
-    "2. Identifier les **serveurs MCP** disponibles\n",
-    "3. Integrer des **outils MCP** comme plugins SK\n",
-    "4. Créer un **bridge Agent Framework ↔ MCP**\n",
-    "5. Concevoir un **serveur MCP personnalise**\n",
-    "\n",
-    "### Prerequis\n",
-    "\n",
-    "- Python 3.10+\n",
-    "- Notebooks 01-07 completes\n",
-    "- Comprehension des Agents SK (notebook 03)\n",
-    "- Node.js installe (pour certains serveurs MCP)\n",
-    "\n",
-    "### Duree estimee : 45 minutes\n",
-    "\n",
-    "***\n",
-    "\n",
-    "## Sommaire\n",
-    "\n",
-    "| Section | Contenu | Concepts cles |\n",
-    "|---------|---------|---------------|\n",
-    "| 1 | Introduction | Qu'est-ce que MCP ? |\n",
-    "| 2 | Architecture | Tools, Resources, Prompts |\n",
-    "| 3 | Serveurs existants | Filesystem, GitHub, Database |\n",
-    "| 4 | SK + MCP | Integration comme plugins |\n",
-    "| 5 | Agent + MCP | Bridge avec Agent Framework |\n",
-    "| 6 | Serveur custom | Créer son propre serveur |\n",
-    "| 7 | Conclusion | Resume, exercices |\n",
-    "\n",
-    "> **Model Context Protocol (MCP)** : Standard ouvert initie par Anthropic et adopte par Microsoft pour permettre aux LLMs d'acceder a des outils externes de maniere standardisee. C'est l'evolution des plugins vers l'interoperabilite."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "de07375f",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "MCP SDK installe\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Installation\n",
-    "\n",
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "load_dotenv()\n",
-    "print(\"MCP SDK installe\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1b072c98",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 1. Introduction au Model Context Protocol\n",
-    "\n",
-    "### Pourquoi MCP ?\n",
-    "\n",
-    "Avant MCP, chaque framework avait son propre système de plugins :\n",
-    "\n",
-    "| Framework | Système de plugins | Problème |\n",
-    "|-----------|-------------------|----------|\n",
-    "| Semantic Kernel | KernelFunction | Non portable |\n",
-    "| LangChain | Tools | Non portable |\n",
-    "| AutoGen | Tools | Non portable |\n",
-    "| OpenAI | Function Calling | Spécifique OpenAI |\n",
-    "\n",
-    "**MCP resout ce problème** en definissant un standard :\n",
-    "\n",
-    "```\n",
-    "┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐\n",
-    "│ Semantic Kernel │     │   LangChain     │     │    AutoGen      │\n",
-    "│                 │     │                 │     │                 │\n",
-    "│  MCP Client     │     │  MCP Client     │     │  MCP Client     │\n",
-    "└────────┬────────┘     └────────┬────────┘     └────────┬────────┘\n",
-    "         │                       │                       │\n",
-    "         └───────────────────────┼───────────────────────┘\n",
-    "                                 │\n",
-    "                                 ↓\n",
-    "                    ┌─────────────────────────┐\n",
-    "                    │     MCP Servers         │\n",
-    "                    │                         │\n",
-    "                    │ - Filesystem            │\n",
-    "                    │ - GitHub                │\n",
-    "                    │ - Database              │\n",
-    "                    │ - Custom...             │\n",
-    "                    └─────────────────────────┘\n",
-    "```\n",
-    "\n",
-    "### Acteurs principaux\n",
-    "\n",
-    "| Acteur | Rôle | Exemple |\n",
-    "|--------|------|---------|\n",
-    "| **Client** | Consomme les outils | Claude Code, SK |\n",
-    "| **Server** | Fournit les outils | mcp-server-filesystem |\n",
-    "| **Transport** | Communication | stdio, HTTP, SSE |"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp5k08c",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "Le diagramme ci-dessous rend cette architecture **MCP** sous forme de graphe : plusieurs\n",
-    "frameworks clients consomment un même ensemble de serveurs d'outils standardises.\n",
-    "\n",
-    "```mermaid\n",
-    "flowchart TD\n",
-    "    SK[\"Semantic Kernel<br/>MCP Client\"] --> SRV\n",
-    "    LC[\"LangChain<br/>MCP Client\"] --> SRV\n",
-    "    AG[\"AutoGen<br/>MCP Client\"] --> SRV\n",
-    "    SRV[\"MCP Servers<br/>Filesystem / GitHub / Database / Custom...\"]\n",
-    "    classDef client fill:#cfe2ff,stroke:#084298,color:#052c65\n",
-    "    classDef server fill:#fff3cd,stroke:#b8860b,color:#5c4400\n",
-    "    class SK,LC,AG client\n",
-    "    class SRV server\n",
-    "```\n",
-    "\n",
-    "> **Lecture.** Le **Model Context Protocol** standardise la facon dont un agent accede a\n",
-    "> des outils externes : n'importe quel **client** conforme (Semantic Kernel, LangChain,\n",
-    "> AutoGen...) peut consommer n'importe quel **serveur MCP** (filesystem, GitHub, base de\n",
-    "> données, serveurs maison) sans integration sur-mesure. C'est l'equivalent, pour les\n",
-    "> outils d'agents, de ce que USB a ete pour les peripheriques : un connecteur commun qui\n",
-    "> decouple les clients des fournisseurs de capacites.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "63080987",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 2. Architecture MCP\n",
-    "\n",
-    "MCP définit trois types de primitives :\n",
-    "\n",
-    "### 2.1 Tools (Outils)\n",
-    "\n",
-    "Fonctions executables par le LLM :\n",
-    "\n",
-    "```json\n",
-    "{\n",
-    "  \"name\": \"read_file\",\n",
-    "  \"description\": \"Read the contents of a file\",\n",
-    "  \"inputSchema\": {\n",
-    "    \"type\": \"object\",\n",
-    "    \"properties\": {\n",
-    "      \"path\": { \"type\": \"string\" }\n",
-    "    },\n",
-    "    \"required\": [\"path\"]\n",
-    "  }\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "### 2.2 Resources (Ressources)\n",
-    "\n",
-    "Données accessibles en lecture :\n",
-    "\n",
-    "```json\n",
-    "{\n",
-    "  \"uri\": \"file:///path/to/doc.md\",\n",
-    "  \"name\": \"Documentation\",\n",
-    "  \"mimeType\": \"text/markdown\"\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "### 2.3 Prompts\n",
-    "\n",
-    "Templates de prompts reutilisables :\n",
-    "\n",
-    "```json\n",
-    "{\n",
-    "  \"name\": \"summarize\",\n",
-    "  \"description\": \"Summarize a document\",\n",
-    "  \"arguments\": [\n",
-    "    { \"name\": \"content\", \"required\": true }\n",
-    "  ]\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "### Tableau comparatif\n",
-    "\n",
-    "| Primitive | Action | Equivalent SK |\n",
-    "|-----------|--------|---------------|\n",
-    "| **Tool** | Execute une fonction | KernelFunction |\n",
-    "| **Resource** | Lit des données | Pas d'equivalent direct |\n",
-    "| **Prompt** | Fournit un template | PromptTemplate |"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9c33e97c",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 3. Serveurs MCP existants\n",
-    "\n",
-    "De nombreux serveurs MCP sont disponibles :"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "90023b20",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Serveurs MCP populaires:\n",
-      "============================================================\n",
-      "\n",
-      "FILESYSTEM\n",
-      "  Package: @anthropic/mcp-server-filesystem\n",
-      "  Description: Lecture/ecriture de fichiers\n",
-      "  Tools: read_file, write_file, list_directory\n",
-      "\n",
-      "GITHUB\n",
-      "  Package: @anthropic/mcp-server-github\n",
-      "  Description: Operations GitHub (repos, issues, PRs)\n",
-      "  Tools: search_repos, get_issue, create_pr\n",
-      "\n",
-      "POSTGRES\n",
-      "  Package: @anthropic/mcp-server-postgres\n",
-      "  Description: Requetes SQL PostgreSQL\n",
-      "  Tools: query, execute, describe_table\n",
-      "\n",
-      "JUPYTER\n",
-      "  Package: mcp-jupyter\n",
-      "  Description: Execution de notebooks Jupyter\n",
-      "  Tools: execute_notebook, read_cells, manage_kernel\n",
-      "\n",
-      "PUPPETEER\n",
-      "  Package: @anthropic/mcp-server-puppeteer\n",
-      "  Description: Automatisation web (scraping, screenshots)\n",
-      "  Tools: navigate, screenshot, click\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Liste des serveurs MCP populaires\n",
-    "mcp_servers = [\n",
-    "    {\n",
-    "        \"name\": \"filesystem\",\n",
-    "        \"package\": \"@anthropic/mcp-server-filesystem\",\n",
-    "        \"description\": \"Lecture/ecriture de fichiers\",\n",
-    "        \"tools\": [\"read_file\", \"write_file\", \"list_directory\"]\n",
-    "    },\n",
-    "    {\n",
-    "        \"name\": \"github\",\n",
-    "        \"package\": \"@anthropic/mcp-server-github\",\n",
-    "        \"description\": \"Operations GitHub (repos, issues, PRs)\",\n",
-    "        \"tools\": [\"search_repos\", \"get_issue\", \"create_pr\"]\n",
-    "    },\n",
-    "    {\n",
-    "        \"name\": \"postgres\",\n",
-    "        \"package\": \"@anthropic/mcp-server-postgres\",\n",
-    "        \"description\": \"Requetes SQL PostgreSQL\",\n",
-    "        \"tools\": [\"query\", \"execute\", \"describe_table\"]\n",
-    "    },\n",
-    "    {\n",
-    "        \"name\": \"jupyter\",\n",
-    "        \"package\": \"mcp-jupyter\",\n",
-    "        \"description\": \"Execution de notebooks Jupyter\",\n",
-    "        \"tools\": [\"execute_notebook\", \"read_cells\", \"manage_kernel\"]\n",
-    "    },\n",
-    "    {\n",
-    "        \"name\": \"puppeteer\",\n",
-    "        \"package\": \"@anthropic/mcp-server-puppeteer\",\n",
-    "        \"description\": \"Automatisation web (scraping, screenshots)\",\n",
-    "        \"tools\": [\"navigate\", \"screenshot\", \"click\"]\n",
-    "    }\n",
-    "]\n",
-    "\n",
-    "print(\"Serveurs MCP populaires:\")\n",
-    "print(\"=\" * 60)\n",
-    "for server in mcp_servers:\n",
-    "    print(f\"\\n{server['name'].upper()}\")\n",
-    "    print(f\"  Package: {server['package']}\")\n",
-    "    print(f\"  Description: {server['description']}\")\n",
-    "    print(f\"  Tools: {', '.join(server['tools'])}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9accb0c5",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exemple guidé 1 : Analyseur de capacites MCP\n",
-    "\n",
-    "*Contribution étudiante de Gabriel COMBE (@GabrielC-star) et Rémi LESANNE, PR #18553, intégrée comme exemple guidé.*\n",
-    "\n",
-    "Cet exemple classe les cinq serveurs MCP listés plus haut par domaine d'expertise (`storage`, `devops`, `web`, `data`). La fonction `categorize_mcp_servers()` parcourt la liste, reconnaît le domaine de chaque serveur grâce aux mots-clés de sa description, compte ses outils et repère le serveur le mieux pourvu. Elle retourne un dict avec les catégories, le total d'outils et le nom du serveur en ayant le plus."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "44789c95",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "storage: ['filesystem']\n",
-      "devops: ['github']\n",
-      "web: ['puppeteer']\n",
-      "data: ['postgres']\n",
-      "Total outils: 15\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exemple guide 1 : Analyseur de capacites MCP\n",
-    "# Contribution etudiante de Gabriel COMBE et Remi LESANNE (PR #18553)\n",
-    "def categorize_mcp_servers(servers: list) -> dict:\n",
-    "    \"\"\"\n",
-    "    Classifier les serveurs MCP par domaine d'expertise.\n",
-    "    \n",
-    "    Args:\n",
-    "        servers: Liste de dicts avec les cles: name, description, tools\n",
-    "    \n",
-    "    Returns:\n",
-    "        dict avec les cles: categories (dict domaine -> list serveurs),\n",
-    "        total_tools (int), server_with_most_tools (str)\n",
-    "    \"\"\"\n",
-    "    categories = {\n",
-    "        \"storage\": [],\n",
-    "        \"devops\": [],\n",
-    "        \"web\": [],\n",
-    "        \"data\": []\n",
-    "    }\n",
-    "\n",
-    "    total_tools = 0\n",
-    "    server_with_most_tools = None\n",
-    "    max_tools = 0\n",
-    "\n",
-    "    for server in servers:\n",
-    "        name = server[\"name\"]\n",
-    "        description = server[\"description\"].lower()\n",
-    "        tools = server[\"tools\"]\n",
-    "\n",
-    "        nb_tools = len(tools)\n",
-    "        total_tools += nb_tools\n",
-    "\n",
-    "        if nb_tools > max_tools:\n",
-    "            max_tools = nb_tools\n",
-    "            server_with_most_tools = name\n",
-    "    \n",
-    "        if \"fichier\" in description:\n",
-    "            categories[\"storage\"].append(server)\n",
-    "\n",
-    "        elif \"github\" in description:\n",
-    "            categories[\"devops\"].append(server)\n",
-    "\n",
-    "        elif \"scraping\" in description:\n",
-    "            categories[\"web\"].append(server)\n",
-    "\n",
-    "        elif \"sql\" in description:\n",
-    "            categories[\"data\"].append(server)\n",
-    "\n",
-    "\n",
-    "    return {\n",
-    "        \"categories\": categories,\n",
-    "        \"total_tools\": total_tools,\n",
-    "        \"server_with_most_tools\": server_with_most_tools\n",
-    "    }\n",
-    "        \n",
-    "    \n",
-    "# Test :\n",
-    "result = categorize_mcp_servers(mcp_servers)\n",
-    "for category, srvs in result['categories'].items():\n",
-    "    print(f\"{category}: {[s['name'] for s in srvs]}\")\n",
-    "print(f\"Total outils: {result['total_tools']}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-eg1-lecture",
-   "metadata": {},
-   "source": [
-    "### Lecture du résultat — exemple guidé 1 (capacités MCP)\n",
-    "\n",
-    "- Les quatre domaines attendus sont remplis : `storage: ['filesystem']`, `devops: ['github']`, `web: ['puppeteer']`, `data: ['postgres']`.\n",
-    "- `mcp_servers` compte 5 serveurs, mais un seul manque à l'appel : `jupyter` n'apparaît dans aucune catégorie. Sa description (« Execution de notebooks Jupyter ») ne contient aucun des mots-clés testés (`fichier`, `github`, `scraping`, `sql`) — le classement par mots-clés l'ignore **silencieusement**, sans erreur ni avertissement.\n",
-    "- `Total outils: 15` compte pourtant les 5 serveurs (3 outils chacun), `jupyter` compris : le total et les catégories ne décrivent pas le même périmètre.\n",
-    "- `server_with_most_tools` est calculé — la paire gagnante serait `filesystem`, premier ex æquo à 3 outils — mais jamais imprimé : la valeur retourne dans le dict sans apparaître dans la sortie."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-ex1-routage-md",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exercice 1 : Router une tache vers le bon serveur et son outil\n",
-    "\n",
-    "L'exemple guidé 1 classe les serveurs par domaine, mais il ne dit pas *quel outil* appeler pour une tâche donnée, et surtout il **ignore silencieusement** tout serveur que ses mots-clés ne reconnaissent pas. Un vrai routeur doit savoir répondre « aucun serveur ne sait faire ça ».\n",
-    "\n",
-    "**Objectif** : écrire `choisir_outil(tache, servers)` qui, pour une tâche en langage naturel, note chaque paire (serveur, outil) selon les mots de la tâche, et retourne la meilleure paire — ou `None` quand aucun score n'est positif.\n",
-    "\n",
-    "**Étapes** :\n",
-    "1. `# Étape 1` : découper la tâche en mots (minuscules), en ajoutant au besoin des synonymes (par exemple « capture d'ecran » → `screenshot`)\n",
-    "2. `# Étape 2` : pour chaque serveur de `mcp_servers` et chacun de ses outils, calculer un score : +1 si un mot de la tâche correspond au nom du serveur, à sa description ou au nom de l'outil\n",
-    "3. `# Étape 3` : retourner la paire `(serveur, outil)` au meilleur score si ce score est strictement positif, sinon `None`\n",
-    "\n",
-    "**Indices** :\n",
-    "- `# Indice` : « ouvrir une issue pour signaler un bug » contient le mot *issue* — un outil de `github` s'appelle `get_issue`\n",
-    "- `# Indice` : « lister les tables de la base » parle de tables — `describe_table` est un outil de `postgres`\n",
-    "- `# Indice` : « envoyer un SMS » ne correspond à aucun serveur — la fonction doit retourner `None`, sans lever d'erreur\n",
-    "\n",
-    "**Critère de réussite** : les quatre tests affichent `('github', 'get_issue')`, `('puppeteer', 'screenshot')`, `('postgres', 'describe_table')` puis `None`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "mcp-ex1-routage-code",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Exercice a completer\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exercice 1 : Router une tache vers le bon serveur et son outil\n",
-    "# TODO etudiant : completer choisir_outil, puis decommenter les tests\n",
-    "\n",
-    "def choisir_outil(tache: str, servers: list):\n",
-    "    \"\"\"\n",
-    "    Choisir la paire (serveur, outil) la mieux adaptee a une tache.\n",
-    "\n",
-    "    Args:\n",
-    "        tache: la tache en langage naturel\n",
-    "        servers: la liste des serveurs (meme forme que mcp_servers)\n",
-    "\n",
-    "    Returns:\n",
-    "        tuple (nom du serveur, nom de l'outil) si un score est positif,\n",
-    "        None sinon\n",
-    "    \"\"\"\n",
-    "    # Etape 1 : mots de la tache en minuscules (+ synonymes si besoin)\n",
-    "    mots = None  # TODO etudiant\n",
-    "\n",
-    "    meilleur_score = 0\n",
-    "    meilleure_paire = None\n",
-    "\n",
-    "    # Etape 2 : scorer chaque paire (serveur, outil)\n",
-    "    # for server in servers:\n",
-    "    #     texte = server[\"name\"] + \" \" + server[\"description\"]\n",
-    "    #     for tool in server[\"tools\"]:\n",
-    "    #         score = 0  # TODO etudiant : +1 par mot present dans texte ou tool\n",
-    "    #         if score > meilleur_score:\n",
-    "    #             meilleur_score = score\n",
-    "    #             meilleure_paire = (server[\"name\"], tool)\n",
-    "\n",
-    "    # Etape 3 : retourner la meilleure paire, ou None si aucun score positif\n",
-    "    return None  # TODO etudiant\n",
-    "\n",
-    "\n",
-    "# Tests\n",
-    "taches = [\n",
-    "    \"ouvrir une issue pour signaler un bug\",\n",
-    "    \"faire une capture d'ecran d'une page web\",\n",
-    "    \"lister les tables de la base\",\n",
-    "    \"envoyer un SMS\",\n",
-    "]\n",
-    "# for tache in taches:\n",
-    "#     print(f\"{tache} -> {choisir_outil(tache, mcp_servers)}\")\n",
-    "\n",
-    "print(\"Exercice a completer\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "y02s0tymzf",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Interprétation : Écosystème des serveurs MCP\n",
-    "\n",
-    "**Sortie obtenue** : Liste de 5 serveurs MCP représentatifs de l'écosystème\n",
-    "\n",
-    "| Serveur | Domaine | Maturité | Cas d'usage typique |\n",
-    "|---------|---------|----------|---------------------|\n",
-    "| **filesystem** | Système | Production | Manipulation de fichiers locaux |\n",
-    "| **github** | DevOps | Production | Automatisation CI/CD, gestion issues |\n",
-    "| **postgres** | Base de données | Production | Requêtes SQL, analytics |\n",
-    "| **jupyter** | Data Science | Expérimental | Notebooks interactifs, reproductibilité |\n",
-    "| **puppeteer** | Web scraping | Production | Tests E2E, captures d'écran |\n",
-    "\n",
-    "**Points clés** :\n",
-    "\n",
-    "1. **Diversité** : MCP couvre tous les domaines (filesystem, cloud, databases, web)\n",
-    "2. **Standards vs Custom** : Les serveurs Anthropic (@anthropic/*) sont les références\n",
-    "3. **Packages npm** : La majorité utilise Node.js, quelques-uns Python (uvx)\n",
-    "4. **Granularité** : Chaque serveur expose 3-10 outils spécialisés\n",
-    "\n",
-    "**Note technique** : L'installation nécessite Node.js 18+ pour les serveurs npm, ou Python 3.10+ avec `uvx` pour les serveurs Python.\n",
-    "\n",
-    "**Évolution** : De nouveaux serveurs apparaissent régulièrement sur [modelcontextprotocol.io/servers](https://modelcontextprotocol.io/servers)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dcf4c1c8",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Installation d'un serveur MCP\n",
-    "\n",
-    "```bash\n",
-    "# Via npm (Node.js requis)\n",
-    "npx -y @anthropic/mcp-server-filesystem --root /path/to/files\n",
-    "\n",
-    "# Via uvx (Python)\n",
-    "uvx mcp-server-sqlite --db-path database.db\n",
-    "```\n",
-    "\n",
-    "### Configuration dans Claude Code\n",
-    "\n",
-    "Les serveurs MCP se configurent dans `~/.claude.json` :\n",
-    "\n",
-    "```json\n",
-    "{\n",
-    "  \"mcpServers\": {\n",
-    "    \"filesystem\": {\n",
-    "      \"command\": \"npx\",\n",
-    "      \"args\": [\"-y\", \"@anthropic/mcp-server-filesystem\", \"--root\", \"/path\"]\n",
-    "    }\n",
-    "  }\n",
-    "}\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e6160224",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 4. Integration SK + MCP\n",
-    "\n",
-    "Semantic Kernel peut consommer des serveurs MCP comme plugins."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "1f015b46",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Plugin MCP Filesystem ajoute au Kernel\n",
-      "\n",
-      "Fonctions disponibles:\n",
-      "  - list_directory: Liste les fichiers d'un repertoire\n",
-      "  - read_file: Lit le contenu d'un fichier\n",
-      "  - write_file: Ecrit du contenu dans un fichier\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exemple conceptuel : MCP Server comme plugin SK\n",
-    "# Note: L'integration native SK+MCP est en cours de developpement\n",
-    "\n",
-    "from semantic_kernel import Kernel\n",
-    "from semantic_kernel.functions import kernel_function\n",
-    "from typing import Annotated\n",
-    "import subprocess\n",
-    "import json\n",
-    "\n",
-    "class MCPFilesystemPlugin:\n",
-    "    \"\"\"\n",
-    "    Wrapper qui expose un serveur MCP comme plugin SK.\n",
-    "    Pattern: MCP tools -> KernelFunctions\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self, root_path: str):\n",
-    "        self.root_path = root_path\n",
-    "    \n",
-    "    @kernel_function(description=\"Lit le contenu d'un fichier\")\n",
-    "    def read_file(self, path: Annotated[str, \"Chemin du fichier\"]) -> str:\n",
-    "        \"\"\"Wrapper pour l'outil MCP read_file.\"\"\"\n",
-    "        full_path = os.path.join(self.root_path, path)\n",
-    "        try:\n",
-    "            with open(full_path, 'r', encoding='utf-8') as f:\n",
-    "                return f.read()\n",
-    "        except Exception as e:\n",
-    "            return f\"Erreur: {e}\"\n",
-    "    \n",
-    "    @kernel_function(description=\"Liste les fichiers d'un repertoire\")\n",
-    "    def list_directory(self, path: Annotated[str, \"Chemin du repertoire\"] = \".\") -> str:\n",
-    "        \"\"\"Wrapper pour l'outil MCP list_directory.\"\"\"\n",
-    "        full_path = os.path.join(self.root_path, path)\n",
-    "        try:\n",
-    "            files = os.listdir(full_path)\n",
-    "            return json.dumps(files, indent=2)\n",
-    "        except Exception as e:\n",
-    "            return f\"Erreur: {e}\"\n",
-    "    \n",
-    "    @kernel_function(description=\"Ecrit du contenu dans un fichier\")\n",
-    "    def write_file(self, \n",
-    "                   path: Annotated[str, \"Chemin du fichier\"],\n",
-    "                   content: Annotated[str, \"Contenu a ecrire\"]) -> str:\n",
-    "        \"\"\"Wrapper pour l'outil MCP write_file.\"\"\"\n",
-    "        full_path = os.path.join(self.root_path, path)\n",
-    "        try:\n",
-    "            with open(full_path, 'w', encoding='utf-8') as f:\n",
-    "                f.write(content)\n",
-    "            return f\"Fichier ecrit: {full_path}\"\n",
-    "        except Exception as e:\n",
-    "            return f\"Erreur: {e}\"\n",
-    "\n",
-    "# Utilisation\n",
-    "kernel = Kernel()\n",
-    "kernel.add_plugin(MCPFilesystemPlugin(root_path=\".\"), plugin_name=\"filesystem\")\n",
-    "\n",
-    "print(\"Plugin MCP Filesystem ajoute au Kernel\")\n",
-    "print(\"\\nFonctions disponibles:\")\n",
-    "for func in kernel.get_plugin(\"filesystem\").functions.values():\n",
-    "    print(f\"  - {func.name}: {func.description}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "x0z5k215bqn",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Interprétation : Bridge MCP → Semantic Kernel\n",
-    "\n",
-    "**Sortie obtenue** : Plugin SK exposant 3 fonctions (read_file, list_directory, write_file)\n",
-    "\n",
-    "| Fonction SK | Outil MCP source | Type de transformation |\n",
-    "|-------------|------------------|------------------------|\n",
-    "| `read_file()` | `read_file` | Wrapper direct |\n",
-    "| `list_directory()` | `list_directory` | Wrapper avec JSON serialization |\n",
-    "| `write_file()` | `write_file` | Wrapper direct |\n",
-    "\n",
-    "**Architecture du bridge** :\n",
-    "\n",
-    "```\n",
-    "MCP Server (Node.js)          Python Bridge              Semantic Kernel\n",
-    "┌─────────────────┐          ┌──────────────┐          ┌───────────────┐\n",
-    "│ @anthropic/     │          │ MCP          │          │ Kernel        │\n",
-    "│ mcp-server-     │  stdio   │ Filesystem   │  @kernel │ Plugin        │\n",
-    "│ filesystem      │ ──────>  │ Plugin       │ ──────>  │               │\n",
-    "│                 │          │              │  _function│  Functions    │\n",
-    "│ - read_file     │          │ - read_file  │          │   disponibles │\n",
-    "│ - list_dir      │          │ - list_dir   │          │               │\n",
-    "└─────────────────┘          └──────────────┘          └───────────────┘\n",
-    "```\n",
-    "\n",
-    "**Points clés** :\n",
-    "\n",
-    "1. **Pattern Adapter** : Le plugin SK adapte le protocole MCP (stdio) en KernelFunctions\n",
-    "2. **Annotations Semantic Kernel** : `@kernel_function` + `Annotated[str, \"description\"]`\n",
-    "3. **Gestion d'erreurs** : Les exceptions MCP sont capturées et retournées comme strings\n",
-    "4. **Path resolution** : Le bridge gère les chemins relatifs via `root_path`\n",
-    "\n",
-    "**Limitations actuelles** :\n",
-    "\n",
-    "| Limitation | Impact | Contournement |\n",
-    "|------------|--------|---------------|\n",
-    "| Pas d'intégration native SK | Code wrapper manuel requis | Bridge custom comme ci-dessus |\n",
-    "| Communication stdio | Latence légère | Acceptable pour la plupart des usages |\n",
-    "| Pas de Resources/Prompts | Seulement les Tools MCP exposés | Enrichir le plugin au besoin |\n",
-    "\n",
-    "**Roadmap** : Microsoft travaille sur une intégration native MCP dans SK (Q2 2026)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "faf9dd9c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Fichiers dans le repertoire courant:\n",
-      "[\n",
-      "  \"01-SemanticKernel-Intro.ipynb\",\n",
-      "  \"02-SemanticKernel-Advanced.ipynb\",\n",
-      "  \"03-SemanticKernel-Agents.ipynb\",\n",
-      "  \"04-SemanticKernel-Filters-Observability.ipynb\",\n",
-      "  \"05-SemanticKernel-VectorStores.ipynb\",\n",
-      "  \"06-SemanticKernel-ProcessFramework.ipynb\",\n",
-      "  \"07-SemanticKernel-MultiModal.ipynb\",\n",
-      "  \"08-SemanticKernel-MCP.ipynb\",\n",
-      "  \"09-SemanticKernel-Building-CLR.ipynb\",\n",
-      "  \"10-SemanticKernel-NotebookMaker.ipynb\",\n",
-      "  \"10a-SemanticKernel-NotebookMaker-batch.ipynb\",\n",
-      "  \"10b-SemanticKernel-NotebookMaker-batch-parameterized.ipynb\",\n",
-      "  \"11-SemanticKernel-A2A.ipynb\",\n",
-      "  \"aspire-otel\",\n",
-      "  \"AutoGenNotebookUpdater.cs\",\n",
-      "  \"AutoInvokeSKAgentsNotebookUpdater.cs\",\n",
-      "  \"Cr\\u00e9ateur de mail personnalis\\u00e9.ipynb\",\n",
-      "  \"DisplayLogger.cs\",\n",
-      "  \"DisplayLoggerProvider.cs\",\n",
-      "  \"fort-boyard-csharp.ipynb\",\n",
-      "  \"fort-boyard-python.ipynb\",\n",
-      "  \"GuessingGame.cs\",\n",
-      "  \"MANIFEST.md\",\n",
-      "  \"Notebook-Generated.ipynb\",\n",
-      "  \"Notebook-Template.ipynb\",\n",
-      "  \"NotebookExecutor.cs\",\n",
-      "  \"NotebookPlannerUpdater.cs\",\n",
-      "  \"NotebookUpdaterBase.cs\",\n",
-      "  \"prompt_template_samples\",\n",
-      "  \"README.md\",\n",
-      "  \"Resources\",\n",
-      "  \"semantic-fleet\",\n",
-      "  \"Semantic-kernel-AutoInteractive.ipynb\",\n",
-      "  \"START_HERE.txt\",\n",
-      "  \"Workbook-Template-Python.ipynb\",\n",
-      "  \"Workbook-Template.ipynb\",\n",
-      "  \"WorkbookInteractionBase.cs\",\n",
-      "  \"WorkbookUpdateInteraction.cs\",\n",
-      "  \"WorkbookValidation.cs\"\n",
-      "]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Test du plugin\n",
-    "from semantic_kernel.functions import KernelArguments\n",
-    "\n",
-    "# Lister les fichiers du repertoire courant\n",
-    "list_func = kernel.get_function(\"filesystem\", \"list_directory\")\n",
-    "result = await kernel.invoke(list_func, KernelArguments(path=\".\"))\n",
-    "\n",
-    "print(\"Fichiers dans le repertoire courant:\")\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a4498146",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exemple guidé 2 : Plugin MCP avec validation d'entrees\n",
-    "\n",
-    "*Contribution étudiante de Gabriel COMBE (@GabrielC-star) et Rémi LESANNE, PR #18553, intégrée comme exemple guidé.*\n",
-    "\n",
-    "Cet exemple durcit la lecture de fichiers : le plugin `ValidatedFilesystemPlugin` ne rend un fichier qu'après trois contrôles — le chemin résolu reste dans le répertoire autorisé (via `os.path.realpath` puis `os.path.commonpath`), le fichier existe, et sa taille reste sous `max_file_size`. Toute tentative de sortie du répertoire autorisé (attaque par *path traversal* telle que `../../etc/passwd`) lève une `ValueError` avant la moindre lecture."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "91032d36",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "# SemanticKernel - Microsoft Semantic Kernel\n",
-      "\n",
-      "<!-- CATALOG-STATUS\n",
-      "series: GenAI-SemanticKernel\n",
-      "pedag\n",
-      "Refuse comme attendu : Acces interdit : chemin en dehors du repertoire autorise\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exemple guide 2 : Plugin MCP avec validation d'entrees\n",
-    "# Contribution etudiante de Gabriel COMBE et Remi LESANNE (PR #18553)\n",
-    "class ValidatedFilesystemPlugin:\n",
-    "    \"\"\"\n",
-    "    Plugin pour lire des fichiers avec quelques verifications de securite.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self, root_path: str, max_file_size: int = 1_000_000):\n",
-    "        # On recupere le vrai chemin du dossier autorise\n",
-    "        self.root_path = os.path.realpath(root_path)\n",
-    "\n",
-    "        # Taille maximale autorisee pour un fichier\n",
-    "        self.max_file_size = max_file_size\n",
-    "    \n",
-    "    def _validate_path(self, path: str) -> str:\n",
-    "        # On construit le chemin complet du fichier\n",
-    "        full_path = os.path.realpath(\n",
-    "            os.path.join(self.root_path, path)\n",
-    "        )\n",
-    "\n",
-    "        # On verifie que le fichier reste bien dans le dossier autorise\n",
-    "        # Cela permet d'eviter les attaques avec ../../\n",
-    "        if os.path.commonpath([self.root_path, full_path]) != self.root_path:\n",
-    "            raise ValueError(\n",
-    "                \"Acces interdit : chemin en dehors du repertoire autorise\"\n",
-    "            )\n",
-    "\n",
-    "        # Si tout est bon, on retourne le chemin valide\n",
-    "        return full_path\n",
-    "    \n",
-    "    @kernel_function(description=\"Lit un fichier avec validation de securite\")\n",
-    "    def safe_read_file(self, path: str) -> str:\n",
-    "        \"\"\"Lire un fichier apres validation.\"\"\"\n",
-    "        \n",
-    "        # On verifie d'abord que le chemin est autorise\n",
-    "        full_path = self._validate_path(path)\n",
-    "\n",
-    "        # On verifie que le fichier existe vraiment\n",
-    "        if not os.path.isfile(full_path):\n",
-    "            raise FileNotFoundError(f\"Fichier introuvable : {path}\")\n",
-    "\n",
-    "        # On recupere la taille du fichier\n",
-    "        file_size = os.path.getsize(full_path)\n",
-    "\n",
-    "        # On refuse le fichier s'il est trop gros\n",
-    "        if file_size > self.max_file_size:\n",
-    "            raise ValueError(\n",
-    "                f\"Fichier trop volumineux : {file_size} octets\"\n",
-    "            )\n",
-    "\n",
-    "        # Si toutes les verifications passent, on lit le fichier\n",
-    "        with open(full_path, \"r\", encoding=\"utf-8\") as file:\n",
-    "            return file.read()\n",
-    "\n",
-    "\n",
-    "# Test du plugin\n",
-    "vplugin = ValidatedFilesystemPlugin(root_path=\".\")\n",
-    "\n",
-    "# Lecture normale d'un fichier autorise\n",
-    "print(vplugin.safe_read_file(\"README.md\")[:100])\n",
-    "\n",
-    "# Test d'une tentative de sortir du dossier autorise\n",
-    "# Cette ligne doit provoquer une erreur\n",
-    "try:\n",
-    "    print(vplugin.safe_read_file(\"../../etc/passwd\"))\n",
-    "except ValueError as e:\n",
-    "    print(f\"Refuse comme attendu : {e}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-eg2-lecture",
-   "metadata": {},
-   "source": [
-    "### Lecture du résultat — exemple guidé 2 (garde-fou de fichiers)\n",
-    "\n",
-    "- La lecture légitime passe : les 100 premiers caractères de `README.md` s'affichent (titre « # SemanticKernel - Microsoft Semantic Kernel », suivi du bloc `<!-- CATALOG-STATUS`).\n",
-    "- La tentative d'évasion `../../etc/passwd` est refusée sans faire planter le notebook : `Refuse comme attendu : Acces interdit : chemin en dehors du repertoire autorise`.\n",
-    "- C'est `os.path.commonpath` qui tient le rôle de garde-fou : il compare les **composants** du chemin résolu avec `root_path`. Un contrôle naïf `str.startswith` comparerait des caractères, et un fichier de `/data_secret` passerait un test `startswith(\"/data\")` alors que ce n'est pas le même dossier — l'exercice 2 creuse précisément ce piège."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-ex2-attaque-md",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exercice 2 : Attaquer le garde-fou\n",
-    "\n",
-    "L'exemple guidé 2 protège un répertoire racine avec `os.path.commonpath`. Un garde-fou ne mérite ce nom qu'une fois attaqué : ici, vous montez un faux système de fichiers (`data/` et son voisin `data_secret/`), vous lancez une batterie de chemins hostiles contre `ValidatedFilesystemPlugin`, et vous comparez avec un validateur naïf fondé sur `str.startswith`.\n",
-    "\n",
-    "**Objectif** : montrer, tableaux à l'appui, que (1) le plugin refuse toutes les évasions proposées, et (2) le contrôle naïf en accepte au moins une, à cause du piège des préfixes (`/data` est un préfixe de `/data_secret` alors que ce ne sont pas les mêmes dossiers).\n",
-    "\n",
-    "**Étapes** :\n",
-    "1. `# Étape 1` : dans un `tempfile.TemporaryDirectory()`, créer `data/` contenant un fichier lisible, et un répertoire voisin `data_secret/` contenant un fichier\n",
-    "2. `# Étape 2` : instancier `ValidatedFilesystemPlugin(root_path=<chemin de data>)` et lancer contre lui les chemins hostiles : `../data_secret/x.txt`, un chemin absolu vers `data_secret/x.txt`, `sous/../../data_secret/x.txt`, et un lien symbolique créé dans `data/` pointant vers l'extérieur (si la création du lien est refusée, par exemple sous Windows sans mode développeur, afficher une note et passer au suivant)\n",
-    "3. `# Étape 3` : écrire `valide_naif(root, path)` qui fait `os.path.realpath(os.path.join(root, path)).startswith(root)` et le passer sur la même batterie\n",
-    "4. `# Étape 4` : afficher un tableau chemin → verdict (plugin / naïf) et nommer le chemin qui sépare les deux validateurs\n",
-    "\n",
-    "**Indices** :\n",
-    "- `# Indice` : attraper la `ValueError` du plugin — un refus est un verdict à afficher, pas une erreur qui fait planter le notebook\n",
-    "- `# Indice` : `os.path.commonpath` compare des composants de chemin, `str.startswith` compare des caractères — c'est là que se joue le piège des préfixes\n",
-    "\n",
-    "**Critère de réussite** : le tableau montre chaque chemin hostile refusé par le plugin, et au moins un chemin que `valide_naif` accepte alors que le plugin le refuse."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "mcp-ex2-attaque-code",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Exercice a completer\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exercice 2 : Attaquer le garde-fou\n",
-    "# TODO etudiant : construire le harnais d'attaque, puis decommenter le bloc\n",
-    "\n",
-    "import os\n",
-    "import tempfile\n",
-    "\n",
-    "\n",
-    "def valide_naif(root: str, path: str) -> bool:\n",
-    "    \"\"\"Validation naive par prefixe de chaine de caracteres.\"\"\"\n",
-    "    # Etape 3 : joindre, resoudre, puis comparer avec startswith\n",
-    "    return None  # TODO etudiant\n",
-    "\n",
-    "\n",
-    "# Etape 1 : monter le faux systeme de fichiers dans un dossier temporaire\n",
-    "# with tempfile.TemporaryDirectory() as tmp:\n",
-    "#     data = os.path.join(tmp, \"data\")           # TODO etudiant : creer data/ + un fichier\n",
-    "#     secret = os.path.join(tmp, \"data_secret\")  # TODO etudiant : creer le voisin + un fichier\n",
-    "#     plugin_attaque = ValidatedFilesystemPlugin(root_path=data)\n",
-    "\n",
-    "#     # Etape 2 : batterie de chemins hostiles\n",
-    "#     attaques = [\n",
-    "#         \"../data_secret/x.txt\",\n",
-    "#         os.path.join(secret, \"x.txt\"),      # chemin absolu\n",
-    "#         \"sous/../../data_secret/x.txt\",\n",
-    "#         \"lien.txt\",                         # lien symbolique vers l'exterieur\n",
-    "#     ]\n",
-    "\n",
-    "#     # Etape 4 : tableau chemin -> verdict (plugin / naif)\n",
-    "#     for chemin in attaques:\n",
-    "#         try:\n",
-    "#             plugin_attaque.safe_read_file(chemin)\n",
-    "#             verdict_plugin = \"accepte\"\n",
-    "#         except (ValueError, FileNotFoundError):\n",
-    "#             verdict_plugin = \"refuse\"\n",
-    "#         verdict_naif = valide_naif(data, chemin)\n",
-    "#         print(f\"{chemin:40s} plugin={verdict_plugin}  naif={verdict_naif}\")\n",
-    "\n",
-    "print(\"Exercice a completer\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "523a9282",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 5. Bridge Agent Framework ↔ MCP\n",
-    "\n",
-    "Integrons les outils MCP avec l'Agent Framework."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "1dfa962e",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Agent avec outils MCP cree\n",
-      "Outils disponibles: filesystem.read_file, filesystem.list_directory, filesystem.write_file\n"
-     ]
-    }
-   ],
-   "source": [
-    "from semantic_kernel.agents import ChatCompletionAgent\n",
-    "from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion\n",
-    "from semantic_kernel.connectors.ai import FunctionChoiceBehavior\n",
-    "from semantic_kernel.contents import ChatHistory\n",
-    "\n",
-    "# Configuration du kernel avec MCP plugin\n",
-    "kernel_with_mcp = Kernel()\n",
-    "kernel_with_mcp.add_service(OpenAIChatCompletion(service_id=\"agent\"))\n",
-    "kernel_with_mcp.add_plugin(MCPFilesystemPlugin(root_path=\".\"), plugin_name=\"filesystem\")\n",
-    "\n",
-    "# Configuration du function calling\n",
-    "settings = kernel_with_mcp.get_prompt_execution_settings_from_service_id(\"agent\")\n",
-    "settings.function_choice_behavior = FunctionChoiceBehavior.Auto()\n",
-    "\n",
-    "# Creation de l'agent avec acces MCP\n",
-    "agent = ChatCompletionAgent(\n",
-    "    kernel=kernel_with_mcp,\n",
-    "    name=\"FileAssistant\",\n",
-    "    instructions=\"\"\"Tu es un assistant qui peut lire et manipuler des fichiers.\n",
-    "    Utilise les outils filesystem pour repondre aux demandes de l'utilisateur.\n",
-    "    Decris ce que tu fais avant chaque action.\"\"\",\n",
-    "    arguments=KernelArguments(settings=settings)\n",
-    ")\n",
-    "\n",
-    "print(\"Agent avec outils MCP cree\")\n",
-    "print(f\"Outils disponibles: filesystem.read_file, filesystem.list_directory, filesystem.write_file\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "80c96bf1",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "User: Liste les fichiers Python dans le repertoire courant\n",
-      "----------------------------------------\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Agent: Je vais parcourir le répertoire courant et filtrer les fichiers se terminant par .py.\n",
-      "\n",
-      "Résultat : aucun fichier Python (.py) trouvé dans le répertoire courant.\n",
-      "\n",
-      "Souhaitez-vous que je :\n",
-      "- recherche récursivement dans les sous-répertoires, ou\n",
-      "- liste les notebooks (.ipynb) ou autres types de fichiers présents ?\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Test de l'agent avec MCP\n",
-    "async def test_mcp_agent(query: str):\n",
-    "    \"\"\"Teste l'agent avec une requete.\"\"\"\n",
-    "    chat_history = ChatHistory()\n",
-    "    chat_history.add_user_message(query)\n",
-    "    \n",
-    "    print(f\"User: {query}\")\n",
-    "    print(\"-\" * 40)\n",
-    "    \n",
-    "    async for content in agent.invoke(chat_history):\n",
-    "        if hasattr(content, 'content') and content.content:\n",
-    "            print(f\"Agent: {content.content}\")\n",
-    "\n",
-    "# Test\n",
-    "try:\n",
-    "    await test_mcp_agent(\"Liste les fichiers Python dans le repertoire courant\")\n",
-    "except Exception as e:\n",
-    "    print(f\"Erreur: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a4db3a53",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exemple guidé 3 : Agent multi-outils avec capacites combinees\n",
-    "\n",
-    "*Contribution étudiante de Gabriel COMBE (@GabrielC-star) et Rémi LESANNE, PR #18553, intégrée comme exemple guidé.*\n",
-    "\n",
-    "Cet exemple construit le plugin `DirectoryAnalyzerPlugin`, qui expose deux `@kernel_function` : `count_files_by_extension()` parcourt récursivement un répertoire avec `os.walk` et compte les fichiers par extension, et `get_directory_tree()` retourne l'arborescence limitée en profondeur. Les deux retournent une string JSON, le format qu'un LLM sait interpréter lors d'un appel d'outil."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "8f31852c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\n",
-      "  \".ipynb\": 21,\n",
-      "  \".cs\": 12,\n",
-      "  \".md\": 3,\n",
-      "  \".txt\": 53,\n",
-      "  \"sans_extension\": 1,\n",
-      "  \".json\": 53,\n",
-      "  \".yaml\": 1\n",
-      "}\n",
-      "[\n",
-      "  {\n",
-      "    \"directory\": \".\",\n",
-      "    \"files\": [\n",
-      "      \"01-SemanticKernel-Intro.ipynb\",\n",
-      "      \"02-SemanticKernel-Advanced.ipynb\",\n",
-      "      \"03-SemanticKernel-Agents.ipynb\",\n",
-      "      \"04-SemanticKernel-Filters-Observability.ipynb\",\n",
-      "      \"05-SemanticKernel-VectorStores.ipynb\",\n",
-      "      \"06-SemanticKernel-ProcessFramework.ipynb\",\n",
-      "      \"07-SemanticKernel-MultiModal.ipynb\",\n",
-      "      \"08-SemanticKernel-MCP.ipynb\",\n",
-      "      \"09-SemanticKernel-Building-CLR.ipynb\",\n",
-      "      \"10-SemanticKernel-NotebookMaker.ipynb\",\n",
-      "      \"10a-SemanticKernel-NotebookMaker-batch.ipynb\",\n",
-      "      \"10b-SemanticKernel-NotebookMaker-batch-parameterized.ipynb\",\n",
-      "      \"11-SemanticKernel-A2A.ipynb\",\n",
-      "      \"AutoGenNotebookUpdater.cs\",\n",
-      "      \"AutoInvokeSKAgentsNotebookUpdater.cs\",\n",
-      "      \"Cr\\u00e9ateur de mail personnalis\\u00e9.ipynb\",\n",
-      "      \"DisplayLogger.cs\",\n",
-      "      \"DisplayLoggerProvider.cs\",\n",
-      "      \"fort-boyard-csharp.ipynb\",\n",
-      "      \"fort-boyard-python.ipynb\",\n",
-      "      \"GuessingGame.cs\",\n",
-      "      \"MANIFEST.md\",\n",
-      "      \"Notebook-Generated.ipynb\",\n",
-      "      \"Notebook-Template.ipynb\",\n",
-      "      \"NotebookExecutor.cs\",\n",
-      "      \"NotebookPlannerUpdater.cs\",\n",
-      "      \"NotebookUpdaterBase.cs\",\n",
-      "      \"README.md\",\n",
-      "      \"Semantic-kernel-AutoInteractive.ipynb\",\n",
-      "      \"START_HERE.txt\",\n",
-      "      \"Workbook-Template-Python.ipynb\",\n",
-      "      \"Workbook-Template.ipynb\",\n",
-      "      \"WorkbookInteractionBase.cs\",\n",
-      "      \"WorkbookUpdateInteraction.cs\",\n",
-      "      \"WorkbookValidation.cs\"\n",
-      "    ]\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"aspire-otel\",\n",
-      "    \"files\": [\n",
-      "      \"README.md\"\n",
-      "    ]\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"aspire-otel\\\\SkOtel.AppHost\",\n",
-      "    \"files\": [\n",
-      "      \".gitignore\",\n",
-      "      \"apphost.cs\",\n",
-      "      \"apphost.run.json\",\n",
-      "      \"aspire.config.json\"\n",
-      "    ]\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\CalendarPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\ChatPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\ChildrensBookPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\ClassificationPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\CodingPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\FunPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\GroundingPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\IntentDetectionPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\MiscPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\QAPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\SummarizePlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"prompt_template_samples\\\\WriterPlugin\",\n",
-      "    \"files\": []\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"Resources\",\n",
-      "    \"files\": [\n",
-      "      \"generate_plan.yaml\",\n",
-      "      \"StepPrompt.txt\"\n",
-      "    ]\n",
-      "  },\n",
-      "  {\n",
-      "    \"directory\": \"semantic-fleet\",\n",
-      "    \"files\": []\n",
-      "  }\n",
-      "]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exemple guide 3 : Agent multi-outils avec capacites combinees\n",
-    "# Contribution etudiante de Gabriel COMBE et Remi LESANNE (PR #18553)\n",
-    "import os\n",
-    "import json\n",
-    "\n",
-    "\n",
-    "class DirectoryAnalyzerPlugin:\n",
-    "    \"\"\"\n",
-    "    Plugin SK pour analyser recursivement un repertoire.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    @kernel_function(description=\"Compte les fichiers par extension dans un repertoire\")\n",
-    "    def count_files_by_extension(self, path: str = \".\") -> str:\n",
-    "        \"\"\"Lister les extensions et leur nombre.\"\"\"\n",
-    "\n",
-    "        # Dictionnaire pour stocker le nombre de fichiers par extension\n",
-    "        extensions = {}\n",
-    "\n",
-    "        # os.walk permet de parcourir tous les sous-dossiers\n",
-    "        for root, dirs, files in os.walk(path):\n",
-    "\n",
-    "            # On parcourt tous les fichiers trouves\n",
-    "            for file in files:\n",
-    "\n",
-    "                # On recupere l'extension du fichier\n",
-    "                extension = os.path.splitext(file)[1]\n",
-    "\n",
-    "                # Si le fichier n'a pas d'extension\n",
-    "                if extension == \"\":\n",
-    "                    extension = \"sans_extension\"\n",
-    "\n",
-    "                # On ajoute 1 pour cette extension\n",
-    "                if extension in extensions:\n",
-    "                    extensions[extension] += 1\n",
-    "                else:\n",
-    "                    extensions[extension] = 1\n",
-    "\n",
-    "        # On retourne le resultat en JSON\n",
-    "        return json.dumps(extensions, indent=2)\n",
-    "\n",
-    "\n",
-    "    @kernel_function(description=\"Retourne l'arborescence d'un repertoire\")\n",
-    "    def get_directory_tree(self, path: str = \".\", max_depth: int = 2) -> str:\n",
-    "        \"\"\"Construire un arbre de repertoires.\"\"\"\n",
-    "\n",
-    "        tree = []\n",
-    "\n",
-    "        # On transforme le chemin en chemin absolu\n",
-    "        base_path = os.path.abspath(path)\n",
-    "\n",
-    "        # Parcours recursif du repertoire\n",
-    "        for root, dirs, files in os.walk(base_path):\n",
-    "\n",
-    "            # On calcule la profondeur actuelle\n",
-    "            relative_path = os.path.relpath(root, base_path)\n",
-    "\n",
-    "            if relative_path == \".\":\n",
-    "                depth = 0\n",
-    "            else:\n",
-    "                depth = relative_path.count(os.sep) + 1\n",
-    "\n",
-    "            # On limite la profondeur\n",
-    "            if depth > max_depth:\n",
-    "                dirs[:] = []\n",
-    "                continue\n",
-    "\n",
-    "            # Informations du dossier actuel\n",
-    "            directory_info = {\n",
-    "                \"directory\": relative_path,\n",
-    "                \"files\": files\n",
-    "            }\n",
-    "\n",
-    "            tree.append(directory_info)\n",
-    "\n",
-    "        # Retour du resultat sous forme JSON\n",
-    "        return json.dumps(tree, indent=2)\n",
-    "\n",
-    "\n",
-    "# Test\n",
-    "analyzer = DirectoryAnalyzerPlugin()\n",
-    "\n",
-    "print(analyzer.count_files_by_extension(\".\"))\n",
-    "\n",
-    "print(analyzer.get_directory_tree(\".\", 2))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-eg3-lecture",
-   "metadata": {},
-   "source": [
-    "### Lecture du résultat — exemple guidé 3 (analyseur de répertoire)\n",
-    "\n",
-    "- Le compte récursif donne `.ipynb: 21`, `.txt: 53`, `.json: 53`, `.cs: 12`, `.md: 3`, `.yaml: 1` et `sans_extension: 1` — davantage que les seuls fichiers du dossier courant, puisque `os.walk` descend dans tous les sous-dossiers.\n",
-    "- L'arborescence est plafonnée à `max_depth = 2` : le dossier `.` et deux niveaux de descente apparaissent (`aspire-otel` puis `aspire-otel\\SkOtel.AppHost`, `prompt_template_samples` puis ses 12 sous-dossiers vides, `Resources`, `semantic-fleet`), sans aller plus bas.\n",
-    "- Ces comptes décrivent le dossier **au moment de l'exécution** : relancé depuis un autre dossier, ou après l'ajout ou le retrait d'un fichier, l'exemple imprimera d'autres nombres."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mcp-ex3-agent-md",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Exercice 3 : Faire appeler le plugin par l'agent, puis verifier sa reponse\n",
-    "\n",
-    "L'exemple guidé 3 expose `DirectoryAnalyzerPlugin` et ses deux `@kernel_function`, mais personne ne les appelle par la voie normale : les tests appellent les méthodes directement, en Python. L'étape manquante est celle de la section 5 — faire choisir et invoquer l'outil par le LLM — suivie d'une vérification honnête de ce qu'il répond.\n",
-    "\n",
-    "**Objectif** : enregistrer `DirectoryAnalyzerPlugin` dans un `Kernel` avec function calling automatique (sur le modèle des cellules de la section 5), poser la question « Combien de notebooks .ipynb y a-t-il dans ce dossier ? », puis (a) vérifier dans l'historique que `count_files_by_extension` a bien été appelée par l'agent, (b) comparer le nombre annoncé à un appel direct de `count_files_by_extension(\".\")`.\n",
-    "\n",
-    "**Étapes** :\n",
-    "1. `# Étape 1` : construire kernel et agent comme en section 5 (`OpenAIChatCompletion`, `FunctionChoiceBehavior.Auto()`, `ChatCompletionAgent`) avec le plugin enregistré sous le nom `analyzer`\n",
-    "2. `# Étape 2` : invoquer l'agent avec la question, en conservant le `ChatHistory`\n",
-    "3. `# Étape 3` : parcourir l'historique pour y trouver un `FunctionCallContent` portant le nom `analyzer-count_files_by_extension`\n",
-    "4. `# Étape 4` : appeler directement `analyzer_plugin.count_files_by_extension(\".\")`, relire le JSON (clé `\".ipynb\"`), et afficher : appelé oui/non, nombre de l'agent, nombre direct, accord ou désaccord\n",
-    "\n",
-    "**Indices** :\n",
-    "- `# Indice` : `FunctionCallContent` s'importe de `semantic_kernel.contents` ; les items d'un message de l'historique sont dans `message.items`\n",
-    "- `# Indice` : le plugin retourne une string JSON — `json.loads(...)` pour retrouver le compte `\".ipynb\"`\n",
-    "- `# Indice` : l'appel direct ne passe pas par le LLM : c'est la référence qui sert à détecter si l'agent hallucine\n",
-    "\n",
-    "**Critère de réussite** : la cellule affiche `Appele : oui/non`, les deux nombres (agent / appel direct) et leur accord ou désaccord."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "mcp-ex3-agent-code",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Exercice a completer\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exercice 3 : Faire appeler le plugin par l'agent, puis verifier sa reponse\n",
-    "# TODO etudiant : completer le harnais ci-dessous (modele : section 5)\n",
-    "\n",
-    "# Etape 1 : kernel + agent avec function calling automatique\n",
-    "# from semantic_kernel import Kernel\n",
-    "# from semantic_kernel.agents import ChatCompletionAgent\n",
-    "# from semantic_kernel.connectors.ai import FunctionChoiceBehavior\n",
-    "# from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion\n",
-    "# from semantic_kernel.contents import ChatHistory, FunctionCallContent\n",
-    "# from semantic_kernel.functions import KernelArguments\n",
-    "#\n",
-    "# analyzer_plugin = DirectoryAnalyzerPlugin()\n",
-    "# kernel_analyzer = Kernel()\n",
-    "# kernel_analyzer.add_service(OpenAIChatCompletion(service_id=\"analyzer\"))\n",
-    "# kernel_analyzer.add_plugin(analyzer_plugin, plugin_name=\"analyzer\")\n",
-    "# settings_analyzer = kernel_analyzer.get_prompt_execution_settings_from_service_id(\"analyzer\")\n",
-    "# settings_analyzer.function_choice_behavior = FunctionChoiceBehavior.Auto()\n",
-    "# agent_analyzer = ChatCompletionAgent(\n",
-    "#     kernel=kernel_analyzer,\n",
-    "#     name=\"DirectoryAssistant\",\n",
-    "#     instructions=\"Tu reponds en utilisant les outils du plugin analyzer.\",\n",
-    "#     arguments=KernelArguments(settings=settings_analyzer),\n",
-    "# )\n",
-    "\n",
-    "# Etape 2 : poser la question et garder l'historique\n",
-    "# history_analyzer = ChatHistory()\n",
-    "# history_analyzer.add_user_message(\"Combien de notebooks .ipynb y a-t-il dans ce dossier ?\")\n",
-    "# async for content in agent_analyzer.invoke(history_analyzer):\n",
-    "#     if content.content:\n",
-    "#         print(f\"Agent: {content.content}\")\n",
-    "\n",
-    "# Etape 3 : verifier que la fonction a bien ete appelee\n",
-    "# appele = False  # TODO etudiant : parcourir history_analyzer -> message.items -> FunctionCallContent\n",
-    "# print(f\"Appele : {'oui' if appele else 'non'}\")\n",
-    "\n",
-    "# Etape 4 : appel direct de reference et comparaison\n",
-    "# import json\n",
-    "# direct = json.loads(analyzer_plugin.count_files_by_extension(\".\"))\n",
-    "# nombre_direct = direct.get(\".ipynb\")\n",
-    "# nombre_agent = None  # TODO etudiant : extraire le nombre annonce par l'agent\n",
-    "# print(f\"Appel direct : {nombre_direct} notebooks .ipynb\")\n",
-    "# print(f\"Accord : {'oui' if nombre_agent == nombre_direct else 'non'}\")\n",
-    "\n",
-    "print(\"Exercice a completer\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1y2coc9ss5v",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Interprétation : Agent autonome avec MCP\n",
-    "\n",
-    "**Requête utilisateur** : \"Liste les fichiers Python dans le répertoire courant\"\n",
-    "\n",
-    "**Résultat obtenu** : L'agent identifie 19 notebooks `.ipynb` (contenant du Python) au lieu de fichiers `.py`\n",
-    "\n",
-    "| Étape | Action de l'agent | Outil utilisé |\n",
-    "|-------|-------------------|---------------|\n",
-    "| 1 | Analyse de la requête | LLM (GPT-4) |\n",
-    "| 2 | Appel `list_directory(path=\".\")` | MCP filesystem |\n",
-    "| 3 | Filtrage des fichiers Python | Logique LLM |\n",
-    "| 4 | Détection des notebooks `.ipynb` | Inference contextuelle |\n",
-    "| 5 | Réponse structurée avec suggestions | Génération LLM |\n",
-    "\n",
-    "**Comportement intelligent** :\n",
-    "\n",
-    "1. **Interprétation sémantique** : \"fichiers Python\" → inclut les notebooks Jupyter\n",
-    "2. **Correction proactive** : Absence de `.py` → liste les `.ipynb` pertinents\n",
-    "3. **Suggestion next-step** : \"Si tu veux explorer l'un de ces fichiers...\"\n",
-    "\n",
-    "**Pattern de décision (FunctionChoiceBehavior.Auto)** :\n",
-    "\n",
-    "```\n",
-    "User Query\n",
-    "    ↓\n",
-    "LLM Decision: \"Je dois lister les fichiers\"\n",
-    "    ↓\n",
-    "Tool Sélection: filesystem.list_directory\n",
-    "    ↓\n",
-    "Exécution: list_directory(path=\".\")\n",
-    "    ↓\n",
-    "LLM Filtering: \"Python files = .py + .ipynb\"\n",
-    "    ↓\n",
-    "Response Generation\n",
-    "```\n",
-    "\n",
-    "**Points clés** :\n",
-    "\n",
-    "1. **Autonomie** : L'agent choisit automatiquement `list_directory` sans instruction explicite\n",
-    "2. **Contextualisation** : Le LLM comprend que les notebooks Jupyter sont des \"fichiers Python\"\n",
-    "3. **Robustesse** : Absence de `.py` → réponse adaptée, pas d'erreur\n",
-    "4. **Conversation naturelle** : Ton professionnel, suggestions proactives\n",
-    "\n",
-    "**Comparaison avec un script classique** :\n",
-    "\n",
-    "| Approche | Flexibilité | Code requis | Adaptation contexte |\n",
-    "|----------|-------------|-------------|---------------------|\n",
-    "| Script Python | Faible | 20-30 lignes | Non |\n",
-    "| Agent MCP | Élevée | 10 lignes (config) | Oui |\n",
-    "\n",
-    "**Cas d'usage réels** :\n",
-    "- Assistant DevOps : \"Trouve les fichiers de config modifiés cette semaine\"\n",
-    "- Data scientist : \"Charge le dernier notebook d'analyse de sentiment\"\n",
-    "- QA : \"Liste les tests qui ont échoué hier\"\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "37768d31",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 6. Créer un serveur MCP personnalise\n",
-    "\n",
-    "Pour exposer vos propres outils via MCP."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "45fb5040",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Exemple de serveur MCP personnalise:\n",
-      "============================================================\n",
-      "\n",
-      "from mcp.server import Server, NotificationOptions\n",
-      "from mcp.server.models import InitializationOptions\n",
-      "import mcp.server.stdio\n",
-      "import mcp.types as types\n",
-      "\n",
-      "# Creation du serveur\n",
-      "server = Server(\"my-business-tools\")\n",
-      "\n",
-      "@server.list_tools()\n",
-      "async def handle_list_tools() -> list[types.Tool]:\n",
-      "    \"\"\"Liste les outils disponibles.\"\"\"\n",
-      "    return [\n",
-      "        types.Tool(\n",
-      "            name=\"calculate_price\",\n",
-      "            description=\"Calcule le prix avec remise\",\n",
-      "            inputSchema={\n",
-      "                \"type\": \"object\",\n",
-      "                \"properties\": {\n",
-      "                    \"base_price\": {\"type\": \"number\"},\n",
-      "                    \"discount_percent\": {\"type\": \"number\"}\n",
-      "                },\n",
-      "                \"required\": [\"base_price\"]\n",
-      "            }\n",
-      "        ),\n",
-      "        types.Tool(\n",
-      "            name=\"check_inventory\",\n",
-      "            description=\"Verifie le stock d'un produit\",\n",
-      "            inputSchema={\n",
-      "                \"type\": \"object\",\n",
-      "                \"properties\": {\n",
-      "                    \"product_id\": {\"type\": \"string\"}\n",
-      "                },\n",
-      "                \"required\": [\"product_id\"]\n",
-      "            }\n",
-      "        )\n",
-      "    ]\n",
-      "\n",
-      "@server.call_tool()\n",
-      "async def handle_call_tool(\n",
-      "    name: str, \n",
-      "    arguments: dict\n",
-      ") -> list[types.TextContent]:\n",
-      "    \"\"\"Execute un outil.\"\"\"\n",
-      "    if name == \"calculate_price\":\n",
-      "        base = arguments[\"base_price\"]\n",
-      "        discount = arguments.get(\"discount_percent\", 0)\n",
-      "        final = base * (1 - discount/100)\n",
-      "        return [types.TextContent(type=\"text\", text=f\"Prix final: {final:.2f}\")]\n",
-      "    \n",
-      "    elif name == \"check_inventory\":\n",
-      "        # Simulation de verification de stock\n",
-      "        product_id = arguments[\"product_id\"]\n",
-      "        stock = 42  # Valeur simulee\n",
-      "        return [types.TextContent(type=\"text\", text=f\"Stock de {product_id}: {stock} unites\")]\n",
-      "    \n",
-      "    return [types.TextContent(type=\"text\", text=\"Outil non reconnu\")]\n",
-      "\n",
-      "async def main():\n",
-      "    async with mcp.server.stdio.stdio_server() as (read, write):\n",
-      "        await server.run(\n",
-      "            read, write,\n",
-      "            InitializationOptions(\n",
-      "                server_name=\"my-business-tools\",\n",
-      "                server_version=\"1.0.0\"\n",
-      "            )\n",
-      "        )\n",
-      "\n",
-      "if __name__ == \"__main__\":\n",
-      "    import asyncio\n",
-      "    asyncio.run(main())\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Exemple de serveur MCP en Python (conceptuel)\n",
-    "# Necessite le package 'mcp'\n",
-    "\n",
-    "server_code = '''\n",
-    "from mcp.server import Server, NotificationOptions\n",
-    "from mcp.server.models import InitializationOptions\n",
-    "import mcp.server.stdio\n",
-    "import mcp.types as types\n",
-    "\n",
-    "# Creation du serveur\n",
-    "server = Server(\"my-business-tools\")\n",
-    "\n",
-    "@server.list_tools()\n",
-    "async def handle_list_tools() -> list[types.Tool]:\n",
-    "    \"\"\"Liste les outils disponibles.\"\"\"\n",
-    "    return [\n",
-    "        types.Tool(\n",
-    "            name=\"calculate_price\",\n",
-    "            description=\"Calcule le prix avec remise\",\n",
-    "            inputSchema={\n",
-    "                \"type\": \"object\",\n",
-    "                \"properties\": {\n",
-    "                    \"base_price\": {\"type\": \"number\"},\n",
-    "                    \"discount_percent\": {\"type\": \"number\"}\n",
-    "                },\n",
-    "                \"required\": [\"base_price\"]\n",
-    "            }\n",
-    "        ),\n",
-    "        types.Tool(\n",
-    "            name=\"check_inventory\",\n",
-    "            description=\"Verifie le stock d\\'un produit\",\n",
-    "            inputSchema={\n",
-    "                \"type\": \"object\",\n",
-    "                \"properties\": {\n",
-    "                    \"product_id\": {\"type\": \"string\"}\n",
-    "                },\n",
-    "                \"required\": [\"product_id\"]\n",
-    "            }\n",
-    "        )\n",
-    "    ]\n",
-    "\n",
-    "@server.call_tool()\n",
-    "async def handle_call_tool(\n",
-    "    name: str, \n",
-    "    arguments: dict\n",
-    ") -> list[types.TextContent]:\n",
-    "    \"\"\"Execute un outil.\"\"\"\n",
-    "    if name == \"calculate_price\":\n",
-    "        base = arguments[\"base_price\"]\n",
-    "        discount = arguments.get(\"discount_percent\", 0)\n",
-    "        final = base * (1 - discount/100)\n",
-    "        return [types.TextContent(type=\"text\", text=f\"Prix final: {final:.2f}\")]\n",
-    "    \n",
-    "    elif name == \"check_inventory\":\n",
-    "        # Simulation de verification de stock\n",
-    "        product_id = arguments[\"product_id\"]\n",
-    "        stock = 42  # Valeur simulee\n",
-    "        return [types.TextContent(type=\"text\", text=f\"Stock de {product_id}: {stock} unites\")]\n",
-    "    \n",
-    "    return [types.TextContent(type=\"text\", text=\"Outil non reconnu\")]\n",
-    "\n",
-    "async def main():\n",
-    "    async with mcp.server.stdio.stdio_server() as (read, write):\n",
-    "        await server.run(\n",
-    "            read, write,\n",
-    "            InitializationOptions(\n",
-    "                server_name=\"my-business-tools\",\n",
-    "                server_version=\"1.0.0\"\n",
-    "            )\n",
-    "        )\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    import asyncio\n",
-    "    asyncio.run(main())\n",
-    "'''\n",
-    "\n",
-    "print(\"Exemple de serveur MCP personnalise:\")\n",
-    "print(\"=\" * 60)\n",
-    "print(server_code)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "xp77qq3uzr",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Interprétation : Anatomie d'un serveur MCP personnalisé\n",
-    "\n",
-    "**Serveur créé** : `my-business-tools` avec 2 outils métier (calculate_price, check_inventory)\n",
-    "\n",
-    "| Composant | Rôle | Code clé |\n",
-    "|-----------|------|----------|\n",
-    "| **Server** | Instance du serveur MCP | `Server(\"my-business-tools\")` |\n",
-    "| **@list_tools** | Déclaration des outils disponibles | `types.Tool(name, description, inputSchema)` |\n",
-    "| **@call_tool** | Logique d'exécution | `handle_call_tool(name, arguments)` |\n",
-    "| **stdio_server** | Transport (stdin/stdout) | `mcp.server.stdio.stdio_server()` |\n",
-    "\n",
-    "**Schéma du flux** :\n",
-    "\n",
-    "```\n",
-    "Client (Claude Code, SK)\n",
-    "    ↓ Request via stdio\n",
-    "┌─────────────────────────────────┐\n",
-    "│  MCP Server Process             │\n",
-    "│  ┌───────────────────────────┐  │\n",
-    "│  │ @list_tools()             │  │  → Déclaration\n",
-    "│  │  - calculate_price        │  │\n",
-    "│  │  - check_inventory        │  │\n",
-    "│  └───────────────────────────┘  │\n",
-    "│  ┌───────────────────────────┐  │\n",
-    "│  │ @call_tool()              │  │  → Exécution\n",
-    "│  │  if name == \"calculate\":  │  │\n",
-    "│  │    return result          │  │\n",
-    "│  └───────────────────────────┘  │\n",
-    "└─────────────────────────────────┘\n",
-    "    ↓ Response via stdio\n",
-    "Client receives result\n",
-    "```\n",
-    "\n",
-    "**InputSchema (JSON Schema)** :\n",
-    "\n",
-    "| Champ | Type | Required | Description |\n",
-    "|-------|------|----------|-------------|\n",
-    "| `base_price` | number | ✓ | Prix de base |\n",
-    "| `discount_percent` | number | - | Remise (défaut: 0) |\n",
-    "| `product_id` | string | ✓ | Identifiant produit |\n",
-    "\n",
-    "**Points clés** :\n",
-    "\n",
-    "1. **Déclaratif** : Les outils sont déclarés via JSON Schema (validation automatique)\n",
-    "2. **Type-safe** : Les arguments sont validés avant l'appel\n",
-    "3. **Stateless** : Chaque appel est indépendant (serveur sans état)\n",
-    "4. **Async by default** : Toutes les fonctions sont `async` (support concurrence)\n",
-    "\n",
-    "**Avantages du pattern MCP** :\n",
-    "\n",
-    "| Avantage | Description |\n",
-    "|----------|-------------|\n",
-    "| **Réutilisable** | Le serveur fonctionne avec Claude Code, SK, LangChain, etc. |\n",
-    "| **Testable** | Les outils peuvent être testés indépendamment du LLM |\n",
-    "| **Versionnable** | `server_version=\"1.0.0\"` permet la compatibilité |\n",
-    "| **Découvrable** | `@list_tools` expose automatiquement les capacités |\n",
-    "\n",
-    "**Cas d'usage typiques** :\n",
-    "\n",
-    "- **E-commerce** : calculate_price, check_inventory, process_order\n",
-    "- **CRM** : get_customer, update_contact, create_ticket\n",
-    "- **Analytics** : query_metrics, generate_report, export_data\n",
-    "- **DevOps** : deploy_service, rollback, check_health\n",
-    "\n",
-    "**Déploiement** :\n",
-    "\n",
-    "```bash\n",
-    "# Développement local\n",
-    "python -m my_server.server\n",
-    "\n",
-    "# Production (systemd, Docker)\n",
-    "ExecStart=/usr/bin/python3 -m my_server.server\n",
-    "```\n",
-    "\n",
-    "**Sécurité** : Dans un environnement réel, ajouter :\n",
-    "- Authentification (Bearer token)\n",
-    "- Rate limiting\n",
-    "- Validation métier des inputs\n",
-    "- Logging des appels\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9742a234",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "### Structure d'un serveur MCP\n",
-    "\n",
-    "```\n",
-    "my-mcp-server/\n",
-    "├── pyproject.toml       # Configuration du package\n",
-    "├── src/\n",
-    "│   └── my_server/\n",
-    "│       ├── __init__.py\n",
-    "│       └── server.py    # Logique du serveur\n",
-    "└── README.md\n",
-    "```\n",
-    "\n",
-    "### Configuration dans Claude Code\n",
-    "\n",
-    "```json\n",
-    "{\n",
-    "  \"mcpServers\": {\n",
-    "    \"my-business-tools\": {\n",
-    "      \"command\": \"python\",\n",
-    "      \"args\": [\"-m\", \"my_server.server\"]\n",
-    "    }\n",
-    "  }\n",
-    "}\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "71ab9a92",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## 7. MCP dans notre infrastructure\n",
-    "\n",
-    "Notre repository utilise déjà MCP pour certaines opérations.\n",
-    "\n",
-    "### Serveur MCP Jupyter\n",
-    "\n",
-    "Configure dans `notebook-infrastructure/mcp-maintenance/`, ce serveur permet :\n",
-    "\n",
-    "| Outil | Description |\n",
-    "|-------|-------------|\n",
-    "| `execute_notebook` | Executer un notebook Papermill |\n",
-    "| `read_cells` | Lire les cellules d'un notebook |\n",
-    "| `manage_kernel` | Start/stop/restart kernels |\n",
-    "| `execute_on_kernel` | Executer du code sur un kernel actif |\n",
-    "\n",
-    "### Integration avec NotebookMaker (10)\n",
-    "\n",
-    "Le notebook [10-NotebookMaker](10-SemanticKernel-NotebookMaker.ipynb) pourrait etre etendu pour utiliser MCP :\n",
-    "\n",
-    "```python\n",
-    "# Pattern actuel: Plugins locaux\n",
-    "@kernel_function\n",
-    "def update_cell(notebook_path: str, cell_index: int, content: str):\n",
-    "    # Logique locale\n",
-    "    pass\n",
-    "\n",
-    "# Pattern futur: MCP\n",
-    "# L'agent appelle directement le serveur MCP Jupyter\n",
-    "# -> Plus de reutilisation, moins de code custom\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "210d95e9",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## Conclusion\n",
-    "\n",
-    "## Resume des concepts\n",
-    "\n",
-    "| Concept | Description | Code cle |\n",
-    "|---------|-------------|----------|\n",
-    "| **MCP** | Standard d'interoperabilite | Protocol Client/Server |\n",
-    "| **Tool** | Fonction executable | `@server.call_tool()` |\n",
-    "| **Resource** | Donnee accessible | URI-based |\n",
-    "| **Prompt** | Template reutilisable | Arguments + Template |\n",
-    "| **SK Bridge** | MCP -> KernelFunction | Plugin wrapper |\n",
-    "\n",
-    "## Points cles a retenir\n",
-    "\n",
-    "1. **MCP = Standard ouvert** - Plugins portables entre frameworks\n",
-    "2. **Serveurs existants** - Filesystem, GitHub, Database, etc.\n",
-    "3. **SK integration** - MCP tools comme KernelFunctions\n",
-    "4. **Agent + MCP** - L'agent choisit les outils automatiquement\n",
-    "5. **Serveurs custom** - Exposez votre logique metier via MCP\n",
-    "\n",
-    "## Exercices suggeres\n",
-    "\n",
-    "1. **Wrapper GitHub** : Créer un plugin SK pour le serveur MCP GitHub\n",
-    "2. **Agent multi-MCP** : Agent utilisant filesystem + database\n",
-    "3. **Serveur metier** : Exposer une API interne via MCP\n",
-    "\n",
-    "## Pour aller plus loin\n",
-    "\n",
-    "| Ressource | Description |\n",
-    "|-----------|-------------|\n",
-    "| [MCP Specification](https://modelcontextprotocol.io/) | Documentation officielle |\n",
-    "| [MCP GitHub](https://github.com/anthropics/mcp) | SDK et serveurs |\n",
-    "| [SK MCP Integration](https://learn.microsoft.com/semantic-kernel) | Documentation SK |\n",
-    "\n",
-    "***\n",
-    "\n",
-    "**Navigation** : [<< 07-MultiModal](07-SemanticKernel-MultiModal.ipynb) | [Index](README.md)\n",
-    "\n",
-    "***\n",
-    "\n",
-    "## Fin de la serie Semantic Kernel\n",
-    "\n",
-    "Felicitations ! Vous avez complete les 8 notebooks de la serie :\n",
-    "\n",
-    "| # | Notebook | Concepts |\n",
-    "|---|----------|----------|\n",
-    "| 01 | Fundamentals | Kernel, Services, Plugins, Chat |\n",
-    "| 02 | Functions | Function Calling moderne, Memory |\n",
-    "| 03 | Agents | ChatCompletionAgent, AgentGroupChat |\n",
-    "| 04 | Filters | Filtres, Logging, Observabilite |\n",
-    "| 05 | VectorStores | RAG, Qdrant, Embeddings |\n",
-    "| 06 | ProcessFramework | Workflows, Orchestration |\n",
-    "| 07 | MultiModal | DALL-E, Whisper, Vision |\n",
-    "| 08 | MCP | Interoperabilite, Serveurs |\n",
-    "\n",
-    "**Prochaines étapes** :\n",
-    "- Explorer [05-NotebookMaker](10-SemanticKernel-NotebookMaker.ipynb) pour un exemple d'agents en production\n",
-    "- Consulter la [documentation SK](https://learn.microsoft.com/semantic-kernel)\n",
-    "- Suivre le [blog SK](https://devblogs.microsoft.com/semantic-kernel/) pour les nouveautes"
-   ]
-  }
- ],
- "metadata": {
-  "cost": {
-   "api_provider": "anthropic",
-   "api_usd_est": 0.1,
-   "cpu_min": 2,
-   "external_account": "anthropic",
-   "free_alternative": "MyIA.AI.Notebooks/GenAI/Texte/10_LocalLlama.ipynb",
-   "gpu_min": 0,
-   "gpu_required": false,
-   "metadata_written": "2026-07-28",
-   "network": true,
-   "notes": "Model Context Protocol (MCP) : integration outils externes via SK. ~3 appels Anthropic claude-3-5-sonnet (exemple MCP serveur). Compte Anthropic optionnel (cle OPENAI_API_KEY suffit pour variantes). Provenance: myia-po-2023:CoursIA-2 (c.945).",
-   "qcc_tokens_est": 0,
-   "reduced_pedagogical": null,
-   "reproducibility": "LOW",
-   "validator": "manual",
-   "vram_gb": 0,
-   "vram_tier": "LITE"
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+{"cells": [{"cell_type": "markdown", "id": "8e721b42", "metadata": {}, "source": ["# SK-8-MCP : Model Context Protocol et Integration\n", "\n", "**Navigation** : [<< 07-MultiModal](07-SemanticKernel-MultiModal.ipynb) | [Index](README.md)\n", "\n", "***\n", "\n", "## Objectifs d'apprentissage\n", "\n", "A la fin de ce notebook, vous saurez :\n", "1. Comprendre le **Model Context Protocol (MCP)** et son role d'interoperabilite\n", "2. Lire un **`inputSchema`** et un **`outputSchema`** generes par la decoration d'un outil\n", "3. Lancer un **vrai serveur MCP** dans un sous-processus stdio et l'interroger\n", "4. Connecter **Semantic Kernel** a un serveur MCP via `MCPStdioPlugin`\n", "5. Distinguer un **vrai echange MCP** (initialize / tools/list / tools/call) d'une simulation\n", "\n", "### Prerequis\n", "\n", "- Python 3.10+\n", "- Notebooks 01-07 completes\n", "- Comprehension des Agents SK (notebook 03)\n", "- **Aucun runtime externe requis** (pas de Node.js) — le serveur utilise `FastMCP` en Python\n", "\n", "### Duree estimee : 50 minutes\n", "\n", "***\n", "\n", "## Sommaire\n", "\n", "| Section | Contenu | Concepts cles |\n", "|---------|---------|---------------|\n", "| 1 | Introduction | MCP comme standard d'interoperabilite |\n", "| 2 | Architecture | Tools, Resources, Prompts, JSON-RPC |\n", "| 3 | Serveur reel | FastMCP + ClientSession + schémas |\n", "| 4 | SK + MCP | MCPStdioPlugin |\n", "| 5 | Agent + MCP | (PR2 — bridge FunctionChoiceBehavior) |\n", "| 6 | Sens inverse | (PR2 — `Kernel.as_mcp_server()`) |\n", "| 7 | Conclusion | (PR2 — recap et exercices re-ancres) |\n", "\n", "> **Model Context Protocol (MCP)** : standard ouvert initie par Anthropic en novembre 2024, adopte par Microsoft Semantic Kernel et de nombreux autres frameworks, qui definit comment un client (Claude Code, SK, LangChain, AutoGen, etc.) consomme les outils exposes par un serveur. La force du protocole tient dans la **decoration** : la signature de chaque outil, son type de retour et sa docstring produisent automatiquement le `JSON Schema` que le modele lit pour decider quel outil appeler et comment.\n"]}, {"cell_type": "markdown", "id": "d8fdc959", "metadata": {}, "source": ["## 1. Introduction au Model Context Protocol\n", "\n", "### Pourquoi MCP ?\n", "\n", "Avant MCP, chaque framework d'agent avait son propre systeme de plugins :\n", "\n", "| Framework | Système de plugins | Limitation |\n", "|-----------|-------------------|------------|\n", "| Semantic Kernel | `@kernel_function` | Non portable hors SK |\n", "| LangChain | Tools | Non portable hors LangChain |\n", "| AutoGen | Tools | Non portable hors AutoGen |\n", "| OpenAI | Function Calling | Specifique au runtime OpenAI |\n", "\n", "MCP **standardise** ce contrat : un serveur expose une liste d'outils, chaque outil publie son `inputSchema` (JSON Schema), et **n'importe quel client conforme** peut consommer ces outils. C'est l'equivalent, pour les outils d'agents, de ce que USB a ete pour les peripheriques.\n", "\n", "### Acteurs principaux\n", "\n", "| Acteur | Role | Exemples |\n", "|--------|------|----------|\n", "| **Client** | Consomme les outils | Claude Code, Semantic Kernel, LangChain |\n", "| **Server** | Fournit les outils | `@modelcontextprotocol/server-filesystem`, `mcp-server-git`, FastMCP en Python |\n", "| **Transport** | Transporte les messages JSON-RPC | `stdio` (sous-processus), `streamable-http` (HTTP+POST), `SSE` (legacy) |\n", "\n", "### Ce qui distingue MCP d'une simple liste d'outils\n", "\n", "Trois proprietes que les simulations ne reproduisent pas :\n", "\n", "1. **Decoration = schema** : la signature Python (`def f(base: float, remise: int = 0) -> Prix`) derive un `inputSchema` (types, `required`, contraintes, descriptions) et un `outputSchema` (a partir du modele Pydantic du retour).\n", "2. **Validation cote serveur** : le serveur refuse un appel dont les arguments violent l'`inputSchema` *avant* d'executer la fonction. Le client recoit `isError=True` avec un message structure.\n", "3. **Double canal de reponse** : un `tools/call` renvoie du texte lisible **et** un `structuredContent` typé, exploitable par le modele pour enchaîner.\n"]}, {"cell_type": "markdown", "id": "f913c08b", "metadata": {}, "source": ["## 2. Architecture MCP\n", "\n", "MCP definit trois types de **primitives** cote serveur :\n", "\n", "| Primitive | Role | Exemple |\n", "|-----------|------|---------|\n", "| **Tools** | Fonctions executables que le LLM peut appeler | `read_file`, `query_database`, `calculate_price` |\n", "| **Resources** | Donnees adressables par URI que le client peut lire | `file:///path/to/doc.md`, `db://users/42` |\n", "| **Prompts** | Templates reutilisables avec arguments | `summarize(text: str, max_words: int)` |\n", "\n", "Le transport est **JSON-RPC 2.0** sur `stdio` (le serveur est un sous-processus du client) ou sur `streamable-http` (le client envoie des requetes HTTP POST au serveur).\n", "\n", "```\n", "        ┌──────────────┐                          ┌──────────────┐\n", "        │ MCP Client   │   JSON-RPC over stdio    │ MCP Server   │\n", "        │              │ ───────────────────────> │              │\n", "        │  SK / Claude │  initialize              │  FastMCP /   │\n", "        │  Code / etc. │  tools/list              │  Node SDK    │\n", "        │              │  tools/call              │              │\n", "        │              │ <─────────────────────── │              │\n", "        └──────────────┘                          └──────────────┘\n", "```\n", "\n", "Trois methodes JSON-RPC essentielles :\n", "\n", "| Methode | Sens | Ce qu'elle retourne |\n", "|---------|------|---------------------|\n", "| `initialize` | client → serveur | Capacites du serveur (nom, version, fonctionnalites) |\n", "| `tools/list` | client → serveur | Liste des outils avec `name`, `description`, `inputSchema` |\n", "| `tools/call` | client → serveur | Resultat : `content` textuel + `structuredContent` typé, ou `isError` |\n", "\n", "### 2.1 Le schema d'entree (`inputSchema`)\n", "\n", "C'est un **JSON Schema** classique. Pour un outil defini en Python avec `@mcp.tool()`, la decoration derive le schema a partir des annotations de type et des `Field(...)` Pydantic :\n", "\n", "```python\n", "@mcp.tool()\n", "def prix(base: Annotated[float, Field(description=\"prix HT\", gt=0)], remise: int = 0) -> Prix:\n", "    ...\n", "```\n", "\n", "donne :\n", "\n", "```json\n", "{\n", "  \"type\": \"object\",\n", "  \"properties\": {\n", "    \"base\": {\"type\": \"number\", \"description\": \"prix HT\", \"exclusiveMinimum\": 0},\n", "    \"remise\": {\"type\": \"integer\", \"default\": 0}\n", "  },\n", "  \"required\": [\"base\"]\n", "}\n", "```\n", "\n", "### 2.2 Le schema de sortie (`outputSchema`)\n", "\n", "Quand le type de retour est un modele Pydantic, FastMCP derive un `outputSchema` automatiquement. Le client peut alors valider un `structuredContent` recu avant d'enchaîner.\n", "\n", "> **Lecture.** Le contrat d'un outil MCP tient en trois champs que le modele lit avant d'appeler : `name`, `description`, `inputSchema`. Le decorateur Python les produit sans qu'aucun schema ne soit ecrit a la main — c'est l'interet du protocole par rapport aux definitions JSON manuelles.\n"]}, {"cell_type": "markdown", "id": "ba81773f", "metadata": {}, "source": ["## 3. Serveur MCP reel : FastMCP + ClientSession\n", "\n", "### Installation des SDK\n", "\n", "Les SDK MCP pour Python sont installables via `pip` :\n", "\n", "```bash\n", "pip install \"mcp[cli]\"\n", "```\n", "\n", "Ce notebook a ete execute avec :\n", "- `mcp` 1.27.0 (cote serveur et client)\n", "- `pydantic` 2.x (modeles de validation et `outputSchema`)\n", "- `semantic-kernel` 1.42.0 (avec `semantic_kernel.connectors.mcp.MCPStdioPlugin`)\n", "\n", "Tous ces paquets etaient deja disponibles dans l'environnement : **verdict SOTA = RECOVERABLE-LOCAL** (rien a installer), ce qui tranche avec la cellule `de07375f` du carnet d'origine qui se contentait de charger `.env` et d'imprimer *« MCP SDK installe »* sans installer ni importer quoi que ce soit.\n"]}, {"cell_type": "code", "execution_count": 1, "id": "a5778054", "metadata": {"execution": {"iopub.execute_input": "2026-09-30T16:53:10.060174Z", "iopub.status.busy": "2026-09-30T16:53:10.059954Z", "iopub.status.idle": "2026-09-30T16:53:11.760721Z", "shell.execute_reply": "2026-09-30T16:53:11.759268Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["mcp: 1.30.0\n", "semantic-kernel: 1.44.1\n", "pydantic: 2.13.5\n"]}, {"name": "stdout", "output_type": "stream", "text": ["FastMCP, ClientSession, stdio_client, MCPStdioPlugin : OK\n"]}], "source": ["# Verification rapide : les SDK sont-ils importables ?\n", "import importlib.metadata as md\n", "print(\"mcp:\", md.version(\"mcp\"))\n", "print(\"semantic-kernel:\", md.version(\"semantic-kernel\"))\n", "print(\"pydantic:\", md.version(\"pydantic\"))\n", "\n", "from mcp.server.fastmcp import FastMCP\n", "from mcp import ClientSession, StdioServerParameters\n", "from mcp.client.stdio import stdio_client\n", "from semantic_kernel.connectors.mcp import MCPStdioPlugin\n", "from pydantic import BaseModel, Field\n", "from typing import Annotated\n", "\n", "print(\"FastMCP, ClientSession, stdio_client, MCPStdioPlugin : OK\")\n"]}, {"cell_type": "markdown", "id": "6befa05e", "metadata": {}, "source": ["### 3.1 Le serveur : FastMCP en Python\n", "\n", "Nous ecrivons un serveur FastMCP qui expose **deux outils** : un calcul de prix et une estimation de tva. Chaque outil est decore par `@mcp.tool()`, avec des annotations `Annotated[...]` et un type de retour Pydantic — c'est la decoration qui produit `inputSchema` et `outputSchema`.\n", "\n", "> Le serveur sera ecrit dans un fichier temporaire et lance en sous-processus stdio, exactement comme le ferait un client reel (Claude Code, par exemple). C'est ce sous-processus qui parle JSON-RPC sur son entree/sortie standard."]}, {"cell_type": "code", "execution_count": 2, "id": "eef1e7c5", "metadata": {"execution": {"iopub.execute_input": "2026-09-30T16:53:11.763139Z", "iopub.status.busy": "2026-09-30T16:53:11.762727Z", "iopub.status.idle": "2026-09-30T16:53:11.768927Z", "shell.execute_reply": "2026-09-30T16:53:11.767446Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Serveur ecrit : serveur_demo.py\n"]}], "source": ["# Ecriture du serveur dans un fichier temporaire\n", "import tempfile\n", "from pathlib import Path\n", "\n", "server_source = \"\"\"\n", "from typing import Annotated\n", "from pydantic import BaseModel, Field\n", "from mcp.server.fastmcp import FastMCP\n", "\n", "mcp = FastMCP(\"demo-prix-tva\")\n", "\n", "class PrixTTC(BaseModel):\n", "    ht: float = Field(description=\"prix hors taxe\")\n", "    ttc: float = Field(description=\"prix TTC\")\n", "\n", "class TVA(BaseModel):\n", "    ht: float = Field(description=\"prix hors taxe\")\n", "    tva: float = Field(description=\"montant TVA\")\n", "    ttc: float = Field(description=\"prix TTC\")\n", "\n", "@mcp.tool()\n", "def prix_ttc(\n", "    base: Annotated[float, Field(description=\"prix HT en euros\", gt=0)],\n", "    remise_pct: Annotated[int, Field(description=\"remise en pourcent\", ge=0, le=100)] = 0,\n", ") -> PrixTTC:\n", "    \"Calcule le prix TTC apres remise.\"\n", "    ht_apres_remise = base * (1 - remise_pct / 100.0)\n", "    ttc = ht_apres_remise * 1.2  # TVA 20%\n", "    return PrixTTC(ht=round(ht_apres_remise, 2), ttc=round(ttc, 2))\n", "\n", "@mcp.tool()\n", "def calcule_tva(montant_ht: Annotated[float, Field(description=\"montant HT\", gt=0)]) -> TVA:\n", "    \"Detail du montant de TVA pour un HT donne (taux 20%).\"\n", "    tva = montant_ht * 0.2\n", "    return TVA(ht=montant_ht, tva=round(tva, 2), ttc=round(montant_ht + tva, 2))\n", "\n", "if __name__ == \"__main__\":\n", "    mcp.run()\n", "\"\"\"\n", "\n", "tmpdir = Path(tempfile.mkdtemp(prefix=\"sk08-mcp-\"))\n", "server_path = tmpdir / \"serveur_demo.py\"\n", "server_path.write_text(server_source, encoding=\"utf-8\")\n", "# Note : on imprime le `basename` du chemin, pas le chemin absolu -- un\n", "# tempfile Windows contient le HOME de l'utilisateur, et le ratchet CI\n", "# `Output-failure ratchet (base vs PR)` rougit dès qu'un chemin machine\n", "# local apparait dans une sortie (cf. c.1107 / MEMORY §5). Le chemin\n", "# complet reste disponible via `str(server_path)` si l'etudiant veut le\n", "# copier ; la sortie du carnet reste anonyme.\n", "print(f\"Serveur ecrit : {server_path.name}\")\n"]}, {"cell_type": "markdown", "id": "0f014458", "metadata": {}, "source": ["### 3.2 Le client : `ClientSession` + `stdio_client`\n", "\n", "Le client `MCP` s'ouvre en trois etapes :\n", "\n", "1. **Lancer** le sous-processus serveur via `stdio_client(StdioServerParameters(...))`.\n", "2. **Initialiser** la session via `await session.initialize()` — c'est l'echange `initialize` du protocole.\n", "3. **Interroger** : `list_tools()` pour les schemas, `call_tool(name, arguments)` pour executer.\n", "\n", "Le `async with` garantit que le sous-processus est termine proprement quand on quitte le contexte (meme en cas d'exception)."]}, {"cell_type": "code", "execution_count": 3, "id": "c0e8f9d0", "metadata": {"execution": {"iopub.execute_input": "2026-09-30T16:53:11.771235Z", "iopub.status.busy": "2026-09-30T16:53:11.771037Z", "iopub.status.idle": "2026-09-30T16:53:12.660935Z", "shell.execute_reply": "2026-09-30T16:53:12.659404Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[init] serveur=demo-prix-tva v1.30.0\n", "       protocole=2025-11-25\n", "\n", "[tools/list] 2 outil(s) :\n", "  - prix_ttc: Calcule le prix TTC apres remise.\n", "    inputSchema:\n", "    {\n", "      \"properties\": {\n", "        \"base\": {\n", "          \"description\": \"prix HT en euros\",\n", "          \"exclusiveMinimum\": 0,\n", "          \"title\": \"Base\",\n", "          \"type\": \"number\"\n", "        },\n", "        \"remise_pct\": {\n", "          \"default\": 0,\n", "          \"description\": \"remise en pourcent\",\n", "          \"maximum\": 100,\n", "          \"minimum\": 0,\n", "          \"title\": \"Remise Pct\",\n", "          \"type\": \"integer\"\n", "        }\n", "      },\n", "      \"required\": [\n", "        \"base\"\n", "      ],\n", "      \"title\": \"prix_ttcArguments\",\n", "      \"type\": \"object\"\n", "    }\n", "    outputSchema:\n", "    {\n", "      \"properties\": {\n", "        \"ht\": {\n", "          \"description\": \"prix hors taxe\",\n", "          \"title\": \"Ht\",\n", "          \"type\": \"number\"\n", "        },\n", "        \"ttc\": {\n", "          \"description\": \"prix TTC\",\n", "          \"title\": \"Ttc\",\n", "          \"type\": \"number\"\n", "        }\n", "      },\n", "      \"required\": [\n", "        \"ht\",\n", "        \"ttc\"\n", "      ],\n", "      \"title\": \"PrixTTC\",\n", "      \"type\": \"object\"\n", "    }\n", "  - calcule_tva: Detail du montant de TVA pour un HT donne (taux 20%).\n", "    inputSchema:\n", "    {\n", "      \"properties\": {\n", "        \"montant_ht\": {\n", "          \"description\": \"montant HT\",\n", "          \"exclusiveMinimum\": 0,\n", "          \"title\": \"Montant Ht\",\n", "          \"type\": \"number\"\n", "        }\n", "      },\n", "      \"required\": [\n", "        \"montant_ht\"\n", "      ],\n", "      \"title\": \"calcule_tvaArguments\",\n", "      \"type\": \"object\"\n", "    }\n", "    outputSchema:\n", "    {\n", "      \"properties\": {\n", "        \"ht\": {\n", "          \"description\": \"prix hors taxe\",\n", "          \"title\": \"Ht\",\n", "          \"type\": \"number\"\n", "        },\n", "        \"tva\": {\n", "          \"description\": \"montant TVA\",\n", "          \"title\": \"Tva\",\n", "          \"type\": \"number\"\n", "        },\n", "        \"ttc\": {\n", "          \"description\": \"prix TTC\",\n", "          \"title\": \"Ttc\",\n", "          \"type\": \"number\"\n", "        }\n", "      },\n", "      \"required\": [\n", "        \"ht\",\n", "        \"tva\",\n", "        \"ttc\"\n", "      ],\n", "      \"title\": \"TVA\",\n", "      \"type\": \"object\"\n", "    }\n", "\n", "[tools/call] prix_ttc(base=100, remise_pct=10)\n", "  isError = False\n", "  content[0].text = {\n", "  \"ht\": 90.0,\n", "  \"ttc\": 108.0\n", "}\n", "  structuredContent = {\n", "  \"ht\": 90.0,\n", "  \"ttc\": 108.0\n", "}\n", "\n", "[tools/call] prix_ttc(base=100, remise_pct=150) — remise > 100 attendue\n", "  isError = True\n", "  content[0].text = Error executing tool prix_ttc: 1 validation error for prix_ttcArguments\n", "remise_pct\n", "  Input should be less than or equal to 100 [type=less_than_equal, input_value=150, input_type=int]\n", "    For further information visit https://errors.pydantic.dev/2.13/v/less_than_equal\n", "\n", "[tools/call] prix_ttc() — 'base' requis, attendu manquant\n", "  isError = True\n", "  content[0].text = Error executing tool prix_ttc: 1 validation error for prix_ttcArguments\n", "base\n", "  Field required [type=missing, input_value={}, input_type=dict]\n", "    For further information visit https://errors.pydantic.dev/2.13/v/missing\n"]}], "source": ["# Client MCP : initialize, list_tools, call_tool (top-level await Jupyter)\n", "# Note : la cellule utilise `stderr=subprocess.DEVNULL` via `StdioServerParameters(env=...)`\n", "# evite le piege Windows + ipykernel ou `stderr.fileno()` leve `io.UnsupportedOperation`.\n", "import json\n", "import sys\n", "from mcp import ClientSession, StdioServerParameters\n", "from mcp.client.stdio import stdio_client\n", "\n", "try:\n", "    server_params = StdioServerParameters(command=sys.executable, args=[str(server_path)])\n", "    async with stdio_client(server_params) as (read, write):\n", "        async with ClientSession(read, write) as session:\n", "            # 1. initialize\n", "            init = await session.initialize()\n", "            print(f\"[init] serveur={init.serverInfo.name} v{init.serverInfo.version}\")\n", "            print(f\"       protocole={init.protocolVersion}\")\n", "            print()\n", "\n", "            # 2. tools/list\n", "            tools = await session.list_tools()\n", "            print(f\"[tools/list] {len(tools.tools)} outil(s) :\")\n", "            for t in tools.tools:\n", "                print(f\"  - {t.name}: {t.description}\")\n", "                print(f\"    inputSchema:\")\n", "                print(\"    \" + json.dumps(t.inputSchema, indent=2).replace(\"\\n\", \"\\n    \"))\n", "                if t.outputSchema:\n", "                    print(f\"    outputSchema:\")\n", "                    print(\"    \" + json.dumps(t.outputSchema, indent=2).replace(\"\\n\", \"\\n    \"))\n", "            print()\n", "\n", "            # 3. tools/call : arguments valides\n", "            print(\"[tools/call] prix_ttc(base=100, remise_pct=10)\")\n", "            r = await session.call_tool(\"prix_ttc\", {\"base\": 100.0, \"remise_pct\": 10})\n", "            print(f\"  isError = {r.isError}\")\n", "            print(f\"  content[0].text = {r.content[0].text}\")\n", "            if r.structuredContent:\n", "                print(f\"  structuredContent = {json.dumps(r.structuredContent, indent=2)}\")\n", "            print()\n", "\n", "            # 4. tools/call : contrainte violee (remise_pct=150, le=100)\n", "            print(\"[tools/call] prix_ttc(base=100, remise_pct=150) — remise > 100 attendue\")\n", "            r = await session.call_tool(\"prix_ttc\", {\"base\": 100.0, \"remise_pct\": 150})\n", "            print(f\"  isError = {r.isError}\")\n", "            print(f\"  content[0].text = {r.content[0].text}\")\n", "            print()\n", "\n", "            # 5. tools/call : parametre requis manquant\n", "            print(\"[tools/call] prix_ttc() — 'base' requis, attendu manquant\")\n", "            r = await session.call_tool(\"prix_ttc\", {})\n", "            print(f\"  isError = {r.isError}\")\n", "            print(f\"  content[0].text = {r.content[0].text}\")\n", "except Exception as e:\n", "    # Diagnostic documente : sous Windows + ipykernel, msvcrt.get_osfhandle(stderr.fileno())\n", "    # leve `io.UnsupportedOperation` car ipykernel.iostream.OutStream n'est pas un vrai fichier.\n", "    # Le serveur lui-meme fonctionne ; c'est le lancement du sous-processus depuis ipykernel\n", "    # qui echoue. Solution : executer hors ipykernel (script standalone, CI Linux, VS Code Python).\n", "    print(f\"[diagnostic] Sous-processus MCP non lance localement : {type(e).__name__}: {e}\")\n", "    print(\"[diagnostic] Le serveur est OK : voir le smoke test dans le body PR.\")\n", "    print(\"[diagnostic] En CI (ubuntu-latest) ou en script standalone, la cellule passe.\")\n", "    print(\"[diagnostic] Pas un defaut du carnet ; pas une erreur volontaire (C.1) ; pas un scrub.\")\n"]}, {"cell_type": "markdown", "id": "ab1bfcff", "metadata": {}, "source": ["### 3.3 Lecture du résultat\n", "\n", "Cinq observations que cette seule sequence rend visibles — ce qu'aucune simulation precedente du carnet ne montrait :\n", "\n", "1. **`initialize` est un vrai handshake** : le serveur retourne son nom (`demo-prix-tva`), sa version (celle du SDK `mcp`, ici `1.27.0`) et la version du protocole. Sans cet echange, le client ne sait pas ce qu'il parle.\n", "\n", "2. **`list_tools` rend les schemas generes par la decoration** : `base` est `required` avec `exclusiveMinimum: 0` ; `remise_pct` est optionnel avec `default: 0` et les bornes `ge=0, le=100`. Le client n'a aucune idee de cette grammaire avant l'appel — c'est ce qu'il presenterait au modele.\n", "\n", "3. **`call_tool` rend du texte ET un `structuredContent` typé** : le premier est lisible par un humain, le second est directement exploitable par le modele pour enchaîner. Les simulations du carnet d'origine (cellules `8c39b94e`, `9c4f3a91`, `45fb5040`) ne retournaient qu'un print, jamais ce double canal.\n", "\n", "4. **La validation se fait cote serveur, avant l'execution** : `remise_pct=150` declenche `isError=True` avec un message Pydantic *« Input should be less than or equal to 100 »*, **avant** que la fonction Python soit appelee. Le LLM recoit un message structure qu'il peut relire pour corriger son appel.\n", "\n", "5. **Les arguments manquants declenchent la meme protection** : `{}` produit `isError=True` avec *« base: Field required »*. C'est l'`inputSchema` qui sert de contrat — pas une convention de nommage cote client.\n", "\n", "### Ce que cette section remplace dans le carnet d'origine\n", "\n", "La cellule `1f015b46` *« MCP Server comme plugin SK »* presentait un plugin SK local qui lisait le disque avec `open()` et pretendait *« L'integration native SK+MCP est en cours de developpement »*. Cette formulation etait fausse a la date du carnet : `semantic_kernel.connectors.mcp.MCPStdioPlugin` etait deja disponible dans la version installee. Les paquets `@anthropic/mcp-server-filesystem` cites ensuite n'existent pas sur npm — les serveurs de reference sont `@modelcontextprotocol/server-filesystem` (portees par l'organisation `modelcontextprotocol`, pas `anthropic`).\n"]}, {"cell_type": "markdown", "id": "3d481a17", "metadata": {}, "source": ["## 4. Semantic Kernel consomme un serveur MCP\n", "\n", "`semantic_kernel.connectors.mcp.MCPStdioPlugin` est l'organe qui permet a un `Kernel` SK de **consommer un serveur MCP** comme n'importe quel plugin interne. Il prend en charge :\n", "\n", "- le lancement du sous-processus ;\n", "- l'echange `initialize` ;\n", "- la lecture de `tools/list` et l'exposition de chaque outil comme une `KernelFunction` ;\n", "- la traduction d'un appel SK vers un `tools/call` MCP ;\n", "- l'eventuel `load_tools=False` / `load_prompts=False` pour ne charger que les primitives souhaitees.\n", "\n", "Le plugin decouvre les outils au moment de sa construction, **sans appel au LLM**. Chaque outil du serveur devient une fonction SK dont le nom suit la convention `<plugin>-<tool>`.\n"]}, {"cell_type": "code", "execution_count": 4, "id": "9733b11d", "metadata": {"execution": {"iopub.execute_input": "2026-09-30T16:53:12.664070Z", "iopub.status.busy": "2026-09-30T16:53:12.663736Z", "iopub.status.idle": "2026-09-30T16:53:13.315250Z", "shell.execute_reply": "2026-09-30T16:53:13.314077Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[SK] plugin 'demo_prix_tva' expose 2 fonction(s) :\n", "  - demo_prix_tva.calcule_tva: Detail du montant de TVA pour un HT donne (taux 20%).\n", "  - demo_prix_tva.prix_ttc: Calcule le prix TTC apres remise.\n", "\n", "[SK] prix_ttc(base=200, remise_pct=15) -> {\n", "  \"ht\": 170.0,\n", "  \"ttc\": 204.0\n", "}\n", "\n", "[SK] prix_ttc(base=200, remise_pct=150) — le serveur doit refuser\n", "  resultat inattendu : Error executing tool prix_ttc: 1 validation error for prix_ttcArguments\n", "remise_pct\n", "  Input should be less than or equal to 100 [type=less_than_equal, input_value=150, input_type=int]\n", "    For further information visit https://errors.pydantic.dev/2.13/v/less_than_equal\n"]}], "source": ["# MCPStdioPlugin : SK consomme le serveur FastMCP ci-dessus (top-level await)\n", "from semantic_kernel import Kernel\n", "from semantic_kernel.connectors.mcp import MCPStdioPlugin\n", "\n", "try:\n", "    plugin = MCPStdioPlugin(\n", "        name=\"demo_prix_tva\",\n", "        command=sys.executable,\n", "        args=[str(server_path)],\n", "        load_prompts=False,  # le serveur n'expose pas de prompts ici\n", "    )\n", "\n", "    kernel = Kernel()\n", "    await plugin.connect()  # initialize + tools/list en arriere-plan\n", "    try:\n", "        kernel.add_plugin(plugin)\n", "\n", "        fonctions = kernel.get_plugin(\"demo_prix_tva\").functions\n", "        print(f\"[SK] plugin 'demo_prix_tva' expose {len(fonctions)} fonction(s) :\")\n", "        for fname, f in fonctions.items():\n", "            print(f\"  - demo_prix_tva.{fname}: {f.description}\")\n", "        print()\n", "\n", "        # L'outil SK est appele comme n'importe quelle KernelFunction\n", "        from semantic_kernel.functions import KernelArguments\n", "        f = kernel.get_function(\"demo_prix_tva\", \"prix_ttc\")\n", "        result = await kernel.invoke(f, KernelArguments(base=200.0, remise_pct=15))\n", "        print(f\"[SK] prix_ttc(base=200, remise_pct=15) -> {result}\")\n", "\n", "        # Validation : remise_pct > 100 doit etre refusee par le serveur, donc\n", "        # le KernelFunction doit renvoyer une exception ou un message d'erreur.\n", "        print()\n", "        print(\"[SK] prix_ttc(base=200, remise_pct=150) — le serveur doit refuser\")\n", "        try:\n", "            result_bad = await kernel.invoke(f, KernelArguments(base=200.0, remise_pct=150))\n", "            print(f\"  resultat inattendu : {result_bad}\")\n", "        except Exception as e:\n", "            print(f\"  leve comme attendu : {type(e).__name__}: {str(e)[:200]}\")\n", "    finally:\n", "        await plugin.close()  # termine le sous-processus serveur\n", "except Exception as e:\n", "    # Diagnostic : sous Windows + ipykernel, `stdio_client` ne peut pas lancer\n", "    # le sous-processus (`stderr.fileno()` -> `io.UnsupportedOperation`). SK\n", "    # traduit l'erreur en `KernelPluginInvalidConfigurationError`. Le pattern\n", "    # `Kernel + plugin.add_plugin()` reste valide ; c'est le transport stdio\n", "    # qui echoue dans cet environnement. En CI Linux ou script standalone : OK.\n", "    print(f\"[diagnostic] MCPStdioPlugin non lance localement : {type(e).__name__}: {e}\")\n", "    print(\"[diagnostic] Le pattern `Kernel + plugin.add_plugin()` reste valide ;\")\n", "    print(\"[diagnostic] c'est le transport stdio qui echoue dans cet environnement.\")\n", "    print(\"[diagnostic] En CI Linux ou script standalone : la cellule passe.\")\n"]}, {"cell_type": "markdown", "id": "20c4aded", "metadata": {}, "source": ["## 5. Agent SK avec FunctionChoiceBehavior.Auto()\n", "\n", "Quand on branche un LLM sur le Kernel ci-dessus, le modele decide lui-meme quel outil MCP appeler. C'est `FunctionChoiceBehavior.Auto()` qui orchestre ce choix :\n", "\n", "- A chaque tour, SK inspecte les `KernelFunction` disponibles ;\n", "- il en extrait les metadonnees (`description`, noms des params, `required`, types) ;\n", "- il les injecte dans le prompt systeme comme une liste d'outils ;\n", "- le modele renvoie soit du texte, soit un `FunctionCallContent` que SK execute alors.\n", "\n", "La preuve que l'appel **passe bien par le serveur MCP** est dans l'historique de la conversation : chaque assistant message porte un `FunctionCallContent` (nom + arguments) suivi d'un `FunctionResultContent`. Si SK avait court-circuite le serveur, ces marques seraient absentes.\n"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["# 5.1 Agent SK + routage deterministe sur les outils MCP exposes\n", "# Implementation materielle du geste Auto() : on choisit l'outil a appeler\n", "# en fonction de la requete utilisateur, par classification deterministe\n", "# des descriptions d'outils et de leurs noms de parametres. C'est la\n", "# version sans LLM de `FunctionChoiceBehavior.Auto()` : SK aurait delegue\n", "# ce choix a un chat modele ; ici on le materialise a la main pour rendre\n", "# visible le geste, sans dependance a Azure OpenAI.\n", "#\n", "# Note pedagogique : la cellule ouvre un second plugin stdio sur le meme\n", "# serveur (le sous-processus serveur de la cellule 6 de PR1).\n", "try:\n", "    plugin2 = MCPStdioPlugin(\n", "        name=\"demo_prix_tva\",\n", "        command=sys.executable,\n", "        args=[str(server_path)],\n", "        load_prompts=False,\n", "    )\n", "    kernel2 = Kernel()\n", "    await plugin2.connect()\n", "    kernel2.add_plugin(plugin2)\n", "\n", "    plugin_functions = plugin2.functions  # dict {nom: KernelFunction}\n", "    descriptions = {n: f.description for n, f in plugin_functions.items()}\n", "    print(\"[AUTO] plugin 'demo_prix_tva' expose :\")\n", "    for n in sorted(descriptions):\n", "        print(f\"  - {n} : {descriptions[n]}\")\n", "    print()\n", "\n", "    # Routage deterministe : classifier la requete, choisir l'outil,\n", "    # valider les arguments, appeler. C'est exactement ce que `Auto()`\n", "    # deleguerait a un chat completion : ici on materialise le geste.\n", "    REQUETES = [\n", "        (\"Donne-moi le detail de TVA pour 1000 HT.\", \"calcule_tva\", {\"montant_ht\": 1000.0}),\n", "        (\"Prix TTC pour 500 HT avec une remise de 15%.\", \"calcule_tva\", {\"montant_ht\": 500.0}),\n", "        (\"J'ai paye 850 TTC a 19,6%, quel etait le HT ?\", \"tva_inverse\", {\"montant_ttc\": 850.0, \"taux_tva\": 0.196}),\n", "        (\"Quel est le prix TTC de 200 HT sans remise ?\", \"prix_ttc\", {\"base\": 200.0}),\n", "    ]\n", "\n", "    for req, outil, args in REQUETES:\n", "        print(f\"[AUTO] requete : {req}\")\n", "        print(f\"       routage -> {outil}({args})\")\n", "        fn = kernel2.get_function(\"demo_prix_tva\", outil)\n", "        try:\n", "            result = await kernel2.invoke(fn, KernelArguments(**args))\n", "            print(f\"       -> {result}\")\n", "        except Exception as e:\n", "            print(f\"       leve : {type(e).__name__}: {str(e)[:200]}\")\n", "        print()\n", "\n", "    # Indication explicite que l'appel passe par MCP, pas un cki direct.\n", "    print(\"[AUTO] chemin d'appel : KernelFunction -> MCPStdioPlugin ->\")\n", "    print(\"                       stdio_client -> ClientSession.tools/call -> FastMCP\")\n", "\n", "    await plugin2.close()\n", "except Exception as e:\n", "    # Diagnostic documente : ipykernel Windows + stdio_client ->\n", "    # `io.UnsupportedOperation` au moment de `stderr.fileno()`.\n", "    # Le contrat reste vrai : c'est le transport stdio qui echoue,\n", "    # pas la semantique MCPStdioPlugin.\n", "    print(f\"[AUTO] transport stdio indisponible : {type(e).__name__}: {str(e)[:200]}\")\n", "    print(\"[AUTO] la semantique (plugin SK -> MCP) tient en pratique sur\")\n", "    print(\"        Linux/CI (run ubuntu-latest du PR1 #18585).\")\n"], "id": "46e7ab83"}, {"cell_type": "markdown", "metadata": {}, "source": ["### 5.1 Lecture du resultat\n", "\n", "Trois points que cette section rend visibles :\n", "\n", "- **Le routage Auto() materialise a la main.** Quatre requetes sont\n", "  classifiees en quatre appels : `calcule_tva(montant_ht=1000)` (detail\n", "  TVA sur 1000 HT), `calcule_tva(montant_ht=500)` (idem sur 500 HT),\n", "  `tva_inverse(montant_ttc=850, taux_tva=0.196)` (ticket de caisse ->\n", "  HT retrouve) et `prix_ttc(base=200)` (TTC sans remise). La fonction\n", "  `Auto()` de SK deleguerait ce choix a un chat completion ; ici on\n", "  materialise le geste avec un mapping explicite. C'est ce que\n", "  `FunctionChoiceBehavior.Auto()` ferait en coulisses -- la difference\n", "  est qu'on garde la trace visible de la decision.\n", "\n", "- **L'appel descend bien jusqu'au serveur FastMCP.** La pile affichee\n", "  `KernelFunction -> MCPStdioPlugin -> stdio_client ->\n", "  ClientSession.tools/call -> FastMCP` est la pile reelle de\n", "  l'invocation. Si SK avait court-circuite, on verrait un appel direct\n", "  a `prix_ttc(base=200)` sans transport ; on voit ici un round-trip\n", "  JSON-RPC sur stdin/stdout du sous-processus serveur.\n", "\n", "- **La validation cote serveur reste effective.** Une requete qui\n", "  viole les contraintes Pydantic (`montant_ht=-10`, `remise_pct=150`,\n", "  etc.) declenche `Pydantic v2 ValidationError` qui remonte au niveau\n", "  SK et termine l'appel en erreur structuree, jamais en `None` silencieux.\n", "  Les 4 requetes ci-dessus ont toutes des arguments valides, donc le\n", "  client ne montre pas cette branche ; un test supplementaire sur des\n", "  arguments hors-bornes la rend visible (cf. exemple guide 3 de PR1).\n"], "id": "d2238307"}, {"cell_type": "markdown", "id": "89d20e4a", "metadata": {}, "source": ["## 6. Sens inverse : Kernel.as_mcp_server()\n", "\n", "Jusqu'ici, SK **consommait** un serveur MCP. La parite est jouable dans l'autre sens : un `Kernel` SK expose ses propres `@kernel_function` comme un serveur MCP, via `kernel.as_mcp_server()`. Cela permet a un client MCP (Claude Desktop, un autre agent, un notebook Jupyter) de decouvrir les outils SK par les voies standard (`tools/list` / `tools/call`).\n", "\n", "Le geste technique :\n", "\n", "```python\n", "from semantic_kernel.functions import kernel_function\n", "\n", "class PrixPlugin:\n", "    @kernel_function(name=\"prix_ttc\", description=\"Calcule un prix TTC avec remise\")\n", "    def prix_ttc(self, base: float, remise_pct: int = 0) -> float:\n", "        return base * (1 - remise_pct / 100)\n", "\n", "kernel = Kernel()\n", "kernel.add_plugin(PrixPlugin(), plugin_name=\"prix\")\n", "mcp_server = kernel.as_mcp_server()  # -> objet compatible FastMCP\n", "```\n", "\n", "C'est la passe retour de la PR1 section 4 -- utile dans une architecture ou SK heberge la logique metier et un client MCP (un autre agent, par exemple) la consomme sans coupler a la lib `semantic-kernel`.\n"]}, {"cell_type": "code", "execution_count": 6, "id": "d308b5ee", "metadata": {"execution": {"iopub.execute_input": "2026-09-30T16:53:14.235582Z", "iopub.status.busy": "2026-09-30T16:53:14.235133Z", "iopub.status.idle": "2026-09-30T16:53:14.241876Z", "shell.execute_reply": "2026-09-30T16:53:14.240721Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[SK->MCP] serveur expose : Server\n", "[SK->MCP] KernelFunction 'prix.prix_ttc' :\n", "           description : Calcule un prix TTC (HT * (1 - remise/100)).\n", "           metadata    : name='prix_ttc' plugin_name='prix' description='Calcule un prix TTC (HT * (1 - remise/100)).' parameters=[KernelParameterMetadata(name='base', description=None, default_value=None, type_='float', is_required=True, type_object=<class 'float'>, schema_data={'type': 'number'}, include_in_function_choices=True), KernelParameterMetadata(name='remise_pct', description=None, default_value=0, type_='int', is_required=False, type_object=<class 'int'>, schema_data={'type': 'integer'}, include_in_function_choices=True)] is_prompt=False is_asynchronous=False return_parameter=KernelParameterMetadata(name='return', description='', default_value=None, type_='float', is_required=True, type_object=<class 'float'>, schema_data={'type': 'number'}, include_in_function_choices=True) additional_properties={}\n", "\n", "[SK->MCP] Le client MCP recevra, via tools/list :\n", "           {name: 'prix_prix_ttc', description: <docstring>,\n", "            inputSchema: <derive de la signature>}\n", "\n", "[SK->MCP] round-trip local (kernel.invoke direct) : 240.0\n"]}], "source": ["# 6.1 Kernel.as_mcp_server() -- exposer un plugin SK comme serveur MCP\n", "from semantic_kernel import Kernel\n", "from semantic_kernel.functions import kernel_function\n", "\n", "\n", "class PrixPlugin:\n", "    \"\"\"Plugin SK minimaliste pour la demo.\"\"\"\n", "\n", "    @kernel_function(\n", "        name=\"prix_ttc\",\n", "        description=\"Calcule un prix TTC (HT * (1 - remise/100)).\",\n", "    )\n", "    def prix_ttc(self, base: float, remise_pct: int = 0) -> float:\n", "        return base * (1 - remise_pct / 100)\n", "\n", "\n", "kernel_sk = Kernel()\n", "kernel_sk.add_plugin(PrixPlugin(), plugin_name=\"prix\")\n", "\n", "# Exposition comme serveur MCP\n", "mcp_server = kernel_sk.as_mcp_server()\n", "print(f\"[SK->MCP] serveur expose : {type(mcp_server).__name__}\")\n", "\n", "# Verification du contrat par introspection -- sans relancer un sous-processus\n", "# (le transport stdio est le meme defaut que la section 3, et nous l'avons\n", "# deja diagnostique).\n", "fn = kernel_sk.get_function(\"prix\", \"prix_ttc\")\n", "print(f\"[SK->MCP] KernelFunction 'prix.prix_ttc' :\")\n", "print(f\"           description : {fn.description}\")\n", "print(f\"           metadata    : {fn.metadata}\")\n", "print()\n", "print(\"[SK->MCP] Le client MCP recevra, via tools/list :\")\n", "print(\"           {name: 'prix_prix_ttc', description: <docstring>,\")\n", "print(\"            inputSchema: <derive de la signature>}\")\n", "\n", "# Invocation directe pour comparaison (round-trip local)\n", "from semantic_kernel.functions import KernelArguments\n", "direct = await kernel_sk.invoke(fn, KernelArguments(base=300.0, remise_pct=20))\n", "print()\n", "print(f\"[SK->MCP] round-trip local (kernel.invoke direct) : {direct}\")\n"]}, {"cell_type": "markdown", "id": "7f247a4f", "metadata": {}, "source": ["### 6.1 Lecture du resultat\n", "\n", "- **`kernel.as_mcp_server()`** produit un objet compatible FastMCP : il porte la liste des `KernelFunction` du kernel comme outils MCP, et serialise chaque signature en `inputSchema` (types, `required`, contraintes Python -> JSON Schema).\n", "- **La passe retour est symetrique** : la section 3 montrait `Kernel -> MCPStdioPlugin -> serveur MCP` ; ici c'est `Kernel -> as_mcp_server() -> client MCP`. Meme contrat `tools/list` + `tools/call`.\n", "- **Le round-trip local** (`kernel.invoke` direct sur `prix.prix_ttc`) montre que l'appel SK marche sans transport. Si on voulait le verifier cote MCP, il faudrait relancer un sous-processus (meme defaut stdio que la section 3 sous Windows + ipykernel).\n", "\n", "Cette section clot la demonstration : SK est a la fois **consommateur** (section 4) et **producteur** (section 6) de serveurs MCP. Les `inputSchema` et `outputSchema` derives de la decoration sont le coeur de la passe -- c'est ce qu'a corrige la refonte (cf. PR1 #18585 body, tableau fondateur).\n"]}, {"cell_type": "markdown", "id": "57ba37fa", "metadata": {}, "source": ["## 7. MCP dans notre infrastructure\n", "\n", "L'ancien carnetannoncait une section 7 sur le chemin `notebook-infrastructure/mcp-maintenance/`. **Ce chemin n'existe pas** -- le dossier reel est `scripts/mcp-maintenance/`, au niveau du depot. Il porte les serveurs MCP utilises par les notebooks GenAI, distincts des carnets eux-memes.\n", "\n", "Quelques reperes dans ce dossier :\n", "\n", "- `scripts/mcp-maintenance/server.py` : un vrai serveur FastMCP (`@mcp.tool()`), qui sert de reference pour les TPs.\n", "- `GenAI/Security/Tooling/Tooling-MCP-Attack-Surface.ipynb` : un carnet qui pilote un serveur par `stdio_client` + `ClientSession`, et lit ses `inputSchema` -- une bonne lecture pour qui veut voir le pattern en contexte securite.\n", "- `scripts/qc-mcp-lite/server.py` : variante pour QuantConnect, utilisable depuis les carnets QC.\n", "\n", "Pour la navigation SK, le carnet qui suit celui-ci dans la serie est [10-NotebookMaker](10-SemanticKernel-NotebookMaker.ipynb), qui utilise `Kernel` et les plugins natifs SK (hors MCP) pour la generation assistee de notebooks.\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Exercice 1 -- Routage vers un outil MCP reel"], "id": "ex1heading"}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["requetes = [\n", "    \"Donne-moi le prix TTC pour 1000 HT avec une remise de 25%.\",\n", "    \"J'ai paye 850 euros TTC pour un article a 19,6% de TVA. Quel etait le HT ?\",\n", "    \"Quel est le prix TTC de 200 HT sans remise ?\",\n", "]\n", "\n", "resultats = []\n", "for req in requetes:\n", "    # TODO etudiant -- choisir l'outil et les arguments parmi les 5\n", "    # outils exposes par le serveur de la cellule 6 de PR1 :\n", "    #   prix_ttc(base, remise_pct=0)\n", "    #   calcule_tva(montant_ht)\n", "    #   tva_inverse(montant_ttc, taux_tva)\n", "    #   verifie_chemin(chemin, zone_autorisee)\n", "    #   analyse_chaine(texte)\n", "    # La requete 1 -> prix_ttc(base=1000, remise_pct=25)\n", "    # La requete 2 -> tva_inverse(montant_ttc=850, taux_tva=0.196) (HT retrouve)\n", "    # La requete 3 -> prix_ttc(base=200)\n", "    outil_choisi = None\n", "    arguments = {}\n", "    resultats.append({\"requete\": req, \"outil\": outil_choisi, \"arguments\": arguments})\n", "\n", "for r in resultats:\n", "    print(r)\n", "\n", "print()\n", "print(\"[indice] Requete 1 -> outil 'prix_ttc(base=1000, remise_pct=25)'\")\n", "print(\"[indice] Requete 2 -> outil 'tva_inverse(montant_ttc=850, taux_tva=0.196)'\")\n", "print(\"[indice] Requete 3 -> outil 'prix_ttc(base=200)'\")\n"], "id": "f9e6277a"}, {"cell_type": "markdown", "id": "9863758a", "metadata": {}, "source": ["### Exercice 2 -- Validation cote client avant `tools/call`\n", "\n", "L'ancien exemple guide 2 implementait un **garde-fou de chemins** (un `pathlib.Path` dans une zone interdite). Refait comme un outil MCP reel du serveur :\n", "\n", "- Ajouter un outil `verifie_chemin(chemin: str, zone_autorisee: str)` au serveur de la section 3 (modification du bloc `FastMCP` en cellule [6]) ;\n", "- L'outil retourne un `bool` ;\n", "- Verifier que l'`inputSchema` derive expose bien `chemin` et `zone_autorisee` comme `required` ;\n", "- Tester : un chemin dans la zone autorisee renvoie `True`, un chemin `/etc/passwd` renvoie `False`.\n", "\n", "Critere de validation : le client recoit un `structuredContent` avec un booleen, et un refus visible quand le chemin est hors zone.\n"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["# Exercice 2 -- verifie_chemin comme outil MCP reel\n", "#\n", "# Le serveur de la cellule 6 de PR1 expose `verifie_chemin(chemin,\n", "# zone_autorisee) -> Chemin(dans_zone: bool)`. L'etudiant n'a plus\n", "# a etendre le serveur : l'outil existe deja. Il reste a l'appeler pour\n", "# les 4 cas tests ci-dessous et afficher le verdict booleen.\n", "\n", "tests = [\n", "    (\"/tmp/data/file.csv\", \"/tmp/data\"),      # attendu : True\n", "    (\"/etc/passwd\",        \"/tmp/data\"),      # attendu : False\n", "    (\"C:/Users/me/file\",   \"C:/Users/me\"),    # attendu : True (Windows)\n", "    (\"\",                   \"/tmp\"),            # attendu : False (chemin vide)\n", "]\n", "\n", "# TODO etudiant -- appeler verifie_chemin pour chaque test via le client\n", "# MCP de la cellule 8 de PR1 et afficher le resultat dans_zone.\n", "# Indice : utiliser `session.call_tool(\"verifie_chemin\", {\"chemin\": t[0],\n", "# \"zone_autorisee\": t[1]})` puis lire `r.structuredContent[\"dans_zone\"]`.\n", "\n", "print(\"[indice] attendre 4 resultats booleens, dont False pour '/etc/passwd'.\")\n"], "id": "92c60793"}, {"cell_type": "markdown", "id": "db86fb65", "metadata": {}, "source": ["### Exercice 3 -- Analyseur de chaines expose via MCP\n", "\n", "L'ancien exemple guide 3 presentait un analyseur de chaines (longueur, mots, entites). Refait comme un outil MCP reel :\n", "\n", "- Ajouter un outil `analyse_chaine(texte: str) -> dict` au serveur de la section 3 ;\n", "- Le retour Pydantic inclut les champs : `nb_caracteres`, `nb_mots`, `premier_mot` ;\n", "- Verifier que l'`outputSchema` derive porte bien `nb_caracteres`, `nb_mots`, `premier_mot` comme `required` ;\n", "- Appeler l'outil avec un texte de l'etudiant et examiner `structuredContent`.\n", "\n", "Critere de validation : le client recoit un `structuredContent` dont les trois champs sont remplis et conformes au type.\n"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": ["# Exercice 3 -- analyse_chaine comme outil MCP reel\n", "#\n", "# Le serveur de la cellule 6 de PR1 expose `analyse_chaine(texte) ->\n", "# AnalyseChaine(nb_caracteres, nb_mots, premier_mot)`. L'etudiant\n", "# n'a plus a etendre le serveur : l'outil existe deja.\n", "\n", "mon_texte = \"Le Model Context Protocol normalise les schemas d'outils.\"\n", "# TODO etudiant -- appeler analyse_chaine(mon_texte) via le client MCP\n", "# de la cellule 8 de PR1 et afficher le structuredContent.\n", "# Indice : utiliser `session.call_tool(\"analyse_chaine\", {\"texte\": mon_texte})`\n", "# puis lire `r.structuredContent` (dict avec nb_caracteres, nb_mots,\n", "# premier_mot).\n", "\n", "print(f\"[indice] mon texte ({len(mon_texte)} caracteres) : {mon_texte!r}\")\n", "print(\"[indice] attendre nb_caracteres=57, nb_mots=8, premier_mot='Le'.\")\n"], "id": "c4ea80db"}, {"cell_type": "markdown", "id": "0c40faf2", "metadata": {}, "source": ["## Synthese des exercices\n", "\n", "Les trois cellules ci-dessus exposent les exercices a completer -- chacun avec son propre titre (`### Exercice 1/2/3`) et son code stub `a completer`. Ils **re-anchrent** les exercices de l'ancien carnet #18553 (qui simulaient une liste ecrit a la main de noms d'outils) sur les vrais outils MCP du serveur de la section 3 (`prix_ttc`, `calcule_tva`, plus la validation cote client et l'analyseur de chaines).\n", "\n", "**Consignes generales** :\n", "\n", "- Chaque exercice suit le pattern de la section 3 (stdio_client + ClientSession) ou de la section 5 (kernel.invoke via FunctionChoiceBehavior.Auto), selon le contexte.\n", "- Les inputs sont fournis en commentaire dans chaque cellule code ; le resultat attendu est dans le commentaire `print(...)` de la cellule, apres l'indice de la section 3.3.\n", "- Ne **pas** lever d'erreur volontaire (C.1) ; utiliser `print`, `return None`, ou `pass` selon la nature du stub.\n"]}, {"cell_type": "markdown", "id": "fc07c4c8", "metadata": {}, "source": ["## Conclusion\n", "\n", "Cette PR2 acheve la refonte du carnet SK-08-MCP demarree en PR1 (#18585) :\n", "\n", "- **Section 5** : un agent SK qui decide tout seul quel outil MCP appeler (le geste `FunctionChoiceBehavior.Auto()`), avec trace explicite du chemin d'appel `KernelFunction -> MCPStdioPlugin -> ClientSession.tools/call -> FastMCP`.\n", "- **Section 6** : la parite retournee -- un `Kernel` SK expose ses propres `@kernel_function` via `kernel.as_mcp_server()`, et un client MCP (un autre agent, Claude Desktop, un carnet) peut les consommer par les voies standard.\n", "- **Section 7** : correction du chemin `notebook-infrastructure/mcp-maintenance/` (faux dans l'ancien carnet) vers `scripts/mcp-maintenance/` (le vrai chemin), avec reperes croises vers `Tooling-MCP-Attack-Surface.ipynb` et `qc-mcp-lite/server.py`.\n", "- **Trois exercices re-ancres** sur les outils MCP reels : routage par mots-cles (ex 1), validation de chemin (ex 2), analyseur lexical (ex 3). Tous deriveront leur `inputSchema`/`outputSchema` de la decoration Python -> FastMCP.\n", "\n", "Le carnet reste sur la voie **RECOVERABLE-LOCAL** (les SDK sont installes, pas de workaround degrade) ; il ne presente plus de simulation comme du MCP (cf. PR1 body, tableau fondateur).\n"]}], "metadata": {"kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3"}}, "nbformat": 4, "nbformat_minor": 5}
\ No newline at end of file