Avoir son propre agent IA gratuitement grâce au MCP : mode d'emploi
Avec le MCP, il est désormais possible de connecter un LLM à la majorité des outils numériques du marché en quelques minutes. Pour autant, l'utilisation du MCP est coûteuse et peut présenter des problèmes de confidentialité. L'utilisation du MCP avec un LLM inféré en local répond en partie à ces deux problématiques. Explications et démonstration.
Pourquoi utiliser MCP avec un LLM en local ?
L'utilisation du MCP avec un LLM en local est la solution la plus logique pour éviter de trop dépenser. Le MCP nécessite de nombreux allers-retours entre outils et LLM, faisant littéralement exploser la consommation de tokens lors d'un usage quotidien. Avec des tarifs allant de 15 dollars en sortie pour un million de tokens avec Claude 4 Sonnet à 75 dollars avec Claude 4 Opus, par exemple, les coûts peuvent rapidement atteindre plusieurs centaines d'euros mensuels. Même avec un abonnement et l'utilisation de Claude Desktop, les limites d'usage sont vite atteintes. En comparaison, un LLM local ne consomme que le compute de votre machine, soit un surcoût électrique négligeable face aux prix des modèles dans le cloud.
Au-delà de l'économie, le LLM local avec MCP répond aux enjeux de confidentialité. La configuration on-device évite d'envoyer des données sensibles aux cloud providers ou éditeurs de modèles, crucial pour les cas d'usage critiques. Bien qu'elle ne protège pas totalement contre la prompt injection, elle permet de garder le contrôle sur ses données. L'association MCP + LLM local peut même fonctionner en environnement air-gap pour les exigences de sécurité maximales.
Tiny Agents d'Hugging Face avec Ollama
A l'heure actuelle, le plus simple pour exécuter MCP en local reste l'utilisation de Tiny Agents d'Hugging Face (client MCP local) et Ollama (bibliothèque d'inférence locale). Ollama va vous permettre de télécharger un LLM optimisé pour l'inférence on-device et de l'inférer sur votre machine sous la forme d'une API en localhost. Le client MCP d'Hugging Face est l'interface CLI qui permet l'échange entre les serveurs MCP et le LLM hébergé sur Ollama. Avant de passer à l'installation, assurez-vous d'avoir la dernière version de Python stable sur votre machine (3.13.3) en juin 2025. Note : utilisez la version officielle de Python et non la version téléchargée sur le Microsoft Store. Pour cela, lancez l'invite de commande en tapant PowerShell dans la barre de recherche Windows puis tapez :
python --version
et mettez à jour si besoin
Installation
Tiny Agents est intégré dans le SDK d'Hugging Face. Pour l'installer, rien de plus simple. Ouvrez Powershell et lancer la commande suivante :
python -m pip install -U "huggingface_hub[mcp]>=0.32.4" --break-system-packages
Installons ensuite Ollama depuis le site officiel. Une fois l'installateur téléchargé, lancez-le. Cliquez sur "installez" et laissez-le programme s'installer.
Une fois Ollama installé, il sera nécessaire de télécharger un modèle et de l'inférer. Le choix du modèle est crucial. Vous devez choisir un modèle supportant le function calling avec une taille ajustée selon les ressources matérielles de votre ordinateur. Nous y reviendrons plus tard. Nous vous conseillons d'utiliser une version de la famille qwen3 d'Alibaba. Les modèles raisonnent tous avant de répondre (via CoT) et supportent assez bien l'appel d'outils (vital pour le MCP). Pour un PC Windows classique sans GPU, la version 1.7B est, par exemple, optimale en termes de ressources.
L'installation et l'inférence du modèle dans Ollama est très simple, exécutez les commandes suivantes dans l'invite PowerShell :
pip install ollama
Fermez ensuite votre terminal et ouvrez en un nouveau (commande en tapant PowerShell dans la barre de recherche Windows) et exécutez :
ollama pull qwen3:1.7b
Le serveur Ollama est maintenant lancé.
Terminons par installer Node.js (un environnement JavaScript nécessaire pour MCP) :
powershell winget install -e --id OpenJS.NodeJS.LTS
L'installation est également possible depuis le site officiel de Node (téléchargez l'exécutable et installez-le).
Configuration
Vous allez lancer votre agent dans un dossier de votre ordinateur. Créez un dossier, nommez-le. Une fois dans le dossier, nous allons créer deux fichiers texte : agent.json, qui contiendra les paramètres de notre agent et PROMP.MD qui contiendra le prompt système de l'agent (ses instructions de base).
Editez agent.json et ajoutez la configuration suivante pour connecter l'agent à votre serveur ollama avec qwen3:1.7b. Dans cet exemple nous ajoutons également un premier serveur MCP : playwright. Ce dernier permet au LLM d'ouvrir un browser et de naviguer sur le web en totale autonomie.
{
"model": "qwen3:1.7b",
"endpointUrl": "http://localhost:11434/v1",
"servers": [
{
"type": "stdio",
"config": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
}
}
]
}
Pour le prompt system, vous pouvez donner à votre agent son contexte d'utilisation et les règles à respecter (pour l'appel d'outils notamment). Pour cela, collez :
You are a tool-using assistant. When invoking tools, you MUST return valid JSON objects without any comment, newline, or extra data.
Wrap tool arguments as a single-line JSON string, e.g. {"query": "Benjamin Polge"}
Do not add explanations or text outside the JSON object.
Exécution et ajout de serveurs MCP additionnels
Nous en avons fini pour la configuration. Pour exécuter votre agent, utilisez simplement la commande dans un nouveau PowerShell :
tiny-agents run CheminVersVotreDossierAgent
en veillant à remplacer CheminVersVotreDossierAgent par le lien vers votre dossier. Attendez-vous à une petite latence.
L'agent est alors lancé et vous pouvez l'interroger en langage naturel comme un chatbot. L'IA va alors utiliser les outils à sa disposition pour vous répondre. Selon les ressources matérielles de votre ordinateur, la génération de la réponse peut mettre de quelques secondes à plusieurs minutes.
Vous pouvez par exemple demander à l'agent d'ouvrir le navigateur et de rechercher l'adresse LinkedIn d'une personne. Exemple de prompt : "Qui est monsieur XX ? Recherchez l'adresse URL de son LinkedIn avec le navigateur et affichez l'URL".
L'agent s'exécute alors et va chercher le nom en utilisant le browser via MCP.
Dans la configuration d'agent.json, nous n'avons utilisé qu'un outil MCP (playwright). Mais il est possible de modifier rapidement votre configuration pour ajouter une flopée de serveurs MCP. Il suffit d'ajouter la configuration du serveur MCP voulu dans le fichier. Exemple en ajoutant le support d'un serveur MCP pour accéder aux fichiers locaux (server-filesystem) :
{
"model": "qwen3:1.7b",
"endpointUrl": "http://localhost:11434/v1",
"servers": [
{
"type": "stdio",
"config": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
}
},
{
"type": "stdio",
"config": {
"command": "npx",
"args": [
"@modelcontextprotocol/server-filesystem@latest",
"C:\\Users\\UserName\\Documents"
]
}
}
]
}
Les limites de l'usage local d'un LLM pour le MCP
Les performances et la fiabilité d'un agent utilisant MCP dépendent directement du modèle de langage (LLM) sous-jacent. Les modèles de moins de 7 milliards de paramètres présentent des limitations significatives : ils génèrent fréquemment des erreurs de formatage JSON qui bloquent l'appel aux outils, et leur compréhension contextuelle reste limitée. Malheureusement, les modèles plus performants de plus de 7 milliards de paramètres posent un autre défi majeur : ils sont extrêmement voraces en ressources computationnelles. Sur la majorité des ordinateurs personnels actuels, ces modèles nécessitent soit des temps de génération très longs, soit ne pourront tout simplement pas fonctionner en raison de ressources VRAM insuffisantes. Toutefois, le problème est appelé à se résoudre à terme car les éditeurs de modèle open source développent constamment des modèles plus efficaces et compacts.
Pour les utilisateurs équipés de Mac avec les dernières puces Apple Silicon (M1, M2, M4...), la situation est déjà bien plus favorable. Les puces sont optimisées pour l'intelligence artificielle embarquée et intègrent nativement un NPU (puce dédiée à l'IA) et utilisent une architecture de mémoire unifiée (RAM + VRAM). Une conception qui permet de faire tourner des modèles de taille bien supérieure avec une efficacité remarquable. L'expérience avec le MCP en est donc d'autant plus performante et fluide.