> 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/notions-de-base/mcp.md).

# Comment utiliser des serveurs MCP avec des LLM locaux

Découvrez comment connecter des serveurs MCP à des modèles d'IA ouverts avec des captures d'écran.

Ce guide pas à pas vous explique comment connecter des serveurs **Model Context Protocol (MCP)** à des LLM locaux comme [Qwen](https://unsloth.ai/docs/fr/modeles/qwen3.6.md) ou [Gemma](https://unsloth.ai/docs/fr/modeles/gemma-4.md), afin que tout 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, applications, bases de données et outils locaux, plutôt que de converser uniquement à partir de ses connaissances. Vous pouvez ainsi créer un assistant IA plus utile, privé et interchangeable, capable d’agir sur votre environnement réel.

Nous utiliserons les dépôts open source [Unsloth](https://github.com/unslothai/unsloth) et [llama.cpp](#llama.cpp-guide) , deux frameworks populaires pour l’inférence et le déploiement de modèles locaux. MCP fonctionne avec les modèles GGUF locaux et les [modèles de fournisseurs cloud.](https://unsloth.ai/docs/fr/integrations/connections.md). **Nous montrerons également comment utiliser** [**plusieurs serveurs MCP**](#using-multiple-mcp-servers) **.**

Les outils MCP fonctionnent aux côtés d’autres capacités du modèle, telles que [l’exécution de code](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#code-execution) et [la recherche sur le Web](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#advanced-web-search), afin qu’un même modèle puisse effectuer des recherches sur le Web, exécuter du code et appeler vos services connectés dans un même fil de discussion.

### Cas d’utilisation

Une fois un serveur MCP connecté, vous pouvez demander à votre modèle local d’effectuer de nombreuses tâches automatisées. Voici quelques exemples :

* **Rechercher dans la documentation :** « Trouve la documentation pertinente et résume les étapes de configuration. » - Context7 peut être utilisé pour cela.
* **Analyser une base de code :** « Cartographie ce dépôt et explique où sont gérés l’authentification, la facturation et l’accès aux données. » - Le serveur MCP officiel de GitHub et GitMCP peuvent être utilisés pour analyser des dépôts.
* **Effectuer des recherches sur le Web à l’aide de plongements vectoriels** - Le serveur MCP d’Exa peut être utilisé pour des recherches sémantiques sur le Web avec prise en charge des plongements contextuels.
* **Déboguer les interfaces de sites Web** - Les serveurs MCP Playwright et Chrome DevTools peuvent être utilisés pour interagir avec des sites Web et trouver des solutions aux problèmes.

### Démarrage rapide

Nous allons utiliser deux méthodes pour connecter à des serveurs MCP un modèle local exécuté sur votre appareil. 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 votre modèle, le rendre accessible et le déployer.

<a href="https://unsloth.ai/docs/fr/notions-de-base/mcp.md#unsloth-guide" class="button primary">Guide MCP pour Unsloth</a><a href="https://unsloth.ai/pages/461bc12a9c9013e37989c418310c1a16a50732de#llama.cpp-guide" class="button primary">Guide MCP pour Llama.cpp</a>

### 🦥 Guide Unsloth

Dans cet exemple, nous utiliserons Unsloth pour connecter un modèle local, tel que [Qwen3.6](https://unsloth.ai/docs/fr/modeles/qwen3.6.md) ou [Gemma 4](https://unsloth.ai/docs/fr/modeles/gemma-4.md) , aux serveurs MCP suivants : [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 ces serveurs. Les mêmes étapes fonctionnent pour tout serveur MCP.

{% stepper %}
{% step %}

#### Configurer Unsloth

Le moyen le plus simple de commencer consiste à installer le [Unsloth Desktop](https://unsloth.ai/docs/fr/desktop.md) application. Elle est compatible avec [macOS](https://unsloth.ai/docs/fr/commencer/install/mac.md), Linux, [Windows](https://unsloth.ai/docs/fr/commencer/install/windows-installation.md), [NVIDIA](https://unsloth.ai/docs/fr/commencer/install/pip-install.md), [AMD](https://unsloth.ai/docs/fr/commencer/install/amd.md), Intel et les configurations avec processeur.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Télécharger Unsloth</a>

* <i class="fa-apple">:apple:</i> [Télécharger pour macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Télécharger pour Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Télécharger pour Linux](https://unsloth.ai/download/linux)

Ou, si vous préférez une installation manuelle :

**macOS, Linux, WSL :**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows PowerShell :**

```bash
irm https://unsloth.ai/install.ps1 | iex
```

[Voir ici](https://unsloth.ai/docs/fr/desktop.md#get-started) pour obtenir des instructions détaillées.
{% endstep %}

{% step %}

#### **Activer MCP**

Cliquez sur « MCP » dans la barre d’outils du chat.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqNVeCtCvYRMqKT9sSZey%2Fimage.png?alt=media&amp;token=9755a1cc-8118-40ba-ba1f-3b9ac0ef773d" alt=""><figcaption></figcaption></figure>

Par défaut, Unsloth Studio prend en charge MCP pour Context7, Exa et Hugging Face. L’activation de la recherche Web d’Exa [recherche Web](https://unsloth.ai/docs/fr/nouveau/studio/chat.md#advanced-web-search) désactivera l’outil de recherche par défaut dont nous disposons.
{% endstep %}

{% step %}

#### **Ajouter des serveurs MCP personnalisés**

Pour ajouter le serveur MCP de Vercel, cliquez sur « Ajouter un MCP personnalisé » : une fenêtre contextuelle s’affiche.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FaO9zf15MX1jWL7nOmdyK%2Fimage.png?alt=media&amp;token=8ae977f0-8388-414c-9fbd-ae1efff464f2" alt=""><figcaption></figcaption></figure>

Renseignez les informations du serveur :

1. **Nom d’affichage**: un libellé convivial, par exemple `Vercel`.
2. **URL**: le point de terminaison de base du serveur, par exemple `https://mcp.vercel.com`.
3. Choisissez ci-dessous une méthode d’authentification.

{% tabs %}
{% tab title="Connexion OAuth" %}
Pour les serveurs qui nécessitent une authentification via navigateur (GitHub, Linear, Vercel, etc.), activez **Utiliser la connexion OAuth**. Une fenêtre de navigateur s’ouvrira lors de la première connexion pour vous permettre d’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 en-tête `Authorization` avec votre jeton :

```
Authorization: Bearer <your-token>
```

{% endtab %}
{% endtabs %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FbgCzTby2rF3qgleWLNXA%2Fmcp-server-added.png?alt=media&amp;token=8095e37e-a4fa-4857-a5aa-0562af526eca" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Tester et ajouter**

Cliquez sur **Tester la connexion** pour vérifier qu’Unsloth peut joindre le serveur. Une fois le test réussi, cliquez sur **Ajouter le serveur** pour l’enregistrer.

Si **Tester la connexion** échoue, vérifiez que l’URL correspond au point de terminaison de base du serveur (et non à une page de documentation) et que votre méthode d’authentification est correcte. Consultez la section Dépannage ci-dessous.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FJeR2x79EkJaG4jYuOiBt%2Fmcp-add-server.png?alt=media&amp;token=38c4fdee-130f-415b-8c5d-e906f13c1555" alt="" width="563"><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **Vérifier le chargement des outils**

Le serveur apparaît maintenant dans la liste des serveurs MCP. Unsloth récupère automatiquement ses outils et affiche une confirmation, par exemple : *Actualisation de « Vercel » (18 outils)*.

Chaque serveur dispose de commandes pour **l’activer ou le désactiver,** l’ **actualiser** ses outils, **le modifier** ou **supprimer** le. Vérifiez que le bouton bascule du serveur et le **Utiliser les serveurs MCP** bouton bascule principal sont activés, puis fermez la boîte de dialogue.

Le serveur est mis en surbrillance s’il est activé. Vous pouvez aussi le désactiver en cliquant à nouveau dessus.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FgunafFRR6EdrF0xXjIuG%2Fimage.png?alt=media&amp;token=3a91e79f-33d0-44da-a7a3-ded37a34b594" alt=""><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### **L’utiliser dans une conversation**

Choisissez n’importe quel modèle dans la **Sélectionner un modèle** liste déroulante et commencez à discuter. Le modèle peut désormais appeler de lui-même les outils du serveur lorsque votre demande le nécessite.

Ci-dessus, un modèle local `gemma-4-E2B-it-GGUF` a reçu la demande *« Peux-tu utiliser le serveur MCP de Vercel ? »* et a indiqué les actions qu’il peut effectuer : gérer des projets, analyser des journaux, répertorier des équipes, générer des liens d’accès, vérifier des domaines et rechercher dans la documentation de Vercel.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FoenMZ3aZx2yUX9ueAbmy%2Fmcp-chat-usecase.png?alt=media&amp;token=4284a8da-e77f-4961-8154-742cd75e4b01" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

#### Utiliser plusieurs serveurs MCP

Et si l’on appelait plusieurs serveurs MCP, par exemple trois ? Nous allons utiliser les serveurs MCP Exa, Context7 et Hugging Face fournis par défaut dans Unsloth Studio, et activer les trois.

Si vous demandez « Unsloth prend-il en charge le fine-tuning de Qwen ? », Exa fournira des informations très utiles à ce sujet :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FbqfXsWpuNJksyX2cLgfz%2Fimage.png?alt=media&amp;token=9f66e3e9-0e78-4016-853d-a7a8b63c4d25" alt=""><figcaption></figcaption></figure>

Ensuite, enchaînez avec « Recherche dans la documentation d’Unsloth comment faire cela », et Context7 sera utilisé pour consulter la documentation :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FrPFQ90O4o8SIydVhDndx%2Fimage.png?alt=media&amp;token=35a48ee5-974b-45de-aba9-e9fb1e7833dd" alt=""><figcaption></figcaption></figure>

Puis saisissez « Recherche des modèles unsloth/Qwen sur Hugging Face », et le serveur MCP de Hugging Face sera appelé :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F9KPBtO3VFxC6Y9e4Hl0d%2Fimage.png?alt=media&amp;token=1c1757dc-4ccb-424f-b98b-29ae173df757" alt=""><figcaption></figcaption></figure>

#### Autre exemple de cas d’utilisation précis

Une fois un serveur connecté, demandez au modèle d’effectuer des tâches concrètes en langage courant. Voici quelques exemples avec le serveur Vercel :

* **Déboguer une compilation qui échoue**: *« Récupère les journaux de compilation de mon dernier déploiement et dis-moi pourquoi il a échoué. »*
* **Vérifier l’état d’un déploiement**: *« Répertorie mes déploiements les plus récents et leur état. »*
* **Rechercher dans la documentation**: *« Recherche dans la documentation Vercel comment configurer un domaine personnalisé. »*
* **Rechercher des informations sur un domaine**: *« Est-ce que `myproject.dev` est disponible, et combien coûterait-il ? »*

### 🦙 Guide Llama.cpp

{% stepper %}
{% step %}

#### Installer ou compiler llama.cpp

**macOS :**

```bash
brew install llama.cpp
```

Ou, pour **Linux, Windows et WSL,** compilez à 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
```

Une compilation à partir des sources n’ajoute pas llama-server au PATH. Depuis le répertoire dans lequel vous avez exécuté git clone, ajoutez le répertoire de sortie de compilation au PATH dans le terminal qui exécutera le serveur. Sous Linux ou WSL (Bash) :

{% code collapsedlinecount="10" %}

```bash
export PATH="$(pwd)/llama.cpp/build/bin:$PATH"
llama-server --help
```

{% endcode %}

Sous Windows natif avec le générateur Visual Studio par défaut, les exécutables Release se trouvent dans llama.cpp\build\bin\Release. Dans PowerShell :

{% code collapsedlinecount="10" %}

```powershell
$env:PATH = "$(Resolve-Path .\llama.cpp\build\bin\Release);$env:PATH"
llama-server.exe --help
```

{% endcode %}

Avec un générateur à configuration unique, tel que Ninja sous Windows, utilisez plutôt .\llama.cpp\build\bin. Répétez la configuration du PATH dans chaque nouveau terminal du serveur, en utilisant le chemin absolu de votre copie du dépôt si vous avez changé de répertoire. Les exemples de commandes multilignes ci-dessous utilisent la syntaxe Bash ; sous PowerShell natif, saisissez chaque commande sur une seule ligne ou remplacez les barres obliques inverses de continuation de ligne de Bash par des accents graves PowerShell. Les utilisateurs de Homebrew peuvent continuer à utiliser directement llama-server.
{% endstep %}

{% step %}

#### Démarrer llama-server avec un fichier GGUF

Nous utilisons [Gemma 4](https://unsloth.ai/docs/fr/modeles/gemma-4.md) GGUF E4B 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 modèle Gemma 4 26B-A4B, plus volumineux :

```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 découvrir d’autres réglages des paramètres d’inférence, consultez notre [guide Gemma 4](https://unsloth.ai/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": "Say hello in one sentence."}]
  }'
```

{% endstep %}

{% step %}

#### Créer un bac à sable de système de fichiers MCP

```bash
mkdir -p ~/mcp-workspace
cd ~/mcp-workspace
pwd
```

Copiez le chemin absolu. Créez un dossier de projet distinct pour votre hôte MCP :

```bash
mkdir -p ~/llama-mcp
cd ~/llama-mcp
```

Créez `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 celui de votre véritable espace de travail. La `mcp-cli` documentation d’IBM utilise la même structure de `server_config.json` et la même `npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files` configuration du système de fichiers.
{% endstep %}

{% step %}

#### Exécuter un hôte MCP dans le terminal avec llama.cpp

Utilisez le `mcp-cli`d’IBM ; il s’agit d’un client/hôte MCP en ligne de commande qui propose un mode de conversation, la découverte d’outils et la prise en charge de fournisseurs personnalisés compatibles avec OpenAI. Sa documentation recommande `uvx mcp-cli --help`, prend en charge les fichiers de projet `server_config.json`, et prend en charge les fournisseurs personnalisés compatibles avec OpenAI au moment de l’exécution via `--api-base` et `--api-key`.

`mcp-cli` a besoin d’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 %}

Exécutez ensuite :

```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
```

Essayez ensuite :

```
Listez les fichiers de l’espace de travail du système de fichiers.
```

Puis :

```
Créez hello.txt avec un message de bienvenue sur une seule ligne, puis relisez-le.
```

`mcp-cli` active par défaut la confirmation des appels d’outils ; vous devriez donc voir des invites avant leur exécution.

**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 %}

### Moteurs de jeu et applications 3D

Unsloth propose des entrées MCP en un clic pour **Blender**, **Unity**, **Unreal Engine**, **Godot**, **Figma** et **Roblox Studio**. Consultez [Moteurs de jeu et applications 3D](https://unsloth.ai/docs/fr/notions-de-base/mcp/mcp-engines.md) pour des instructions de configuration détaillées et des démonstrations.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F5zX7CyoLMVp3Cl811T5u%2Freplace-0.webp?alt=media&amp;token=e0026647-232b-4ebb-b0fd-6f0c0422e96d" alt="A local model building a village in Unreal Engine from Unsloth chat"><figcaption><p>Qwen3.8-27B construit un village dans Unreal Engine 5.8 à partir d’une conversation Unsloth.</p></figcaption></figure>

### Serveurs MCP locaux avec accès à distance ou sur le réseau local

Outre les URL `http(s)://` ou l’exécutable, l’ **URL ou exécutable** Le champ accepte également une commande locale telle que `npx`, `uvx` ou le chemin vers un binaire de serveur, avec ses arguments dans les lignes **Arguments** . Ces serveurs locaux (stdio) s’exécutent comme des programmes sur votre ordinateur.

Lorsque **L’accès à distance** ou **L’accès au réseau local** est activé dans les paramètres (ou si Unsloth a été démarré avec `--secure`), Unsloth est accessible depuis d’autres appareils. Les commandes locales sont donc désactivées et l’enregistrement de l’une d’elles affiche le message suivant :

{% code collapsedlinecount="10" %}

```
Les commandes locales sont désactivées lorsque l’accès à distance est activé, car le serveur est accessible depuis l’extérieur de cette machine.
```

{% endcode %}

Vous pouvez tout de même utiliser des serveurs MCP locaux de deux façons :

1. **Exécutez le serveur en HTTP sur votre propre machine (recommandé).** De nombreux serveurs MCP peuvent eux-mêmes fournir un accès HTTP. Démarrez-le en le liant à `127.0.0.1` afin que seul cet ordinateur puisse y accéder, puis ajoutez son adresse comme URL. Par exemple, pour [osmmcp](https://github.com/nervsystems/osmmcp):

   <pre class="language-bash" data-collapsed-line-count="10"><code class="lang-bash">osmmcp --enable-http --http-only --http-addr 127.0.0.1:7082
   </code></pre>

   Ajoutez ensuite `http://127.0.0.1:7082/mcp` dans la boîte de dialogue MCP. Cette méthode fonctionne dans Unsloth Desktop et Studio lorsque l’accès à distance est activé. Exécutez le serveur MCP sur l’ordinateur où Unsloth fonctionne, et non sur l’appareil depuis lequel vous naviguez ; avec [Docker](https://unsloth.ai/docs/fr/commencer/install/docker.md), `127.0.0.1` désigne le conteneur lui-même. Démarrez donc le serveur à l’intérieur du conteneur (`docker exec`). Pour un serveur qui ne prend en charge que stdio, un pont stdio-vers-HTTP tel que [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) fait la même chose, par exemple : `mcp-proxy --port=8099 uvx mcp-server-fetch`, puis ajoutez `http://127.0.0.1:8099/mcp`.
2. **Autorisez explicitement les commandes locales (Studio).** Démarrez Studio en définissant vous-même la variable ; les commandes locales resteront activées lorsque l’accès à distance ou l’accès au réseau local est activé :

   <pre class="language-bash" data-collapsed-line-count="10"><code class="lang-bash">UNSLOTH_STUDIO_ALLOW_STDIO_MCP=1 unsloth studio
   </code></pre>

   Dans Windows PowerShell : `$env:UNSLOTH_STUDIO_ALLOW_STDIO_MCP = "1"; unsloth studio`.

{% hint style="warning" %}
Avec l’option 2, toute personne pouvant se connecter à votre Studio via le réseau peut exécuter des programmes sur votre ordinateur par l’intermédiaire d’un serveur MCP. Utilisez cette option uniquement avec un mot de passe robuste et sur des réseaux de confiance ; privilégiez l’option 1.
{% endhint %}

### Dépannage

Si un serveur ne parvient pas à se connecter ou si ses outils ne s’affichent pas, vérifiez que l’URL correspond au point de terminaison de base du serveur (par exemple, `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’il s’ouvre ; pour les serveurs utilisant des jetons, vérifiez l’en-tête `Authorization` et assurez-vous que le jeton est valide.

Si l’enregistrement d’une commande locale échoue avec le message « Les commandes locales sont désactivées lorsque l’accès à distance est activé », consultez [Serveurs MCP locaux avec l’accès à distance ou l’accès au réseau local](#local-mcp-servers-with-remote-access-or-lan-access).

Cliquez sur **Actualiser** si les outils ne s’affichent pas après la connexion, et vérifiez que le bouton d’activation du serveur concerné ainsi que le bouton principal **Utiliser les serveurs MCP** sont activés.

### Consignes de sécurité

Ne connectez que des serveurs MCP auxquels vous faites confiance. Examinez les autorisations demandées et maintenez 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 sur le Web ou d’autres outils, car du contenu contenant des instructions malveillantes peut tenter de déclencher des appels d’outils indésirables.

### Serveurs MCP populaires

Voici quelques serveurs MCP populaires et utiles auxquels vous pouvez vous connecter :

| Serveur MCP                                                | Idéal pour                                                        | Pourquoi c’est utile                                                                                                                                                                                                                                                                         |
| ---------------------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GitHub MCP**                                             | Dépôts, problèmes, demandes de tirage, recherche de code, Actions | Serveur MCP officiel de GitHub, avec configuration à distance et locale, couvrant les dépôts, les problèmes, les demandes de tirage, Actions, la sécurité du code et plus encore. ([GitHub](https://github.com/github/github-mcp-server))                                                    |
| **Context7**                                               | Documentation et exemples récents sur les bibliothèques           | Récupère la documentation actuelle et propre à chaque version pour les assistants de programmation, 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))                                   |
| **Notion MCP**                                             | Documentation, notes, tâches, connaissances de projet             | Utile pour les équipes qui utilisent Notion pour les spécifications, les PRD, les feuilles de route ou les notes. Le serveur MCP hébergé peut lire et modifier le contenu de l’espace de travail. ([Notion Developers](https://developers.notion.com/guides/mcp/overview))                   |
| **Slack MCP**                                              | Recherche dans les conversations d’équipe                         | Permet aux outils d’IA d’interroger les messages, les canaux, les fichiers, les fils de discussion et les informations sur les membres de Slack ; les actions possibles dépendent des autorisations. ([Slack](https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server)) |
| **Linear MCP**                                             | Problèmes, projets, flux de travail produit                       | Serveur MCP distant officiel permettant de rechercher, créer et mettre à jour des problèmes, des projets, des commentaires et des objets associés dans Linear. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                                                       |
| **Vercel MCP**                                             | Déploiements, journaux, documentation, domaines                   | Utile pour les flux de travail frontend et Web : permet d’examiner les déploiements, les journaux, la documentation et le contexte des projets. Vérifiez d’abord la compatibilité du client. ([Vercel](https://vercel.com/docs/agent-resources/vercel-mcp?utm_source=chatgpt.com))           |
| **Sentry MCP**                                             | Débogage en production                                            | Aide les agents à examiner les problèmes, les traces, les erreurs et les données de performances dans Sentry, dans le cadre de flux de développement avec intervention humaine. ([GitHub](https://github.com/getsentry/sentry-mcp))                                                          |
| **MCP pour le système de fichiers et les fichiers locaux** | Fichiers de projet locaux                                         | Utile pour les configurations LLM locales, généralement via `stdio`. Il vaut mieux considérer les serveurs de référence 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/notions-de-base/mcp.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
