Connecter Qwen Code à des outils via MCP

Qwen Code peut se connecter à des outils et des sources de données externes via le Model Context Protocol (MCP) . Les serveurs MCP donnent à Qwen Code accès à vos outils, bases de données et API.

Ce que vous pouvez faire avec MCP

Avec des serveurs MCP connectés, vous pouvez demander à Qwen Code de :

• Travailler avec des fichiers et des repos (lecture/recherche/écriture, selon les outils que vous activez)
• Interroger des bases de données (inspection du schéma, requêtes, rapports)
• Intégrer des services internes (exposer vos API sous forme d’outils MCP)
• Automatiser des workflows (tâches répétitives exposées sous forme d’outils/prompts)

Démarrage rapide

Qwen Code charge les serveurs MCP depuis mcpServers dans votre settings.json. Vous pouvez configurer les serveurs de deux manières :

• En modifiant directement settings.json
• En utilisant les commandes qwen mcp (voir Référence CLI)

Ajouter votre premier serveur

1. Ajoutez un serveur (exemple : serveur MCP HTTP distant) :

qwen mcp add --transport http my-server http://localhost:3000/mcp

2. Ouvrez la boîte de dialogue de gestion MCP pour afficher et gérer les serveurs :

qwen mcp

3. Redémarrez Qwen Code dans le même projet (ou lancez-le s’il n’était pas encore en cours d’exécution), puis demandez au modèle d’utiliser les outils de ce serveur.

Où la configuration est stockée (scopes)

La plupart des utilisateurs n’ont besoin que de ces deux scopes :

• Scope projet (par défaut) : .qwen/settings.json à la racine de votre projet
• Scope utilisateur : ~/.qwen/settings.json pour tous les projets sur votre machine

Écrire dans le scope utilisateur :

qwen mcp add --scope user --transport http my-server http://localhost:3000/mcp

Configurer les serveurs

Choisir un transport

Configurer via settings.json ou qwen mcp add

Les deux approches génèrent les mêmes entrées mcpServers dans votre settings.json : utilisez celle que vous préférez.

Serveur Stdio (processus local)

JSON (.qwen/settings.json) :

{
  "mcpServers": {
    "pythonTools": {
      "command": "python",
      "args": ["-m", "my_mcp_server", "--port", "8080"],
      "cwd": "./mcp-servers/python",
      "env": {
        "DATABASE_URL": "$DB_CONNECTION_STRING",
        "API_KEY": "${EXTERNAL_API_KEY}"
      },
      "timeout": 15000
    }
  }
}

CLI (écrit dans le scope projet par défaut) :

qwen mcp add pythonTools -e DATABASE_URL=$DB_CONNECTION_STRING -e API_KEY=$EXTERNAL_API_KEY \
  --timeout 15000 python -m my_mcp_server --port 8080

Serveur HTTP (HTTP streamable distant)

JSON :

{
  "mcpServers": {
    "httpServerWithAuth": {
      "httpUrl": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer your-api-token"
      },
      "timeout": 5000
    }
  }
}

CLI :

qwen mcp add --transport http httpServerWithAuth http://localhost:3000/mcp \
  --header "Authorization: Bearer your-api-token" --timeout 5000

Serveur SSE (Server-Sent Events distant)

JSON :

{
  "mcpServers": {
    "sseServer": {
      "url": "http://localhost:8080/sse",
      "timeout": 30000
    }
  }
}

CLI :

qwen mcp add --transport sse sseServer http://localhost:8080/sse --timeout 30000

Sécurité et contrôle

Confiance (ignorer les confirmations)

• Confiance serveur (trust: true) : ignore les invites de confirmation pour ce serveur (à utiliser avec parcimonie).

Authentification OAuth

Qwen Code prend en charge l’authentification OAuth 2.0 pour les serveurs MCP. Cela est utile lors de l’accès à des serveurs distants nécessitant une authentification.

Utilisation de base

Lorsque vous ajoutez un serveur MCP avec des identifiants OAuth, Qwen Code gère automatiquement le flux d’authentification :

qwen mcp add --transport sse oauth-server https://api.example.com/sse/ \
  --oauth-client-id your-client-id \
  --oauth-redirect-uri https://your-server.com/oauth/callback \
  --oauth-authorization-url https://provider.example.com/authorize \
  --oauth-token-url https://provider.example.com/token

