MCP et proxies mobiles : comment connecter un proxy aux outils IA étape par étape

Introduction

Dans ce guide pratique, vous apprendrez à connecter un proxy mobile au client MCP étape par étape, afin de garantir que vos outils IA fonctionnent de manière stable et prévisible avec des sources de données externes et des API. Nous commencerons par une brève explication des raisons d'utiliser des proxies mobiles et du fonctionnement du MCP (Model Context Protocol), puis nous préparerons l'environnement, connecterons le proxy, examinerons un exemple réel basé sur le serveur MCP mobileproxy.space, effectuerons un diagnostic, discuterons des erreurs typiques et nous terminerons par des possibilités avancées. Au final, vous disposerez d'une configuration opérationnelle que vous pourrez transférer à votre équipe ou à un environnement de production.

Ce guide est destiné aux développeurs, analystes de données et ingénieurs en intégration qui souhaitent obtenir un comportement réseau reproductible des outils IA et réduire l'instabilité lors de l'accès à des sites et API externes. Même si vous découvrez MCP pour la première fois, vous pourrez suivre chaque étape. Les utilisateurs avancés trouveront des exemples de code prêts à l'emploi et des conseils d'optimisation.

Avant de commencer, il est utile de comprendre des notions de base : comment ouvrir un terminal, installer Node.js, modifier un fichier JSON de configuration et lire des logs. Des connaissances approfondies sur les réseaux ne sont pas nécessaires. Nous expliquerons tout ce qu'il faut savoir au fur et à mesure.

Temps d'exécution : 60 à 90 minutes, selon que vous avez déjà installé les outils et disposé des identifiants prêts pour le proxy mobile. Si vous configurez le client MCP pour la première fois, prévoyez 90 minutes pour suivre attentivement toutes les vérifications et diagnostics.

Conseil : Si vous implémentez cette configuration dans un environnement d'équipe, convenez d'un endroit unique pour stocker les configurations et secrets, afin de ne pas disperser les mots de passe du proxy dans les fichiers personnels des développeurs.

Vérification : À la fin de la section « Vérification des résultats », vous recevrez une liste de contrôle qui vous permettra de vous assurer que le proxy est effectivement utilisé et que les outils accèdent avec succès à Internet via le réseau mobile.

Préparation

Pour une configuration correcte et rapide, rassemblez tous les outils et accès à l'avance. Cela vous fera gagner du temps et aidera à éviter des erreurs en milieu de processus.

Outils, programmes et accès nécessaires

• Système d'exploitation : Windows 10/11, macOS 12+ ou Linux avec droits d'installation de logiciels.
• Node.js LTS 20+ (avec npm) pour exécuter des serveurs MCP en JavaScript/TypeScript.
• Éditeur de code : VS Code, JetBrains ou tout autre de votre choix.
• Identifiants de proxy mobile : hôte, port, login, mot de passe. Idéalement, aussi URL de rotation IP et paramètres pour les sessions « collantes ».
• Client MCP : par exemple, Claude Desktop ou Cline (extension VS Code), prenant en charge la connexion aux serveurs MCP externes.
• Outils de diagnostic réseau de base : curl ou équivalents pour vérifier l'accès à Internet via le proxy.

Exigences système

• Internet stable sur votre machine de travail.
• Accès sortant ouvert aux ports du proxy mobile (généralement 3128, 8000, 8080 ou autre, comme spécifié par le fournisseur).
• Espace disque : minimum 200 Mo pour les paquets Node.js et les logs.

Ce qu'il faut télécharger, installer et configurer

1. Installez Node.js LTS 20+ à partir du distributeur officiel pour votre OS.
2. Préparez un dossier de projet, par exemple mcp-mobileproxy, où seront stockés le code et les configurations.
3. Vérifiez que votre client MCP est installé : lancez Claude Desktop ou ouvrez VS Code avec Cline installé.
4. Préparez les identifiants de proxy mobile (hôte, port, utilisateur, mot de passe), ainsi que l’URL ou la commande de rotation IP et les paramètres pour les sessions « collantes », si prévus par votre offre.

Création de sauvegardes

Si vous modifiez la configuration du client MCP (par exemple, le fichier JSON), effectuez une sauvegarde du fichier original avant d'apporter des modifications. Copiez-le en ajoutant le suffixe .bak. Si quelque chose ne va pas, vous pourrez facilement revenir aux réglages d’origine.

Attention : Ne stockez jamais vos mots de passe de proxy dans des dépôts publics. Pour le travail d’équipe, utilisez des gestionnaires de secrets ou des variables d'environnement pour éviter les fuites d'identifiants.

Vérification : Assurez-vous que Node.js est installé (la commande node -v affiche la version) et que vous savez où se trouve le fichier de configuration de votre client MCP. Vos identifiants de proxy mobile doivent être à portée de main, et l'accès à Internet doit être stable.

Qu'est-ce que le MCP (Model Context Protocol)

