MCP en OpenCode sur DeepSeek : comment connecter des outils externes

MCP (Model Context Protocol) est un protocole ouvert qui décrit comment connecter des outils et des sources de données externes au modèle de langage : un système de fichiers, une documentation, un suivi des tâches, un suivi des bogues ou votre propre service. Au lieu d’intégrer chaque outil dans l’agent, vous configurez un serveur MCP distinct et l’agent communique avec lui selon le schéma standard.

OpenCode prend en charge MCP dès le départ : à la fois les serveurs locaux, qui sont lancés par un processus enfant, et les serveurs distants, accessibles via HTTP. Un point important est que l’ensemble de la couche MCP est implémentée du côté d’OpenCode lui-même, et non du côté du fournisseur de modèles. Par conséquent, DeepSeek reçoit les outils MCP comme fonctions normales dans la requête et n’a pas besoin de connaître quoi que ce soit sur le protocole lui-même.

Dans cet article, je vais voir comment ajouter un serveur local et distant, comment obtenir une autorisation, comment ne pas se noyer sous les jetons et ce qu’il faut prendre en compte lorsque l’on travaille avec des modèles DeepSeek.

Ce dont vous avez besoin

Pour travailler, vous avez besoin de trois choses :

• OpenCode installé. Si l’agent n’est pas encore configuré, j’ai discuté de la procédure d’installation et de connexion de DeepSeek dans une note séparée.
• Node.js et npx. Nécessaire pour les serveurs MCP locaux, qui sont distribués sous forme de packages npm.
• Clés d’accès. Uniquement pour les serveurs distants qui nécessitent une autorisation. Les serveurs publics comme Context7 fonctionnent sans clé, mais avec des limites inférieures.

Comment ça marche

Les serveurs sont décrits dans la configuration OpenCode dans le bloc mcp. Chaque serveur possède un nom unique sous lequel il peut être mentionné dans une requête. Les outils serveur sont enregistrés avec ce préfixe de nom, il n’y a donc aucun conflit entre les différents serveurs.

Après la connexion, les outils MCP deviennent disponibles pour les modèles avec ceux intégrés : lecture de fichiers, édition de code et exécution de commandes. Du point de vue de DeepSeek, il s’agit de fonctions ordinaires qu’un agent peut appeler – c’est pourquoi le bundle fonctionne sans aucune prise en charge MCP du côté de l’API du modèle.

Serveur local

Le moyen le plus simple de se familiariser avec le mécanisme est d’utiliser le serveur de test @modelcontextprotocol/server-everything. Ajoutons-le au fichier opencode.json à la racine du projet :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mcp_everything": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-everything"]
    }
  }
}

Le champ commande est la commande de démarrage du serveur et ses arguments sous forme de tableau. Après avoir redémarré OpenCode, les outils apparaîtront dans la session et pourront être demandés explicitement :

используй инструмент mcp_everything, чтобы сложить 3 и 4

Le serveur local possède plusieurs champs plus utiles. environment définit les variables d’environnement du processus, cwd – le répertoire de travail, timeout – le délai d’attente de la demande en millisecondes, et enabled vous permet de désactiver temporairement le serveur sans le supprimer de la configuration.

Serveur distant

Les serveurs distants sont plus pratiques : vous n’avez pas besoin d’exécuter quoi que ce soit localement et ils sont accessibles via une URL. Un bon exemple est Context7, qui recherche une documentation de bibliothèque à jour. Il se connecte sans clé :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp"
    }
  }
}

Si vous disposez d’un compte Context7 gratuit, la clé est d’augmenter les limites. Les en-têtes sont transmis via le bloc headers, et il est pratique de conserver la clé elle-même dans une variable d’environnement :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}"
      }
    }
  }
}

La construction {env:NAME} remplace la valeur de la variable d’environnement lors du chargement de la configuration, afin que la clé ne finisse pas dans le référentiel. Avant de démarrer l’agent, la variable doit être exportée dans le terminal.

Un autre serveur public utile est Grep de Vercel, recherchez des exemples de code sur GitHub :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gh_grep": {
      "type": "remote",
      "url": "https://mcp.grep.app"
    }
  }
}

Autorisation via OAuth

Certains serveurs distants nécessitent OAuth. OpenCode peut réaliser lui-même ce scénario : il remarque la réponse 401, déclenche l’autorisation et enregistre les tokens. Pour Sentry, précisez simplement le serveur :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sentry": {
      "type": "remote",
      "url": "https://mcp.sentry.dev/mcp",
      "oauth": {}
    }
  }
}

Après cela, l’autorisation peut être démarrée manuellement – le navigateur s’ouvrira :

opencode mcp auth sentry

Les commandes de service sont également utiles dans le travail quotidien. La liste mcp opencode affiche les serveurs et l’état d’autorisation, la déconnexion opencode mcp supprime les jetons stockés et le débogage mcp opencode vérifie la connectivité réseau et la découverte OAuth pour un serveur spécifique. Les jetons sont stockés localement dans le fichier ~/.local/share/opencode/mcp-auth.json.