Important : Configuration de l’URI de redirection

Le flux OAuth nécessite une URI de redirection vers laquelle le fournisseur d’autorisation envoie le code d’authentification.

• Développement local : Par défaut, Qwen Code utilise http://localhost:7777/oauth/callback. Cela fonctionne lorsque vous exécutez Qwen Code sur votre machine locale avec un navigateur local.

• Déploiements distants/cloud : Lorsque vous exécutez Qwen Code sur des serveurs distants, des IDE cloud ou des terminaux web, la redirection localhost par défaut ne fonctionnera PAS. Vous DEVEZ configurer --oauth-redirect-uri pour pointer vers une URL accessible publiquement capable de recevoir le callback OAuth.

Exemple pour les serveurs distants :

qwen mcp add --transport sse remote-server https://api.example.com/sse/ \
  --oauth-redirect-uri https://your-remote-server.example.com/oauth/callback

Configuration manuelle via settings.json

Vous pouvez également configurer OAuth en modifiant directement settings.json :

{
  "mcpServers": {
    "oauthServer": {
      "url": "https://api.example.com/sse/",
      "oauth": {
        "enabled": true,
        "clientId": "your-client-id",
        "clientSecret": "your-client-secret",
        "authorizationUrl": "https://provider.example.com/authorize",
        "tokenUrl": "https://provider.example.com/token",
        "redirectUri": "https://your-server.com/oauth/callback",
        "scopes": ["read", "write"]
      }
    }
  }
}

Propriétés de configuration OAuth :

Gestion des tokens

Les tokens OAuth sont automatiquement :

• Stockés de manière sécurisée dans ~/.qwen/mcp-oauth-tokens.json
• Actualisés à leur expiration (si des refresh tokens sont disponibles)
• Validés avant chaque tentative de connexion

Utilisez la commande /mcp auth dans Qwen Code pour gérer l’authentification OAuth de manière interactive.

Filtrage des outils (autoriser/refuser des outils par serveur)

Utilisez includeTools / excludeTools pour restreindre les outils exposés par un serveur (du point de vue de Qwen Code).

Exemple : inclure uniquement quelques outils :

{
  "mcpServers": {
    "filteredServer": {
      "command": "python",
      "args": ["-m", "my_mcp_server"],
      "includeTools": ["safe_tool", "file_reader", "data_processor"],
      "timeout": 30000
    }
  }
}

Listes d’autorisation/refus globales

L’objet mcp dans votre settings.json définit les règles globales pour tous les serveurs MCP :

• mcp.allowed : liste d’autorisation des noms de serveurs MCP (clés dans mcpServers)
• mcp.excluded : liste de refus des noms de serveurs MCP

Exemple :

{
  "mcp": {
    "allowed": ["my-trusted-server"],
    "excluded": ["experimental-server"]
  }
}

Dépannage

• Le serveur affiche “Disconnected” dans qwen mcp list : vérifiez que l’URL/commande est correcte, puis augmentez timeout.
• Le serveur Stdio ne parvient pas à démarrer : utilisez un chemin command absolu et vérifiez cwd/env.
• Les variables d’environnement dans le JSON ne sont pas résolues : assurez-vous qu’elles existent dans l’environnement où Qwen Code s’exécute (les environnements shell et les applications GUI peuvent différer).

Référence

Structure de settings.json

Configuration spécifique au serveur (mcpServers)

Ajoutez un objet mcpServers à votre fichier settings.json :

// ... file contains other config objects
{
  "mcpServers": {
    "serverName": {
      "command": "path/to/server",
      "args": ["--arg1", "value1"],
      "env": {
        "API_KEY": "$MY_API_TOKEN"
      },
      "cwd": "./server-directory",
      "timeout": 30000,
      "trust": false
    }
  }
}

Propriétés de configuration :

Obligatoire (l’un des suivants) :

Optionnel :

Gérer les serveurs MCP avec qwen mcp

Vous pouvez toujours configurer les serveurs MCP en modifiant manuellement settings.json, mais la CLI est généralement plus rapide.

Ajouter un serveur (qwen mcp add)

qwen mcp add [options] <name> <commandOrUrl> [args...]

Les indicateurs --oauth-* s’appliquent uniquement à --transport sse et --transport http. Leur combinaison avec --transport stdio est refusée.

Supprimer un serveur (qwen mcp remove)

qwen mcp remove <name>