Qwen3.6 + MCPs : l'IA locale qui répare ton code à ta place

QU'EST-CE QUE LE PROTOCOLE MCPS ?

Le Model Context Protocol (ou MCPs) est un standard ouvert créé par Anthropic. En gros, c'est comme un USB universel pour l'IA : tu définis une fois un outil (un serveur MCPs), et n'importe quelle IA compatible peut l'utiliser sans avoir besoin de réécrire du code pour chaque modèle. Plus besoin de faire des intégrations personnalisées à chaque fois.

Concrètement, imagine que chaque outil de développement (lire un fichier, ouvrir un ticket GitHub, lancer un test) est une prise électrique. Le protocole MCPs, c'est le câble qui permet à ton IA de se brancher dessus, peu importe la marque de l'IA ou de l'outil. Résultat : tu peux utiliser la même IA pour lire un fichier, modifier du code, et créer une pull request sur GitHub, sans rien changer à ton code.

POURQUOI QWEN3.6 AVEC MCPS ?

Qwen3.6 est un modèle de langage spécialisé dans la programmation. Il peut non seulement comprendre du code, mais aussi l'exécuter via des outils connectés. Avec MCPs, tu crées une IA qui agit comme un développeur junior : elle lit les bugs, comprend le code, propose des corrections et les applique directement dans ton dépôt GitHub.

L'avantage ? Tout se passe en local, sur ta machine. Pas besoin de partager ton code avec un service cloud. Tu gardes le contrôle total sur tes données et ton infrastructure.

INSTALLER L'ENVIRONNEMENT DE DÉVELOPPEMENT

Pour commencer, il te faut Python 3.11 ou supérieur. Vérifie ta version avec :

python --version

Crée ensuite un environnement virtuel pour isoler les dépendances :

python -m venv qwen-mcp-env
source qwen-mcp-env/bin/activate    # macOS / Linux
qwen-mcp-env\Scripts\activate       # Windows

Installe les paquets nécessaires pour faire fonctionner l'IA et les outils MCPs :

pip install \
  "openai>=1.30.0" \
  "qwen-agent>=0.0.10" \
  "mcp>=1.0.0" \
  "httpx>=0.27.0"

Pour faire tourner le modèle, tu as besoin d'un serveur d'inférence. Trois options s'offrent à toi selon ton matériel :

• vLLM pour les cartes graphiques NVIDIA
• SGLang pour les GPU NVIDIA avec un préchargement plus rapide des longs contextes
• kTransformers pour les CPU ou les configurations hybrides

Installe au moins l'une de ces options. Par exemple, pour SGLang :

pip install "sglang[all]>=0.5.10"

Si tu utilises Node.js, vérifie aussi que tu as la version 18 ou supérieure, car certains serveurs MCPs préconstruits nécessitent Node.js pour fonctionner.

LANCER LE MODÈLE QWEN3.6 EN LOCAL

Avec SGLang, lance le modèle Qwen3.6-35B-A3B avec les options suivantes :

python -m sglang.launch_server \
    --model-path Qwen/Qwen3.6-35B-A3B \
    --host 0.0.0.0 \
    --port 30000 \
    --reasoning-parser qwen3 \
    --tool-call-parser qwen3_coder \
    --enable-prefix-caching \
    --tp 2    # parallélisation sur 2 GPU ; retire cette option si tu n'as qu'un GPU

Les options --reasoning-parser qwen3 et --tool-call-parser qwen3_coder permettent à l'IA de comprendre les blocs de raisonnement et les appels d'outils. L'option --enable-prefix-caching est cruciale : elle réutilise le cache des calculs entre les tours de conversation, ce qui rend l'IA plus efficace pour les tâches longues comme la correction de bugs.

Si tu préfères utiliser vLLM, la commande équivalente est :

vllm serve Qwen/Qwen3.6-35B-A3B \
    --host 0.0.0.0 \
    --port 8000 \
    --reasoning-parser qwen3 \
    --tool-call-parser qwen3_coder \
    --enable-prefix-caching-v2 \
    --tensor-parallel-size 2

Une autre option plus légère est d'utiliser Ollama pour faire tourner un modèle plus petit comme Qwen2.5-7B :

ollama pull qwen2.5:7b
ollama serve

L'API d'Ollama est compatible avec les standards OpenAI, ce qui facilite l'intégration.

VÉRIFIER QUE LE MODÈLE FONCTIONNE

Pour t'assurer que tout est bien configuré, fais un test de santé sur le serveur :

curl http://localhost:30000/health

Tu devrais obtenir une réponse comme {