Le MCP est un protocole ouvert qui standardise l'interaction entre les clients IA (par exemple, les applications de bureau et les plugins IDE) et les capacités externes fournies par les serveurs MCP. L'idée est simple : le client affiche dans l'interface des « outils » et des « ressources », tandis que le serveur en met en œuvre la logique. Grâce à cela, un même serveur peut être connecté à différents clients, et les outils auront une apparence et un fonctionnement identiques.

Concepts clés en termes simples

• Client MCP : l'application où vous interagissez avec le modèle et choisissez quels outils lui sont accessibles. Exemples : Claude Desktop, Cline.
• Serveur MCP : programme tiers mettant en œuvre les "outils" (tools), "ressources" (resources), "propositions" (prompts). Le serveur fournit des descriptions des capacités et traite les appels du client.
• Outils : actions que le modèle peut effectuer : requête API web, lecture de fichier, parsing HTML, requête HTTP via proxy, etc.
• Transport : moyen de communication entre le client et le serveur (généralement, stdio ou connexion web). Pour vous, cela est transparent : vous spécifiez la commande de démarrage du serveur et les paramètres.

Principes de fonctionnement

Le client établit une session avec le serveur MCP et reçoit une description déclarative des capacités : quels outils sont disponibles, quels paramètres ils acceptent, ce qu'ils retournent. Lorsque vous demandez à la modèle d'exécuter une action, le client appelle l'outil correspondant sur le serveur. Le serveur effectue tout le « travail sale » — accède à Internet, interroge des bases de données, parse des fichiers — et renvoie le résultat au client. Dans ce scénario, il est important que les sorties réseau du serveur passent par le proxy mobile et non directement. Ainsi, toutes les requêtes des outils IA seront routées de manière prévisible : adresses IP stables, rotations, sessions « collantes », régionalité, etc.

Ce qu'il est important de comprendre avant de commencer

• Où vous allez activer le proxy : globalement via des variables d'environnement ou localement dans le code du serveur MCP. Les deux options sont valides, mais chacune a ses avantages.
• Comment vous allez confirmer qu'une requête passe bien par le proxy : par exemple, en vérifiant votre IP externe, en consultant les logs du fournisseur de proxy ou en inspectant les en-têtes.
• Quelle stratégie de rotation IP vous convient : bouton de rotation manuel, automatique après N requêtes ou sessions « collantes » pendant la durée de la tâche.

Conseil : Réfléchissez en détail à votre stratégie de rotation avant de commencer. Des rotations fréquentes ne sont pas toujours utiles : de nombreux sites préfèrent une session « collante » stable dans le cadre d'une tâche de collecte de données ou de test d'API.

Vérification : Vous comprenez que le MCP est un « pont » entre le client et les outils externes, tandis que le proxy mobile est un itinéraire contrôlé pour les appels réseau de ces outils. L'objectif est que tous les échanges réseau passent par le fournisseur de proxy spécifié.

Pourquoi les outils IA ont besoin de proxies mobiles

Les proxies mobiles offrent des avantages importants lors de l'utilisation des outils IA avec des ressources externes et des API :

• Stabilité d'accès : certains services sont sensibles au type d'IP et à l'activité qui en provient. Les IP mobiles ont souvent une heuristique de filtrage différente, ce qui augmente la prévisibilité.
• Rotation flexible : vous pouvez faire tourner les IP sur commande, selon le temps ou le nombre de requêtes, évitant ainsi l'accumulation de « bruit » et de blocages inutiles sur une même adresse.
• Sessions : les sessions « collantes » permettent de garder la même IP pendant l'exécution de la tâche (par exemple, 10 à 30 minutes), afin de ne pas compromettre l'interaction continue.
• Régionalité : le choix de la géographie de connexion, si disponible dans votre offre, aide à tester le comportement des services pour différents pays.

Dans le contexte du MCP, cela signifie que tout outil mis en œuvre du côté serveur utilisera précisément le chemin réseau que vous avez défini, assurant la reproductibilité et réduisant le désordre lors du débogage.

Attention : Utilisez les proxies mobiles strictement dans le cadre de la législation et des règles des services cibles. La configuration du proxy dans ce guide vise à garantir la stabilité et la reproductibilité du fonctionnement des outils IA, et non à contourner des restrictions.

Conseil : Si votre cas d'utilisation est l'intégration d'un agent avec plusieurs sources, séparez-les par sessions : certains outils sur des sessions « collantes », d'autres sur des IP à rotation rapide. Cela réduit les chevauchements et les artefacts.

Vérification : Formulez votre scénario : pourquoi avez-vous besoin d'un proxy mobile (stabilité, sessions, régionalité), comment mesurerez-vous le succès (moins d'erreurs de connexion, IP stable dans les logs, absence de blocages inattendus).

Étape 1 : Planifiez votre stratégie et obtenez l'accès au proxy mobile

Objectif de l'étape