Si le serveur n’utilise pas OAuth, mais une clé API standard, l’autorisation automatique doit être désactivée, sinon OpenCode essaiera de transmettre OAuth là où il n’est pas nécessaire :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-api-key-server": {
      "type": "remote",
      "url": "https://mcp.example.com/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {env:MY_API_KEY}"
      }
    }
  }
}

Gestion des outils

Les outils MCP consomment du contexte : chaque serveur ajoute des descriptions de ses fonctions à la requête. Par conséquent, il est préférable de garder les serveurs rarement utilisés éteints. Cela peut être fait globalement via le bloc tools :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-mcp-foo": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command-foo"]
    },
    "my-mcp-bar": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command-bar"]
    }
  },
  "tools": {
    "my-mcp*": false
  }
}

Le modèle my-mcp* désactive tous les outils dont le nom commence par ce préfixe. S’il existe de nombreux serveurs, il est plus judicieux de les désactiver globalement et de les activer localement pour un agent spécifique :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-mcp": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command"],
      "enabled": true
    }
  },
  "tools": {
    "my-mcp*": false
  },
  "agent": {
    "my-agent": {
      "tools": {
        "my-mcp*": true
      }
    }
  }
}

Fonctionnalités DeepSeek

La connexion avec DeepSeek fonctionne car les modèles prennent en charge les fonctions d’appel et les outils MCP correspondants ressemblent à des fonctions ordinaires. DeepSeek lui-même ne connecte pas les serveurs MCP et ne devrait pas le faire : la connexion est gérée par OpenCode.

Ce à quoi vous devez faire attention :

• Sélection d’un modèle. Pour les modifications de routine et petites, deepseek-flash est suffisant. Pour les tâches où vous devez garder beaucoup de contexte en tête et sélectionner soigneusement un outil, il est préférable de donner deepseek-v4-pro.
• Taille du contexte. Les serveurs lourds comme GitHub MCP ajoutent beaucoup de jetons et, avec un grand projet, atteignent facilement la limite. Activez-les uniquement pendant la durée d’une tâche spécifique.

Les schémas d’outillage

• Coût sont envoyés avec chaque requête. Ainsi, plus il y a de serveurs inclus, plus chaque itération est coûteuse. Vous payez directement le fournisseur, de sorte que les serveurs supplémentaires sont visibles sur votre facture.
• Conseils pour l’agent. Il est plus sûr de ne pas se fier à l’ingéniosité du modèle, mais de nommer directement le serveur dans la requête ou d’écrire une règle dans AGENTS.md.

Un exemple de règle pour AGENTS.md, afin que l’agent accède lui-même à la source requise :

Когда нужно посмотреть документацию библиотеки, используй инструменты context7.

Recette pratique

Pour le travail quotidien, deux serveurs suffisent généralement : Context7 pour la documentation et un serveur restreint pour une tâche spécifique – par exemple, Sentry pour analyser les erreurs ou Grep pour rechercher des exemples de code. Il est préférable de garder le reste éteint et de l’allumer si nécessaire.

Ma procédure est la suivante : j’ajoute le serveur à opencode.json, redémarre OpenCode, vérifie la liste via la opencode mcp list, puis pose une question test qui mentionne explicitement le serveur. Si l’outil n’est pas appelé, je regarde vers le débug opencode mcp et le délai d’attente – un serveur lent peut ne pas avoir le temps de répondre dans les 30 secondes imparties.

À quoi faire attention

Quelques points pratiques. Les serveurs MCP sont du code de confiance : le serveur local s’exécute sur votre machine avec vos droits et vous envoyez les données de requête au serveur distant. Par conséquent, l’installation de serveurs aléatoires à partir d’Internet doit être effectuée avec la même prudence que n’importe quelle CLI tierce.

Conservez les clés et les jetons dans les variables d’environnement et ne vous engagez pas dans le référentiel. OpenCode stocke les jetons OAuth localement, mais sur une machine partagée, cela vaut également la peine d’être pris en compte : la déconnexion opencode mcp les supprime lorsque l’accès n’est plus nécessaire.

Et encore une chose : n’allumez pas tout en même temps. MCP ajoute des outils au contexte, et le contexte est synonyme d’argent et de qualité de réponse. Deux ou trois serveurs vraiment nécessaires fonctionnent bien mieux que dix connectés au cas où.

Liens

https://opencode.ai/docs/mcp-servers/
https://opencode.ai/docs/config/
https://modelcontextprotocol.io/
https://github.com/upstash/context7
https://mcp.sentry.dev
https://mcp.grep.app
https://github.com/anomalyco/opencode

Sources

https://opencode.ai/docs/mcp-servers/
https://modelcontextprotocol.io/
https://api-docs.deepseek.com/
https://api-docs.deepseek.com/quick_start/agent_integrations/opencode