> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/bases/mcp.md).
# Comment utiliser des serveurs MCP avec des LLM locaux
Ce guide étape par étape vous montre comment connecter **Model Context Protocol (MCP)** des serveurs à des LLM locaux comme [Qwen](/docs/fr/modeles/qwen3.6.md) ou [Gemma](/docs/fr/modeles/gemma-4.md), afin que n'importe quel modèle que vous exécutez puisse appeler des outils et services externes via MCP. Connecter MCP à un modèle local lui permet d'utiliser en toute sécurité vos fichiers locaux, applications, bases de données et outils au lieu de simplement discuter de mémoire, afin de construire un assistant IA plus utile, privé et interchangeable, capable d'agir dans votre environnement réel.
Nous utiliserons les dépôts open source [Unsloth](https://github.com/unslothai/unsloth) et [llama.cpp](#llama.cpp-guide) comme ce sont des frameworks populaires pour l'inférence/le déploiement de modèles locaux. MCP fonctionne avec les modèles GGUF locaux et les [modèles des fournisseurs](/docs/fr/integrations/connections.md). **Nous montrerons également comment** [**plusieurs serveurs MCP**](#using-multiple-mcp-servers) **peuvent être utilisés.**
Les outils MCP fonctionnent aux côtés d'autres capacités du modèle telles que [de code](/docs/fr/nouveau/studio/chat.md#code-execution) et [recherche web](/docs/fr/nouveau/studio/chat.md#advanced-web-search), ainsi un seul modèle peut rechercher le web, exécuter du code et appeler vos services connectés dans le même fil de conversation.
### Cas d'utilisation
Une fois qu'un serveur MCP est connecté, vous pouvez demander à votre modèle local d'effectuer de nombreuses tâches automatisées. Quelques exemples :
* **Rechercher la documentation :** « Trouvez la documentation pertinente et résumez les étapes de configuration. » - Context7 peut être utilisé.
* **Analyser une base de code :** « Cartographiez ce dépôt et expliquez où se produisent l'authentification, la facturation et l'accès aux données. » - Le MCP officiel GitHub et GitMCP peuvent être utilisés pour analyser les dépôts.
* **Rechercher sur le web avec des embeddings** - Le serveur MCP d'Exa peut être utilisé pour des recherches sémantiques sur le web avec prise en charge d'embeddings contextuels.
* **Déboguer les interfaces web** - Les serveurs MCP Playwright et Chrome DevTools peuvent être utilisés pour piloter des sites web afin de trouver des corrections aux problèmes.
### Démarrage rapide
Nous utiliserons deux façons de connecter votre modèle local sur votre appareil aux serveurs MCP. Les deux utilisent des packages open source : [Unsloth](https://github.com/unslothai/unsloth) et [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) pour exécuter, servir et déployer votre modèle.
Guide MCP UnslothGuide MCP Llama.cpp
### 🦥 Guide Unsloth
Dans cet exemple, nous utiliserons Unsloth pour connecter n'importe quel modèle local comme [Qwen3.6](/docs/fr/modeles/qwen3.6.md) ou [Gemma 4](/docs/fr/modeles/gemma-4.md) aux serveurs MCP : [Vercel](https://mcp.vercel.com), [Context7](https://context7.com/), [Exa](https://exa.ai/) et [Hugging Face](https://huggingface.co/docs/hub/en/agents-mcp). Nous demanderons ensuite à un modèle ce qu'il peut faire avec. Les mêmes étapes fonctionnent pour n'importe quel serveur MCP.
{% stepper %}
{% step %}
#### Configurer Unsloth Studio
Nous allons maintenant devoir installer et configurer [Unsloth](/docs/fr/nouveau/studio.md), ce qui vous permettra d'exécuter les modèles cloud dans une interface utilisateur. [Voir ici](/docs/fr/nouveau/studio/install.md) pour des instructions plus détaillées.
{% tabs %}
{% tab title="macOS" %}
#### Étape 1 : configurer Unsloth
Lancez le `terminal` depuis votre Mac, puis installez Unsloth en saisissant la commande ci-dessous.
```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```
L'environnement et les paquets requis vont maintenant être installés. Tapez `Y` puis appuyez sur Entrée lorsqu'on vous y invite pour continuer. Une fois la configuration terminée, le serveur sera disponible localement sur le port `8888`.
{% hint style="info" %}
Si vous avez sauté le démarrage de l'application pendant l'installation, vous pouvez la lancer plus tard avec `unsloth studio -p 8888`. Pour autoriser les connexions depuis d'autres appareils de votre réseau, utilisez `unsloth studio -H 0.0.0.0 -p 8888` à la place.
{% endhint %}
#### Étape 2 : démarrer Unsloth
Ouvrez le navigateur de votre choix et saisissez `http://127.0.0.1:8888` dans la barre d'adresse. Si c'est la première fois que vous installez Unsloth, vous serez redirigé vers la page du mot de passe où vous devrez créer un nouveau mot de passe. Vous devriez ensuite voir la page de chat comme ci-dessous.
{% endtab %}
{% tab title="Windows" %}
#### Étape 1 : configurer Unsloth
Ouvrez le menu Démarrer, recherchez `PowerShell`et lancez-le. Copiez et entrez la commande d'installation :
```powershell
irm https://unsloth.ai/install.ps1 | iex
```
l'installation commencera automatiquement. Une fois l'installation terminée, PowerShell vous demandera si vous souhaitez démarrer Unsloth Studio**.**
Vous pouvez également le lancer avec la commande suivante :
```bash
unsloth studio -H 0.0.0.0 -p 8888
```
{% hint style="info" %}
Si vous souhaitez que votre instance soit accessible par des clients en dehors de votre PC/ordinateur.\
Ajoutez `-H 0.0.0.0` à la `unsloth studio` commande.
{% endhint %}
#### Étape 2 : démarrer Unsloth
Ouvrez `http://127.0.0.1:8888` dans votre navigateur. Au premier lancement, créez un nouveau mot de passe pour continuer vers la page de chat. **Unsloth Studio** est maintenant installé et prêt à être utilisé.
{% endtab %}
{% tab title="Linux, WSL" %}
#### Étape 1 : configurer Unsloth
{% tabs %}
{% tab title="Linux" %}
Ouvrez votre application de terminal. Vous pouvez la lancer en appuyant sur `Ctrl + Alt + T`, ou en recherchant `Terminal` dans le menu des applications de votre système.
{% endtab %}
{% tab title="WSL" %}
Cliquez sur le menu Démarrer de Windows, tapez le nom de votre distribution installée (par ex. `Ubuntu`), puis ouvrez-la.
{% hint style="warning" %}
Sur **WSL**assurez-vous que vos **pilotes NVIDIA** sont installés sur **Windows** (pas dans WSL) et que le **kit d'outils CUDA** est installé dans votre distribution WSL. Consultez les exigences système ci-dessous pour plus de détails.
{% endhint %}
{% endtab %}
{% endtabs %}
Pour installer, copiez et exécutez la commande d'installation :
```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```
Puis :
1. Cliquez à l'intérieur de la fenêtre du terminal
2. Collez la commande avec `Ctrl + Maj + V`
3. Appuyez sur `Entrée`
Unsloth commencera à configurer l'environnement et à installer les paquets requis comme indiqué ci-dessous. Tapez **Y** et appuyez sur `Entrée` lorsqu'on vous demande si vous souhaitez autoriser Unsloth à démarrer maintenant. Cela lancera Unsloth sur votre **8888** port local.
{% hint style="info" %}
Si vous avez choisi de ne pas démarrer Unsloth pendant le processus d'installation, vous pouvez toujours lancer l'application Unsloth à l'aide de `unsloth studio -p 8888` . Si vous souhaitez que votre instance Unsloth soit accessible par des clients en dehors de votre PC/ordinateur, ajoutez `-H 0.0.0.0` à la `unsloth studio` commande.
{% endhint %}
#### Étape 2 : démarrer Unsloth
Ouvrez le navigateur de votre choix et saisissez `http://127.0.0.1:8888` dans la barre d'adresse. Si c'est la première fois que vous installez Unsloth, vous serez redirigé vers la page du mot de passe où vous devrez créer un nouveau mot de passe. Ensuite, Unsloth devrait maintenant s'ouvrir sur la page de chat comme ci-dessous.
{% endtab %}
{% endtabs %}
{% endstep %}
{% step %}
#### **Activer MCP**
Cliquez sur « MCP » dans la barre d'outils du chat.
Unsloth Studio prend par défaut en charge MCP pour Context7, Exa et Hugging Face. Activer Exa [recherche web](/docs/fr/nouveau/studio/chat.md#advanced-web-search) désactivera l'outil de recherche par défaut que nous avons.
{% endstep %}
{% step %}
#### **Ajouter des serveurs MCP personnalisés**
Pour ajouter le serveur MCP Vercel, cliquez sur « Ajouter un MCP personnalisé », et une fenêtre contextuelle s'affichera :
Renseignez les détails du serveur :
1. **Nom affiché**: un libellé convivial, par ex. `Vercel`.
2. **URL**: le point de terminaison de base du serveur, par ex. `https://mcp.vercel.com`.
3. Choisissez une méthode d'authentification ci-dessous.
{% tabs %}
{% tab title="Connexion OAuth" %}
Pour les serveurs qui nécessitent une authentification via le navigateur (GitHub, Linear, Vercel, etc.), activez **Utiliser la connexion OAuth**. Une fenêtre de navigateur s'ouvrira lors de la première connexion afin que vous puissiez autoriser Unsloth.
{% endtab %}
{% tab title="En-tête personnalisé" %}
Pour les serveurs qui s'authentifient avec un jeton, laissez OAuth désactivé et cliquez sur **Ajouter un en-tête** sous **En-têtes personnalisés**. Ajoutez un `Authorization` en-tête avec votre jeton :
```
Authorization: Bearer
```
{% endtab %}
{% endtabs %}
{% endstep %}
{% step %}
#### **Tester et ajouter**
Cliquez sur **Tester la connexion** pour confirmer qu'Unsloth peut atteindre le serveur. Une fois que c'est réussi, cliquez sur **Ajouter le serveur** pour l'enregistrer.
Si **Tester la connexion** En cas d'échec, vérifiez que l'URL est le point de terminaison de base du serveur (et non une page de documentation) et que votre méthode d'authentification est correcte. Voir le dépannage ci-dessous.
{% endstep %}
{% step %}
#### **Vérifier que les outils sont chargés**
Le serveur apparaît maintenant dans la liste des serveurs MCP. Unsloth récupère automatiquement ses outils et affiche une confirmation, par ex. *Actualisé « Vercel » (18 outils)*.
Chaque serveur dispose de contrôles pour **bascule** le basculer on/off, **actualiser** ses outils, **modifier** le, ou **le supprimer.** Assurez-vous que le bouton du serveur et le **Utiliser les serveurs MCP** interrupteur principal sont tous deux activés, puis fermez la boîte de dialogue.
Il sera surligné s'il est activé. Vous pouvez aussi le désactiver en cliquant simplement dessus à nouveau.
{% endstep %}
{% step %}
#### **Utilisez-le dans le chat**
Choisissez n'importe quel modèle dans le **menu déroulant Sélectionner un modèle** menu déroulant et commencez à discuter. Le modèle peut maintenant appeler de lui-même les outils du serveur quand votre requête l'exige.
Au-dessus, un `gemma-4-E2B-it-GGUF` a été demandé *« Pouvez-vous utiliser le serveur MCP Vercel ? »* et a indiqué les actions qu'il peut effectuer : gérer les projets, analyser les journaux, lister les équipes, générer des liens d'accès, vérifier les domaines et rechercher la documentation de Vercel.
{% endstep %}
{% endstepper %}
#### Utiliser plusieurs serveurs MCP
Que diriez-vous d'appeler plusieurs serveurs MCP, par exemple 3 ? Nous utiliserons les serveurs MCP par défaut fournis par Exa, Context7 et Hugging Face dans Unsloth Studio et activerons les 3.
Si vous demandez « Unsloth peut-il prendre en charge le fine-tuning de Qwen ? », Exa fournira d'excellents détails à ce sujet :
Puis en suivi « Recherchez dans la documentation Unsloth comment faire cela », et Context7 est utilisé pour la documentation :
Puis tapez « Rechercher sur Hugging Face des modèles unsloth/Qwen », et le serveur MCP de Hugging Face sera appelé :
#### Un autre exemple de cas d'utilisation spécifique
Une fois qu'un serveur est connecté, demandez au modèle de faire un vrai travail en langage clair. Quelques exemples avec le serveur Vercel :
* **Déboguer une build qui échoue**: *« Récupérez les journaux de build de mon dernier déploiement et dites-moi pourquoi il a échoué. »*
* **Vérifier l'état du déploiement**: *« Listez mes déploiements les plus récents et leur état. »*
* **Rechercher dans la documentation**: *« Recherchez dans la documentation Vercel comment configurer un domaine personnalisé. »*
* **Recherche de domaine**: *« Est `monprojet.dev` disponible, et combien cela coûterait-il ? »*
### 🦙 Guide llama.cpp
{% stepper %}
{% step %}
#### Installer ou compiler llama.cpp
**macOS :**
```bash
brew install llama.cpp
```
Ou pour **Linux, Windows, WSL** compiler à partir des sources :
```bash
git clone https://github.com/ggml-org/llama.cpp
cmake -S llama.cpp -B llama.cpp/build -DCMAKE_BUILD_TYPE=Release
cmake --build llama.cpp/build --config Release -j --target llama-server llama-cli
```
{% endstep %}
{% step %}
#### Démarrer llama-server avec un GGUF
Nous utilisons [Gemma 4](/docs/fr/modeles/gemma-4.md) E4B GGUF dans cet exemple :
```bash
llama-server \
-hf unsloth/gemma-4-E4B-it-GGUF:UD-Q4_K_XL \\
--alias local \\
--host 127.0.0.1 \\
--port 8080 \\
--no-ui \\
--temp 1.0 \
--top-p 0.95 \\
--top-k 64 \\
--reasoning off
```
Pour le plus grand modèle Gemma 4 26B-A4B :
```bash
llama-server \
-hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_M \\
--alias local \\
--host 127.0.0.1 \\
--port 8080 \\
--no-ui \\
--temp 1.0 \
--top-p 0.95 \\
--top-k 64 \\
--reasoning off
```
Pour plus d'ajustements des paramètres d'inférence, consultez notre [guide Gemma 4](/docs/fr/modeles/gemma-4.md).
Vous pouvez tester le serveur :
```bash
curl http://127.0.0.1:8080/v1/chat/completions \\
-H "Content-Type: application/json" \\
-H "Authorization: Bearer none" \\
-d '{
"model": "local",
"messages": [{"role": "user", "content": "Dites bonjour en une phrase."}]
}'
```
{% endstep %}
{% step %}
#### Créer un bac à sable du système de fichiers MCP
```bash
mkdir -p ~/mcp-workspace
cd ~/mcp-workspace
pwd
```
Copiez le chemin absolu. Créez un dossier de projet séparé pour votre hôte MCP :
```bash
mkdir -p ~/llama-mcp
cd ~/llama-mcp
```
Créer `server_config.json`:
{% code expandable="true" %}
```json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/ABSOLUTE/PATH/TO/mcp-workspace"
],
"env": {}
}
}
}
```
{% endcode %}
Remplacez le chemin par le chemin réel de votre espace de travail. Le `mcp-cli` docs utilisent cette même `server_config.json` forme et la même `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` configuration du système de fichiers.
{% endstep %}
{% step %}
#### Exécutez un hôte MCP terminal contre llama.cpp
Utilisez le `mcp-cli` ; c'est un client/hôte MCP en ligne de commande avec mode chat, découverte d'outils et prise en charge de fournisseurs OpenAI compatibles personnalisés. Sa documentation recommande `uvx mcp-cli --help`, support projet `server_config.json`, et la prise en charge de fournisseurs OpenAI compatibles personnalisés à l'exécution via `--api-base` et `--api-key`.
`mcp-cli` nécessite un fichier de configuration pour démarrer. Il faut donc ajouter une étape pour le créer. Par exemple :
{% code title="" expandable="true" %}
```bash
mkdir -p ~/.chuk_llm
cat > ~/.chuk_llm/config.yaml <<'YAML'
openai_compatible:
client_class: "chuk_llm.llm.providers.openai_client:OpenAILLMClient"
default_model: "local"
models: ["*"]
YAML
```
{% endcode %}
Puis exécutez :
```bash
uvx mcp-cli \\
--provider llamacpp \\
--api-base http://127.0.0.1:8080/v1 \\
--api-key none \\
--model local \\
--server filesystem \\
--config-file server_config.json
```
Puis essayez :
```
Listez les fichiers dans l'espace de travail du système de fichiers.
```
Puis :
```
Créez hello.txt avec une salutation d'une ligne, puis relisez-le.
```
`mcp-cli` a la confirmation des appels d'outils activée par défaut, donc vous devriez voir des invites avant l'exécution des outils.
**Exemple de code complet :**
{% code expandable="true" %}
```bash
# terminal 1
llama-server -hf unsloth/gemma-4-E4B-it-GGUF:UD-Q4_K_XL \\
--alias local --host 127.0.0.1 --port 8080 --no-ui \\
--temp 1.0 --top-p 0.95 --top-k 64 \\
--chat-template-kwargs '{"enable_thinking":false}'
# terminal 2, dans le dossier contenant server_config.json
uvx mcp-cli \\
--provider llamacpp \\
--api-base http://127.0.0.1:8080/v1 \\
--api-key none \\
--model local \\
--server filesystem \\
--config-file server_config.json
```
{% endcode %}
{% endstep %}
{% endstepper %}
### Dépannage
Si un serveur ne parvient pas à se connecter ou que ses outils n'apparaissent pas, vérifiez que l'URL est le point de terminaison de base du serveur (par ex. `https://mcp.vercel.com`), et non une page de documentation ou de tableau de bord. Pour les serveurs OAuth, terminez la connexion dans le navigateur lorsqu'elle s'ouvre ; pour les serveurs basés sur un jeton, vérifiez le `Authorization` l'en-tête et que le jeton est valide.
Cliquez sur **Actualiser** si les outils n'apparaissent pas après la connexion, et assurez-vous que l'interrupteur du serveur individuel ainsi que le **Utiliser les serveurs MCP** interrupteur principal sont activés.
### Notes de sécurité
Ne connectez que les serveurs MCP en lesquels vous avez confiance. Examinez les autorisations demandées et gardez la confirmation humaine activée pour les actions qui lisent des données privées, modifient des déploiements, achètent des domaines ou modifient des projets. Soyez particulièrement prudent lorsque vous combinez des serveurs MCP avec la recherche web ou d'autres outils, car du contenu injecté dans le prompt peut tenter de déclencher des appels d'outils indésirables.
### Serveurs MCP populaires
Voici une liste de quelques serveurs MCP populaires et utiles auxquels vous pouvez vous connecter :
| Serveur MCP | Idéal pour | Pourquoi c'est utile |
| --------------------------------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **MCP GitHub** | Dépôts, tickets, PR, recherche de code, Actions | MCP GitHub officiel avec configuration distante et locale, couvrant les dépôts, les tickets, les pull requests, Actions, la sécurité du code, et plus encore. ([GitHub](https://github.com/github/github-mcp-server)) |
| **Context7** | Documentation et exemples récents des bibliothèques | Récupère la documentation actuelle, spécifique à la version, pour les assistants de codage au lieu de s'appuyer sur des données d'entraînement obsolètes. Utilise `https://mcp.context7.com/mcp`. ([GitHub](https://github.com/upstash/context7)) |
| **MCP Notion** | Documentation, notes, tâches, connaissances du projet | Idéal pour les équipes qui utilisent Notion pour les spécifications, PRD, feuilles de route ou notes. Le MCP hébergé peut lire et écrire le contenu de l'espace de travail. ([Développeurs Notion](https://developers.notion.com/guides/mcp/overview)) |
| **MCP Slack** | Recherche dans les conversations d'équipe | Permet aux outils d'IA d'interroger les messages, canaux, fichiers, fils de discussion et informations des membres Slack ; les actions dépendent des autorisations. ([Slack](https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server)) |
| **MCP Linear** | Tickets, projets, workflows produit | MCP distant officiel pour trouver, créer et mettre à jour les tickets, projets, commentaires et objets associés Linear. ([Linear](https://linear.app/changelog/2025-05-01-mcp)) |
| **MCP Vercel** | Déploiements, journaux, documentation, domaines | Utile pour les workflows frontend/web : inspecter les déploiements, les journaux, la documentation et le contexte du projet. Vérifiez d'abord la compatibilité du client. ([Vercel](https://vercel.com/docs/agent-resources/vercel-mcp?utm_source=chatgpt.com)) |
| **MCP Sentry** | Débogage en production | Aide les agents à inspecter les tickets, traces, erreurs et données de performance Sentry dans des workflows de développement avec validation humaine. ([GitHub](https://github.com/getsentry/sentry-mcp)) |
| **MCP système de fichiers / fichiers locaux** | Fichiers du projet local | Utile pour les configurations de LLM locales, généralement via `stdio`. Les serveurs de référence sont à considérer surtout comme des exemples ou des points de départ. ([GitHub](https://github.com/modelcontextprotocol/servers)) |
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://unsloth.ai/docs/fr/bases/mcp.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.