Définir les paramètres d'utilisation du proxy mobile (type de sessions, rotations, régionalité) et obtenir des identifiants opérationnels pour l'intégration ultérieure avec le client MCP et le serveur.

Instructions étape par étape

1. Déterminez si vous aurez une session « collante ». Si l'agent doit garder le contexte tout au long de la tâche, choisissez le mode « sticky » pour 10 à 30 minutes.
2. Choisissez une stratégie de rotation : manuelle via bouton/URL, suivant un calendrier ou selon le nombre de requêtes. Pour commencer, une rotation manuelle conviendra.
3. Obtenez auprès du fournisseur les paramètres de connexion : hôte, port, utilisateur, mot de passe. Si nécessaire, l’URL de rotation IP et le modèle de connexion pour la session « collante ».
4. Vérifiez si des listes d'IP autorisées sont nécessaires. Si le fournisseur exige que votre IP sortante soit liée, ajoutez-la à l'avance à votre compte client.
5. Effectuez un test curl. Commande : curl -x http://user:password@host:port https://api.ipify.org. Votre IP externe doit être renvoyée via le proxy.
6. Sauvegardez les identifiants dans des variables d'environnement : par exemple, PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS. C'est plus sûr que de les stocker directement dans le code.

Attention : Ne transmettez jamais les données du proxy par des canaux non sécurisés. Lorsque vous les communiquez à des collègues, utilisez des moyens d'échange chiffrés et appliquez la rotation des mots de passe selon les règles.

Conseil : Si le fournisseur prend en charge la génération d'un login distinct avec des limitations (durée de vie, géographie), créez des identifiants séparés pour le développement, les tests et la production. Ainsi, vous éviterez de surcharger accidentellement l'offre de votre abonnement.

Résultat attendu

Vous disposez d'un hôte, d'un port, d'un login et d'un mot de passe pour le proxy mobile, éventuellement d'une URL de rotation et d'instructions sur la session « collante ». Le test curl confirme que le trafic passe bien par le proxy.

Problèmes possibles et solutions

• Erreur 407 Proxy Authentication Required → Identifiants de connexion incorrects. Vérifiez vos identifiants. Assurez-vous que les caractères spéciaux sont correctement encodés si vous les utilisez dans l'URL.
• Timeout → Le port est bloqué par un pare-feu. Autorisez les connexions sortantes sur le port du fournisseur ou vérifiez un port alternatif.
• L'IP externe ne change pas → Le trafic ne passe pas par le proxy. Vérifiez la syntaxe de la clé -x et la nécessité d'une autorisation.

Vérification : La commande curl retourne une IP externe différente de votre IP habituelle, correspondant à celle affichée dans le tableau de bord du fournisseur de proxy.

Étape 2 : Installer le client MCP et préparer l'environnement

Objectif de l'étape

Préparer l'infrastructure : installer ou vérifier le client MCP (par exemple, Claude Desktop), créer le projet du serveur MCP et configurer les dépendances pour fonctionner via le proxy.

Instructions étape par étape

1. Vérifiez la présence de Node.js : dans le terminal, exécutez node -v. Si la version est inférieure à 20, installez la version LTS actuelle.
2. Créez un dossier de projet : mkdir mcp-mobileproxy && cd mcp-mobileproxy.
3. Initialisez le projet : npm init -y. Cela créera package.json.
4. Installez les dépendances MCP : npm install @modelcontextprotocol/sdk axios https-proxy-agent.
5. Créez le fichier index.js, où vous placerez le code du serveur MCP d'exemple.
6. Ouvrez le client MCP. Pour Claude Desktop, trouvez le fichier de configuration des paramètres. Sous Windows, il est généralement stocké dans le profil utilisateur dans le dossier des données d’application, sous macOS, dans le dossier Library/Application Support. Faites une sauvegarde du fichier de configuration avant modifications.
7. Si vous utilisez Cline (VS Code), ouvrez les paramètres de l'extension et trouvez la section pour ajouter des serveurs MCP personnalisés (généralement, un item de configuration « mcp servers »). Nous préparons l'ajout du script serveur à partir de votre projet.

Conseil : Conservez le chemin vers le projet du serveur MCP sans espaces et caractères spéciaux inutilisés. Cela facilitera la configuration et réduira le risque d'erreurs de guillemets.

Résultat attendu

Le dossier du projet du serveur MCP est prêt avec les dépendances installées. Vous savez où et comment ajouter un nouveau serveur dans votre client MCP et où se trouve le fichier de configuration du client.

Problèmes possibles et solutions

• npm introuvable → Node.js installé sans npm ou non ajouté au PATH. Réinstallez Node.js en incluant npm et redémarrez le terminal.
• Aucun accès au dossier → Exécutez le terminal en tant qu'utilisateur disposant des droits d'écriture ou utilisez un dossier dans votre profil.
• Fichier de configuration du client introuvable → Consultez l'aide de votre client MCP ou la documentation locale sur la page mcp.html pour vérifier le chemin.

