> 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 é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, applications, bases de données et outils locaux au lieu de simplement discuter de mémoire, afin de 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) car 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 cloud [des fournisseurs](/docs/fr/integrations/connections.md). **Nous montrerons aussi 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 [l'exécution de code](/docs/fr/nouveau/studio/chat.md#code-execution) et [la recherche web](/docs/fr/nouveau/studio/chat.md#advanced-web-search), donc un seul modèle peut rechercher sur le web, exécuter du code et appeler vos services connectés dans le même fil de conversation.

### Cas d'utilisation

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

* **Rechercher dans 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 déroulent 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 le web avec des embeddings** - Le serveur MCP d'Exa peut être utilisé pour des recherches web sémantiques avec prise en charge d'embeddings contextuels.
* **Déboguer des interfaces de sites web** - Les serveurs MCP Playwright et Chrome DevTools peuvent être utilisés pour piloter des sites web afin de trouver des correctifs aux problèmes.

### Démarrage rapide

Nous allons utiliser deux façons de connecter votre modèle local sur votre appareil aux serveurs MCP. Les deux utilisent des paquets 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.

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

### 🦥 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) avec les 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 cela. Les mêmes étapes fonctionnent pour n'importe quel serveur MCP.

{% stepper %}
{% step %}

#### Configurer Unsloth

Le moyen le plus simple de commencer est d'installer l'application [Unsloth Desktop](/docs/fr/desktop.md) . Elle prend en charge [MacOS](/docs/fr/commencer/install/mac.md), Linux, [Windows](/docs/fr/commencer/install/windows-installation.md), [NVIDIA](/docs/fr/commencer/install/pip-install.md), [AMD](/docs/fr/commencer/install/amd.md), Intel et les configurations CPU.

<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](/docs/fr/desktop.md#get-started) pour 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. Activer Exa [la 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 « Add custom MCP », et une fenêtre contextuelle s'affichera :

<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 détails du serveur :

1. **Nom d'affichage**: une étiquette conviviale, 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 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 <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 **Tester la connexion** pour confirmer qu'Unsloth peut atteindre le serveur. Une fois que cela réussit, cliquez sur **Ajouter le serveur** pour l'enregistrer.

Si **Tester la connexion** cela échoue, 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 la résolution des problèmes 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 les outils 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 **basculer** son état marche/arrêt, **actualiser** ses outils, **modifier** le, ou **supprimer** le. Assurez-vous que le bouton du serveur et le **Utiliser les serveurs MCP** bouton principal sont activés, puis fermez la boîte de dialogue.

Il sera mis en surbrillance s'il est activé. Vous pouvez aussi le désactiver en cliquant simplement dessus à nouveau.

<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 le chat**

Choisissez n'importe quel modèle dans le menu déroulant **Sélectionner un modèle** et commencez à discuter. Le modèle peut maintenant appeler de lui-même les outils du serveur lorsque votre demande l'exige.

Ci-dessus, un `gemma-4-E2B-it-GGUF local` a été interrogé *« Pouvez-vous utiliser le serveur MCP Vercel ? »* et a indiqué les actions qu'il peut effectuer : gérer des projets, analyser des journaux, lister 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 on appelait 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 nous activerons les 3.

Si vous demandez « Unsloth peut-il prendre en charge le fine-tuning de Qwen », Exa fournira de très bons détails à 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>

Puis, en suivi, « Rechercher dans la documentation Unsloth comment faire cela », et Context7 est utilisé pour 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 tapez « Rechercher sur Hugging Face des modèles unsloth/Qwen », 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 spécifique

Une fois qu'un serveur est connecté, demandez au modèle de faire un vrai travail en langage simple. Quelques exemples avec le serveur Vercel :

* **Déboguer une build en échec**: *« Récupère les journaux de build de mon dernier déploiement et dis-moi pourquoi il a échoué. »*
* **Vérifier l'état du déploiement**: *« Liste mes déploiements les plus récents et leur état. »*
* **Rechercher dans la documentation**: *« Recherche dans la documentation Vercel comment configurer un domaine personnalisé. »*
* **Recherche de domaine**: *« Est-ce que `myproject.dev` est 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 modèle Gemma 4 26B-A4B plus grand :

```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 de réglages 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": "Say hello in one sentence."}]
  }'
```

{% endstep %}

{% step %}

#### Créer un bac à sable 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é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 le vrai chemin de votre espace de travail. La documentation IBM de `mcp-cli` utilise 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écuter un hôte MCP de terminal avec 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`, prise en charge de projet `server_config.json`, et prise en charge de fournisseurs OpenAI compatibles personnalisés au runtime 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 %}

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

Essayez ensuite :

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

Puis :

```
Créez hello.txt avec un message de salutation d'une ligne, puis relisez-le.
```

`mcp-cli` a la confirmation des appels d'outils activée par défaut, vous devriez donc voir des invites avant l'exécution d'un outil.

**Exemple complet de code :**

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

### Serveurs MCP locaux avec accès à distance ou accès LAN

En plus des `http(s)://` , le **champ URL ou exécutable** accepte aussi une commande locale telle que `npx`, `uvx` ou le chemin vers un binaire serveur, avec ses arguments dans les lignes **Arguments** Ces serveurs locaux (stdio) s'exécutent comme un programme sur votre ordinateur.

Lorsque **l'accès à distance** ou **l'accès LAN** est activé dans les paramètres (ou qu'Unsloth a été démarré avec `--secure`), Unsloth est accessible depuis d'autres appareils, donc les commandes locales sont désactivées et l'enregistrement de l'une d'elles affiche :

{% 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 toujours 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 servir en HTTP. Démarrez-le en le liant à `127.0.0.1` afin que seule cette machine 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>

   Puis ajoutez `http://127.0.0.1:7082/mcp` dans la boîte de dialogue MCP. Cela fonctionne dans Unsloth Desktop et Studio avec l'accès à distance activé. Exécutez le serveur MCP sur l'ordinateur qui exécute Unsloth, pas sur l'appareil depuis lequel vous naviguez ; avec [Docker](/docs/fr/commencer/install/docker.md), `127.0.0.1` est le conteneur lui-même, donc démarrez le serveur à l'intérieur du conteneur (`docker exec`). Pour un serveur qui ne parle que stdio, un pont stdio-vers-HTTP tel que [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) fait le même travail, par ex. `mcp-proxy --port=8099 uvx mcp-server-fetch`, puis ajoutez `http://127.0.0.1:8099/mcp`.
2. **Autoriser explicitement les commandes locales (Studio).** Démarrez Studio avec la variable définie vous-même, et les commandes locales restent activées lorsque l'accès à distance ou l'accès LAN 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>

   Sous 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 via un serveur MCP. N'utilisez-le qu'avec un mot de passe fort sur des réseaux de confiance, et privilégiez l'option 1.
{% endhint %}

### Dépannage

Si un serveur ne parvient pas à se connecter ou si 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 à jeton, vérifiez le `Authorization` en-tête et que le jeton est valide.

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

Cliquez **Actualiser** si les outils n'apparaissent pas après la connexion, et assurez-vous que le bouton du serveur individuel et le **Utiliser les serveurs MCP** bouton 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. Faites particulièrement attention 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                                                                                                                                                                                                                                            |
| --------------------------------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **GitHub MCP**                                | Dépôts, problèmes, PR, recherche de code, Actions | MCP GitHub officiel avec configuration à distance et locale, couvrant les dépôts, problèmes, pull requests, Actions, sécurité du code et plus encore. ([GitHub](https://github.com/github/github-mcp-server))                                                   |
| **Context7**                                  | Documentation et exemples de bibliothèque récents | Récupère la documentation actuelle, spécifique à la version, pour les assistants de code 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**                                | Docs, notes, tâches, connaissance des projets     | Idéal pour les équipes utilisant Notion pour les spécifications, les PRD, les feuilles de route ou les 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))  |
| **Slack MCP**                                 | Recherche dans les conversations d’équipe         | Permet aux outils d’IA d’interroger les messages, canaux, fichiers, fils de discussion et informations sur les membres Slack ; les actions dépendent des autorisations. ([Slack](https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server)) |
| **Linear MCP**                                | Tickets, projets, flux de travail produit         | MCP distant officiel pour rechercher, créer et mettre à jour des tickets Linear, des projets, des commentaires et des objets associés. ([Linear](https://linear.app/changelog/2025-05-01-mcp))                                                                  |
| **Vercel MCP**                                | Déploiements, journaux, docs, domaines            | Utile pour les workflows frontend/web : inspectez 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)) |
| **Sentry MCP**                                | 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 intervention humaine. ([GitHub](https://github.com/getsentry/sentry-mcp))                                                    |
| **MCP système de fichiers / fichiers locaux** | Fichiers de projet locaux                         | Utile pour les configurations 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 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.