Vérification : Exécutez npm list dans le dossier du projet et vérifiez que les paquets @modelcontextprotocol/sdk, axios et https-proxy-agent sont installés. Le fichier de configuration du client MCP a été trouvé et une sauvegarde de son état initial a été sauvegardée.

Connecter le proxy mobile au client MCP

Objectif de l'étape

Faire en sorte que tous les appels réseau des outils exécutés par le serveur MCP passent par le proxy mobile. Nous allons examiner deux approches : les variables d'environnement globales et le proxy au niveau du code.

Instructions étape par étape (via les variables d'environnement du client)

1. Ouvrez la configuration du client MCP et trouvez la section pour ajouter des serveurs personnalisés (par exemple, mcpServers).
2. Ajoutez un nouveau serveur en spécifiant la commande de démarrage de Node.js et le chemin vers votre index.js. Exemple de structure : nom du serveur, champ command : node, args : ["chemin/vers/index.js"].
3. Dans la section env, spécifiez les variables : HTTP_PROXY et HTTPS_PROXY avec la valeur http://user:password@host:port. Si vous utilisez un proxy non authentifié par IP, indiquez simplement host:port.
4. Si nécessaire, ajoutez NO_PROXY pour les adresses internes qui ne doivent pas passer par le proxy (par exemple, localhost, 127.0.0.1).
5. Ajoutez des variables pour la rotation, si vous souhaitez l'appeler depuis le serveur : par exemple, MOBILEPROXY_ROTATE_URL et MOBILEPROXY_API_KEY, si le fournisseur exige un clé.
6. Sauvegardez la configuration et redémarrez le client MCP afin qu'il relise la nouvelle entrée et démarre votre serveur avec les variables d'environnement appropriées.

Instructions étape par étape (via le proxy au niveau du code)

1. Ouvrez index.js et intégrez https-proxy-agent ou la configuration axios-proxy.
2. Créez un agent avec les données de process.env : hôte, port, utilisateur, mot de passe.
3. Transmettez l'agent dans chaque requête HTTP au sein des outils du serveur MCP.
4. Pour plus de flexibilité, ajoutez une option de sélection : si les variables d'environnement ne sont pas définies, utilisez une connexion directe ; si elles sont définies, utilisez le proxy.

Conseil : Commencez avec les variables d'environnement au niveau du client : c'est plus rapide et plus simple pour le premier démarrage. Ensuite, au besoin, ajoutez un contrôle précis dans le code.

Résultat attendu

Le client MCP démarre votre serveur avec les variables d'environnement équipées, et tous les appels HTTP sortants des outils du serveur sont effectués via le proxy mobile.

Problèmes possibles et solutions

• Le serveur ne démarre pas → Chemin incorrect vers le script dans args ou pas de droits d'exécution. Vérifiez le chemin, utilisez des chemins absolus si nécessaire.
• Le proxy est ignoré → Le client n'a pas transmis env au serveur. Assurez-vous que vous spécifiez env dans la configuration du serveur MCP spécifique et non globalement ou dans une autre section.
• L'authentification au proxy échoue → Vérifiez que votre login/mot de passe ne contient pas de caractères @ et : sans URL-encoding. Si nécessaire, spécifiez-les séparément (PROXY_USER, PROXY_PASS) et assemblez l'URI dans le code.

Vérification : Lancez un outil qui effectue une requête HTTP et comparez votre IP externe avant et après l'activation du proxy. Elle doit correspondre à celle de votre proxy mobile.

Exemple sur la base du serveur MCP mobileproxy.space

Objectif de l'étape

Assembler un serveur MCP minimal qui : 1) peut obtenir l'IP externe via un proxy mobile, 2) peut provoquer une rotation d'IP, 3) exécute une requête HTTP arbitraire via un proxy mobile. Nous utilisons le paquet @modelcontextprotocol/sdk et axios, et le fournisseur est le serveur MCP mobileproxy.space comme exemple d'intégration avec le fournisseur de proxies mobiles.

Code du serveur MCP (index.js)

Ci-dessous un exemple en JavaScript. Il enregistre trois outils : get_external_ip, rotate_ip et fetch_url. Les outils utilisent le proxy, les paramètres sont pris dans les variables d'environnement. Pour l'URL externe IP, utilisons le point de terminaison standard ipify, et la rotation via MOBILEPROXY_ROTATE_URL.

Exemple de code :

Sauvegardez sous index.js

const { Server } = require('@modelcontextprotocol/sdk'); const axios = require('axios'); const { HttpsProxyAgent } = require('https-proxy-agent'); function buildProxyAgent() { const host = process.env.PROXY_HOST; const port = process.env.PROXY_PORT; const user = process.env.PROXY_USER; const pass = process.env.PROXY_PASS; if (!host || !port) return null; let auth = ''; if (user && pass) {auth = encodeURIComponent(user) + ':' + encodeURIComponent(pass) + '@'; } const proxyUrl = 'http://' + auth + host + ':' + port; return new HttpsProxyAgent(proxyUrl); } async function axiosViaProxy(url, opts = {}) { const agent = buildProxyAgent(); const cfg = { url, method: opts.method || 'GET', headers: opts.headers || {}, data: opts.data, timeout: 20000 }; if (agent) {cfg.httpsAgent = agent;cfg.httpAgent = agent;cfg.proxy = false; } return axios(cfg); } const server = new Server({ name: 'mcp-mobileproxy-space', version: '1.0.0' }); server.tool('get_external_ip', { description: 'Renvoie l’IP externe via le proxy mobile', inputSchema: { type: 'object', properties: {}, additionalProperties: false } }, async () => { const res = await axiosViaProxy('https://api.ipify.org?format=json'); return { content: [{ type: 'text', text: JSON.stringify(res.data) }] }; }); server.tool('rotate_ip', { description: 'Provoque la rotation d’IP auprès du fournisseur de proxy mobile', inputSchema: { type: 'object', properties: {}, additionalProperties: false } }, async () => { const rotateUrl = process.env.MOBILEPROXY_ROTATE_URL; if (!rotateUrl) {return { content: [{ type: 'text', text: 'MOBILEPROXY_ROTATE_URL n’est pas défini' }] }; } const res = await axiosViaProxy(rotateUrl); return { content: [{ type: 'text', text: 'Rotation demandée : ' + res.status }] }; }); server.tool('fetch_url', { description: 'Requête HTTP via le proxy mobile', inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', enum: ['GET','POST','PUT','DELETE'], default: 'GET' }, headers: { type: 'object', additionalProperties: { type: 'string' } }, body: { type: 'string' } }, required: ['url'], additionalProperties: false } }, async (input) => { const cfg = { method: input.method || 'GET', headers: input.headers || {}, data: input.body }; const res = await axiosViaProxy(input.url, cfg); const out = { status: res.status, headers: res.headers, snippet: typeof res.data === 'string' ? res.data.slice(0, 500) : JSON.stringify(res.data).slice(0, 500) }; return { content: [{ type: 'text', text: JSON.stringify(out) }] }; }); server.start();

Configuration des variables d'environnement

1. Dans la configuration du client MCP, à côté de l'entrée de votre serveur, ajoutez env : PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS.
2. Ajoutez MOBILEPROXY_ROTATE_URL fourni par le fournisseur mobile. Par exemple, il peut s'agir d'une URL sécurisée qui, lors d'une requête GET, initie un changement d'IP.
3. Redémarrez le client MCP pour appliquer les variables.

Conseil : Si votre fournisseur mobileproxy.space prend en charge les sessions « collantes » via la modification du nom d'utilisateur ou des paramètres de requête, créez des variables distinctes, comme PROXY_SESSION ou PROXY_ZONE, et formez dynamiquement PROXY_USER sur cette base.

Vérification du fonctionnement des outils

1. Dans l'interface du client MCP, trouvez la liste des outils du serveur mcp-mobileproxy-space : get_external_ip, rotate_ip, fetch_url.
2. Appelez get_external_ip et assurez-vous qu'un JSON contenant votre IP externe via le proxy est renvoyé.
3. Appelez rotate_ip et attendez une confirmation de statut 200 ou un autre code de réussite, selon la réponse du fournisseur.
4. Appelez fetch_url avec le paramètre url : https://example.org et vérifiez qu'une portion de HTML est dans la réponse avec le code 200.

Vérification : Après avoir appelé get_external_ip, l'IP externe que vous voyez dans la réponse correspond à celle affichée dans votre tableau de bord mobileproxy.space. Après rotate_ip, l'IP change pour une nouvelle (selon les règles de votre offre et de votre fournisseur).

Problèmes possibles et solutions

• Les outils ne s'affichent pas → Le serveur n’a pas démarré. Vérifiez les logs du client et le chemin vers index.js. Démarrez le serveur séparément : node index.js, pour voir d'éventuelles erreurs.
• rotate_ip retourne une erreur → Vérifiez la valeur de MOBILEPROXY_ROTATE_URL et l'accès depuis votre réseau. Assurez-vous que l'URL est correcte et qu'une authentification n'est pas nécessaire séparément.
• fetch_url retourne des en-têtes inattendus → Certains sites dépendent de User-Agent et Accept-Language. Transmettez-les dans les en-têtes pour imiter un navigateur classique.

Conseil : Pour assurer la stabilité des requêtes, incluez dans les en-têtes User-Agent, Accept, Accept-Language. Cela est particulièrement utile lors du parsing HTML et de l'interaction avec des API qui attendent un client avec une signature spécifique.

Étape 4 : Ajustements pour le client et le serveur

Objectif de l'étape

Déboguer et stabiliser la configuration : journalisation, délais d'expiration, sessions « collantes », redémarrage du serveur en cas de défaillances, restriction de la fréquence des requêtes et bonne stratégie de rotation.

Instructions détaillées étape par étape

1. Ajoutez une journalisation avancée. Dans index.js, enveloppez les appels axiosViaProxy dans un try/catch, journalisez les codes de réponse, les délais et les erreurs avec des tampons horaires.
2. Configurez les délais d'expiration. Pour les ressources non stables, réduisez les délais d'attente et activez la répétition de la requête avec un délai exponentiel (backoff) si nécessaire.
3. Activez les sessions « collantes » pour les tâches nécessitant une séquence : stockez session_id dans les env ou dans l'état du serveur et formez dynamiquement PROXY_USER.
4. Limitez la fréquence d'appels à fetch_url : ajoutez un compteur de requêtes et un intervalle d'attente entre les requêtes à un seul domaine. Cela réduira le risque de blocages temporaires sur les ressources cibles.
5. Configurez le redémarrage du serveur. S'il échoue en raison d'erreurs réseau, utilisez un gestionnaire de processus (par exemple, node avec l'option - ou d'autres outils applicables dans votre environnement) afin que le serveur redémarre automatiquement.
6. Réfléchissez à votre régime de rotation IP dans le code : par exemple, après N requêtes réussies ou toutes les M minutes, si cela est permis par les conditions du fournisseur.

Conseil : Ajoutez une commande-outil server_status qui renvoie votre état actuel : active session_id, compteur de requêtes, temps avant la prochaine rotation. Cela facilitera la maintenance et la surveillance.

Résultat attendu

Votre serveur MCP est résistant aux pannes aléatoires, utilise correctement les sessions « collantes » et la rotation, journalise les événements importants, et la fréquence des requêtes peut être régulée sans besoin de modifier le code du client.

Problèmes possibles et solutions

• Logs excessifs → Introduisez des niveaux de journalisation (info, avertir, erreur) et changez-les via la variable d'environnement LOG_LEVEL.
• Traitement lent → Vérifiez si vous avez activé des délais d'attente trop agressifs ou si la rotation IP est appelée trop fréquemment.
• Interruptions de connexion aléatoires → Activez keep-alive sur les agents et réduisez le nombre de connexions simultanées à un même hôte.

Vérification : Les logs montrent que les requêtes s'exécutent de manière stable et, en cas de rotation, la nouvelle IP est rapidement confirmée par l'appel get_external_ip. Les erreurs sont traitées sans faire tomber le serveur.

Étape 5 : Diagnostic et journalisation

Objectif de l'étape

Apprendre à identifier et à résoudre rapidement les problèmes réseau : authentification au proxy, délais d'attente, en-têtes incorrects, erreurs de routage et conflits de variables d'environnement.

Instructions étape par étape

1. Vérifiez les variables d'environnement avant de lancer : affichez process.env.PROXY_HOST et d'autres variables clés dans le log au démarrage du serveur (sans les mots de passe).
2. Effectuez une requête de test séparée dans le code (par exemple, vers ipify) et affichez l'objet de réponse complet : code, en-têtes, premiers octets du corps.
3. Enregistrez des métriques minimales : temps DNS, temps d'établissement TLS, temps de réponse total. Cela aide à comprendre où se situe le « goulet d'étranglement ».
4. Vérifiez les en-têtes que vous envoyez : User-Agent, Accept, Content-Type. Assurez-vous qu'ils répondent aux attentes de l'API ou du site cible.
5. Effectuez un test avec curl pour comparaison. Si curl fonctionne de manière stable via le même proxy alors que le serveur ne le fait pas, cherchez un problème dans le code (agent, délai d'attente, proxy=false pour axios).

Conseil : Conservez des logs d'authentification masqués : remplacez une partie du login et du mot de passe par des astérisques lors de la sortie des logs. Cela facilite l'analyse des incidents sans risque de fuite de secrets.

Résultat attendu

Vous êtes capable de localiser rapidement le problème : distinguer les délais d'attente réseau des erreurs d'authentification ou de mauvais en-têtes, voir où et pourquoi les requêtes ralentissent ou sont rejetées.

Problèmes possibles et solutions

• HTTP 403 ou 429 → Requêtes trop fréquentes ou signature client suspecte. Réduisez la fréquence, ajustez les en-têtes, utilisez des sessions « collantes » selon la tâche.
• Erreurs de connexion sporadiques → Augmentez les délais d'attente et activez les répétitions de requêtes avec une augmentation progressive du délai. Vérifiez la stabilité du réseau mobile chez le fournisseur.
• Données incohérentes → Comparez les réponses via et sans proxy sur un banc d'essai. Vérifiez l'encodage et transmettez les en-têtes Accept-Charset nécessaires.

Vérification : À l'issue des tests, vous disposez d'une carte des problèmes : vous savez combien prend chaque étape de la requête, et vous pouvez optimiser la configuration de manière ciblée.

Vérification des résultats

Liste de contrôle

• Les outils du serveur MCP s'affichent dans le client.
• La demande get_external_ip retourne l'IP du proxy mobile.
• La rotation d'IP s'effectue et est confirmée par un changement d'IP.
• Une requête fetch_url aboutit avec succès à plusieurs domaines.
• Les logs sont clairs : les codes de réponse, les délais et les messages diagnostiques minimaux sont visibles.

Comment tester

1. Exécutez trois requêtes successives get_external_ip et notez l’IP. Puis, appelez rotate_ip et répétez get_external_ip. Assurez-vous que l’IP a changé selon les règles de votre offre.
2. Exécutez fetch_url vers deux domaines différents. Comparez les codes et les en-têtes. Assurez-vous qu'il n'y a pas d'erreurs systématiques.
3. Utilisez une session « collante » (si elle est prévue) et vérifiez que l’IP reste la même durant la durée de la session.

Indicateurs de réussite

• Taux stable de requêtes réussies (200 OK) vers vos ressources cibles.
• Rotation prévisible et absence de « sauts » inattendus d'IP lors d'une session « collante ».
• Faible nombre de délais d'attente avec des délais et répétitions appropriés.

Conseil : Mettez en place un test automatique de « point de contrôle » dans votre CI : exécutez get_external_ip et un fetch_url avant le déploiement. Cela permettra de détecter à l'avance les défaillances du fournisseur ou des configurations.

Erreurs fréquentes

Problème → Cause → Solution

• Le proxy ne s'applique pas → Les variables d'environnement ne sont pas transmises au processus du serveur → Spécifiez env au niveau de l’entrée de serveur MCP dans la configuration du client et redémarrez le client.
• Échec de l'authentification au proxy → Les caractères spéciaux dans le login/mot de passe perturbent l’URI → Spécifiez login/mot de passe comme variables distinctes et assemblez proxyUrl avec encodeURIComponent.
• HTTP 429 Too Many Requests → Rotation trop fréquente ou RPS élevé → Réduisez la fréquence des requêtes, utilisez une queue, appliquez des sessions « collantes » pour les opérations consécutives.
• Erreurs sporadiques 5xx sur le service cible → Les répétitions agressives aggravent l’instabilité des ressources → Introduisez du jitter dans le backoff et réduisez le nombre de répétitions.
• Aucun outil sur le tableau de bord → Le serveur MCP a échoué au démarrage → Exécutez le serveur dans le terminal, lisez la pile d'erreurs, corrigez les erreurs de syntaxe, puis connectez-le à nouveau.
• L'IP ne change pas après la rotation → La rotation n’a pas été complétée ou le chemin a été mis en cache → Attendez l'intervalle spécifié par le fournisseur ou demandez une confirmation du statut de rotation via leur API.
• Conflits avec des services locaux → Le proxy est appliqué à tout, y compris localhost → Utilisez NO_PROXY=localhost,127.0.0.1 pour que les appels locaux soient directs.

Vérification : Répétez le scénario problématique après avoir apporté des modifications. Assurez-vous que le symptôme a disparu : le proxy s'applique, l'authentification réussit, les codes de réponse sont attendus.

Fonctionnalités avancées

Configurations avancées

• Sécrets et clés : externalisez tous les mots de passe et clés dans des variables d'environnement ou des gestionnaires de secrets. Ne les intégrez pas dans le code.
• Géotargeting : si mobileproxy.space offre un choix de pays/régions, créez un outil set_region et changez la géographie sans redémarrer le serveur.
• Pool de proxies : pour des charges importantes, utilisez un pool de plusieurs points mobiles et une règle de répartition (round-robin, par domaine, par tâche).
• Contrôle de fréquence : ajoutez un limiteur global de fréquence sur le serveur afin de ne pas dépendre de la discipline des agents.

Optimisation

• Mise en cache : pour des ressources immuables, mettez en cache les réponses pendant une courte durée. Cela réduira le trafic et accélérera les réponses.
• Parallélisme : limitez les requêtes simultanées vers un même hôte, mais autorisez le parallélisme entre hôtes pour ne pas créer de goulets d’étranglement.
• Profilage : collectez des métriques par domaine et type de requêtes. Cela vous aidera à comprendre où l'optimisation aura le meilleur effet.

Que faire d'autre

• Ajouter un outil de vérification de la disponibilité des ressources cibles (healthcheck_url) avec rapport.
• Intégrer l'exportation des logs vers un stockage centralisé, par exemple, le journal des événements de votre infrastructure.
• Préparer des instructions pour l'équipe et les publier sur la page interne mcp.html avec des modèles de configuration.
• Étudier un document détaillé sur le choix et la configuration des proxies pour les agents sur la page interne document sur les proxies pour les agents IA.

Conseil : Formalisez les « profils de connexion » — dev, stage, prod — avec différentes limites et niveaux de journalisation. Cela simplifiera la maintenance et l'audit.

FAQ

1. Quelle est la durée de vie d'une session « collante » d'un proxy mobile ?

Cela dépend de l'offre du fournisseur. En général, les fournisseurs proposent des intervalles de 10 à 30 minutes. Vérifiez dans votre compte mobileproxy.space et configurez l'intervalle dans votre serveur MCP.

2. Comment savoir si la requête passe bien par le proxy mobile ?

Comparez l'IP externe avant et après l'activation du proxy via get_external_ip. Par ailleurs, tenez des logs côté serveur, et si possible, vérifiez avec les données du tableau de bord du fournisseur.

3. Peut-on attribuer différents proxies à différents outils ?

Oui. Au niveau du code, créez plusieurs agents proxy et sélectionnez-les selon le nom de l'outil ou le domaine. Au niveau du client, levez plusieurs serveurs avec différents env.

4. Que faire si le site cible exige des en-têtes spécifiques ?

Transmettez les en-têtes nécessaires via le paramètre headers de l'outil fetch_url. User-Agent, Accept, Accept-Language, Referer aident souvent.

5. Comment éviter les fuites de secrets dans les logs ?

Masquez les chaînes sensibles et ne journalisez pas les URL complètes avec des mots de passe. Conservez les secrets uniquement dans des variables d'environnement et appliquez la rotation des mots de passe.

6. Peut-on utiliser le proxy uniquement pour certains domaines ?

Oui. Au niveau du code, appliquez conditionnellement l’agent proxy uniquement aux domaines nécessaires. Envoyez les autres requêtes directement. Ou créez deux outils : fetch_proxy et fetch_direct.

7. Que faire si la rotation ne change pas l'IP ?

Attendez l'intervalle spécifié par le fournisseur, et vérifiez le statut de rotation. Assurez-vous que vous n'êtes pas en session « collante », si vous attendez un changement immédiat d'IP.

8. Comment adapter pour une haute charge ?

Utilisez un pool de points mobiles, limitez le parallélisme par domaine, ajoutez une queue de requêtes et un backoff intelligent. Pour le travail d'agent, répartissez les tâches selon les profils.

9. Où conserver la documentation de l'équipe ?

La page interne mcp.html convient pour héberger les instructions, modèles de configurations et règles de rotation. Mettez-la à jour au fur et à mesure de l'évolution.

10. Peut-on connecter mobileproxy.space comme serveur MCP prêt à l'emploi ?

Oui, si vous disposez d'un serveur ou d'un adaptateur approprié fournissant des outils de rotation et de requêtes via leur infrastructure. L'exemple ci-dessus montre comment rassembler un tel serveur de manière autonome basé sur le SDK.

Conseil : Établissez un « passeport » interne du serveur : nom, version, liste des outils, contact responsable. Cela accélère le support et facilite la formation des nouvelles recrues.

Conclusion

Vous avez passé en revue toutes les étapes : compris ce qu'est le MCP et pourquoi les proxies mobiles sont importants pour le fonctionnement stable des outils IA ; préparé l'environnement ; connecté un proxy mobile au client MCP ; mis en œuvre un exemple opérationnel du serveur MCP avec des outils get_external_ip, rotate_ip et fetch_url basé sur mobileproxy.space ; réglé la configuration délicate, les logs et le diagnostic ; effectué des tests ; traité des erreurs fréquentes et exploré des possibilités avancées. Vous disposez désormais d’une architecture reproductible : le client MCP gère les outils, le serveur MCP exécute les actions réseau, et le proxy mobile assure un chemin réseau prévisible et ajustable.

Ensuite, vous pouvez : 1) Diviser le serveur en modules pour différentes tâches ; 2) Ajouter des profils d'environnement dev/stage/prod ; 3) Inclure un pool de proxies et un choix dynamique d'itinéraire ; 4) Documenter les détails sur la page interne mcp.html et renvoyer à un contenu étendu document sur les proxies pour agents IA.

Développez vers l'automatisation : connectez des métriques, des alertes sur la dégradation, des tests automatisés et une rotation IP gérée selon un calendrier ou une charge. Plus votre réseau est formalisé, plus il est facile de mettre à l'échelle vos agents et de maintenir la qualité des services.

Conseil : Révisez régulièrement les limites et les tarifs du fournisseur mobileproxy.space pour éviter d'atteindre des quotas pendant les périodes de pointe. Planifiez votre capacité et conservez une configuration de secours en cas d'indisponibilité d'un point.

À propos de l'auteur

Roman Melnikov

Technical Writer and System Administrator

Expérience professionnelle : Technical writer and DevOps engineer with 9 years of experience. Created over 50 detailed guides on system configuration and administration. His instructions helped thousands of professionals successfully solve technical tasks. Popular author on Habr and YouTube.

Formation : Bauman Moscow State Technical University. Information Systems and Technologies

Expertise :

Technical Documentation DevOps System Administration Linux Docker and Kubernetes CI/CD Infrastructure Automation Cloud Technologies System Monitoring Bash and Python Scripting