Votre guide de l'IA agentique avec MATLAB

Introduction : IA agentique avec MATLAB

L'IA générative a transformé notre manière d'interagir avec les ordinateurs, mais aller au-delà du simple dialogue pour construire des systèmes d'IA capables de raisonner, d'agir et d'exécuter de manière autonome du code MATLAB^® nécessite une approche novatrice. Aujourd'hui, demander à un grand modèle de langage de résoudre un problème d'ingénierie signifie souvent copier le code d'un point à un autre, corriger les erreurs manuellement et espérer que l'IA ait compris votre domaine. L'IA agentique change la donne.

Ce guide vous montre comment construire des systèmes d'IA qui ne se contentent pas de suggérer des solutions, mais qui les exécutent. En connectant les LLM à MATLAB via le Model Context Protocol (MCP), vous pouvez créer des agents d'IA qui écrivent du code, exécutent des simulations, analysent les résultats et effectuent des itérations jusqu'à l’obtention du résultat.

Du chat à l’action : pourquoi l'IA agentique ?

Si vous avez utilisé ChatGPT ou Claude pour vous aider avec du code MATLAB, vous connaissez la procédure : poser une question, obtenir du code, le coller dans MATLAB, rencontrer une erreur, revenir sur le chat, expliquer l'erreur, obtenir un nouveau code, et ainsi de suite. Cela fonctionne, mais c'est lent et frustrant.

L'IA agentique boucle cette boucle. Au lieu d'être un générateur de texte que vous orchestrez manuellement, un agent d'IA peut :

• Écrire le code et l’exécuter directement
• Détecter les erreurs et les corriger automatiquement
• Accéder à votre espace de travail et à vos données
• Effectuer des itérations jusqu'à ce que la tâche soit terminée
• Fournir des résultats vérifiés et fonctionnels

Comparez cela avec l'IA générative, qui :

• Génère des extraits de code sur demande
• Nécessite que vous copiez, colliez et exécutiez le code manuellement
• Compte sur vous pour interpréter les erreurs et poser des questions complémentaires
• N'a pas accès à vos fichiers ou données
• Ne peut pas vérifier si le code fonctionne réellement

Quatre capacités qui transforment un chatbot en collègue

L'IA générative, c’est comme avoir un consultant qui rédige des rapports. L'IA agentique, c’est comme avoir un collègue qui fait le travail. L'IA ne se contente pas de vous indiquer comment résoudre un problème : elle le résout, vous montre les résultats et vous demande si vous souhaitez des modifications.

Pourquoi combiner MATLAB avec l'IA agentique ?

MATLAB est particulièrement précieux pour l'IA agentique en ingénierie et en sciences car il offre :

• Calcul fiable : Les grands modèles de langage ont tendance à halluciner les mathématiques, tandis que MATLAB les traite correctement.
• Expertise sectorielle : Plus de 100 toolboxes sont disponibles pour le traitement du signal, le contrôle, le Deep Learning, et bien plus encore.
• Capacités de simulation : Connectez-vous à Simulink^® pour le test et la vérification au niveau système.
• Outils professionnels : Les capacités d'analyse, de visualisation et de déploiement du code sont intégrées.

Compréhension du Model Context Protocol

Pour qu'un LLM puisse utiliser MATLAB, il doit disposer d'un moyen pour découvrir les outils disponibles, les appeler avec les bons paramètres et recevoir les résultats. C'est précisément ce que le Model Context Protocol (MCP) offre : un cadre commun qui permet l'interaction entre l'IA et les outils. Considérez le MCP comme un port USB-C pour l’IA : tout comme l'USB-C permet à tout équipement de se connecter à n'importe quel périphérique, le MCP permet à tout modèle d'IA de se connecter à n'importe quel outil, y compris MATLAB.

Le serveur MCP assure la traduction entre les requêtes d'IA et l'exécution MATLAB. L'agent d'IA décide de ce qu'il faut faire ; MATLAB effectue les calculs.

Permettre aux agents d’IA d’utiliser MATLAB (MCP Core Server)

Le MATLAB MCP Core Server rend MATLAB disponible pour toute application d'IA compatible MCP. Une fois installés, les assistants d’IA tels que Claude Desktop, GitHub Copilot ou Gemini CLI peuvent écrire et exécuter du code MATLAB pour vous, tout en vous laissant le contrôle.

En coulisses, le MCP Core Server propose cinq capacités fondamentales qui permettent aux agents d'IA de travailler de manière autonome avec MATLAB. Vous n'avez pas besoin de les appeler directement ; l'agent d’IA les utilise automatiquement en fonction de ce que vous lui demandez de faire :

Le workflow agentique en action

Une interaction typique se présente ainsi : Vous demandez : « Créez un filtre de Butterworth pour ce signal bruité. » L'IA écrit le code, l'exécute dans MATLAB, vérifie s'il y a des erreurs ou des résultats inattendus, affine son approche et fournit un code fonctionnel avec un graphique, le tout sans aucun copier-coller de votre part.

Installation

Téléchargez MATLAB MCP Core Server sur GitHub :

# Clone the repository
git clone https://github.com/mathworks/matlab-mcp-core-server

# Follow setup instructions for your AI client
# (Claude Desktop, VS Code with Copilot, Gemini CLI, etc.)

Exemple de configuration (Claude Desktop)

Ajoutez à votre fichier claude_desktop_config.json :

{ 
 "mcpServers": { 
 "matlab": { 
 "command": "/path/to/matlab-mcp-server", 
 "args": [] 
 } 
 } 
} 

Comprenez ce que vous permettez

Les outils d'IA agentique peuvent écrire et exécuter du code sur votre machine avec accès à vos fichiers. Cette capacité est puissante mais exige de la confiance. Examinez attentivement ce que l'IA propose avant d'approuver des actions importantes, en particulier dans les environnements de production.

Créer des agents IA dans MATLAB (Client MCP)

Que faire si vous souhaitez créer votre propre agent d'IA qui fonctionne dans MATLAB et peut appeler des outils et des API externes ? Le client MATLAB MCP rend cela possible, transformant MATLAB en une plateforme pour le développement d'IA agentique.

Principales capacités de MATLAB en tant qu'hôte d'agent IA

• Découvrez les outils : Interrogez n'importe quel serveur MCP pour lister les outils disponibles et leurs schémas d'entrée.
• Outils d’appel : Appelez des outils externes aussi facilement que des fonctions MATLAB locales avec callTool.
• Intégration LLM : Convertissez les schémas d'outils en objets openAIFunction pour un appel de fonction fluide.

Maintenant, examinons un exemple de construction d'un workflow agentique dans MATLAB :

% Connect to an MCP server 
client = mcpClient("path/to/mcp-server"); 
 
% List available tools from the server 
tools = listTools(client); 
disp(tools); 
 
% Convert tools to OpenAI function format for the LLM 
functions = openAIFunction(tools); 
 
% Create a chat with function calling enabled 
chat = openAIChat("You are a helpful assistant.", ... 
 Tools=functions); 
 
% Send a user query - LLM decides if a tool is needed 
response = generate(chat, "What is the 10th prime number?"); 
 
% If LLM requests a tool call, execute it 
if isfield(response, 'tool_calls') 
 toolRequest = response.tool_calls; 
 result = callTool(client, toolRequest); 
     
 % Feed result back to LLM for final response 
 finalResponse = generate(chat, result); 
end 

À quoi pouvez-vous vous connecter ?

Tout serveur MCP fonctionne avec le client MCP MATLAB. Cela inclut les serveurs pour les bases de données, les API web, les systèmes de fichiers, d'autres services d'IA et les outils personnalisés que vous développez. L'écosystème se développe rapidement.

Implémenter l'appel d'outil dans MATLAB

L'appel d'outil est le mécanisme au cœur de l'IA agentique. Le LLM n'exécute pas directement les fonctions, mais génère une requête structurée décrivant quelle fonction appeler et avec quels arguments. Votre code exécute ensuite la fonction et renvoie les résultats au LLM.

Le module LLM détermine ce qu'il doit calculer. MATLAB se charge de l’exécution correcte du calcul. Lorsqu'un utilisateur soumet une requête, le modèle de langage interprète l'intention et décide quel outil appeler ainsi que les paramètres à utiliser. MATLAB exécute ensuite la fonction et renvoie le résultat. Le module LLM formate une réponse en langage naturel. Les utilisateurs n'ont jamais besoin d'écrire ou d'exécuter eux-mêmes du code.

Définir un outil dans MATLAB

% Define a function that the LLM can call 
function result = addTwoNumbers(x1, x2) 
 result = x1 + x2; 
end 
 
% Create tool definition for the LLM 
addTool = openAIFunction("addTwoNumbers", ... 
 "Add two numbers together"); 
addTool = addParameter(addTool, "x1", "number", ... 
 "First number to add", Required=true); 
addTool = addParameter(addTool, "x2", "number", ... 
 "Second number to add", Required=true);

Construire un agent d'IA simple

function aiAgent(userQuery) 
 % Initialize chat with tools 
 chat = ollamaChat("mistral-nemo", Tools=addTool); 
     
 % Get LLM response 
 response = generate(chat, userQuery); 
     
 % Check if LLM wants to call a tool 
 if isfield(response, 'tool_calls') 
 % Extract function call details 
 funcName = response.tool_calls.function.name; 
 args = response.tool_calls.function.arguments; 
         
 fprintf("AI requested: %s(%f, %f)\n", ... 
 funcName, args.x1, args.x2); 
         
 % Execute the function 
 result = addTwoNumbers(args.x1, args.x2); 
 fprintf("Result: %f\n", result); 
 else 
 % No tool call - show direct response 
 disp(response.content); 
 end 
end

L'appel d'outils fonctionne avec plusieurs fournisseurs via les LLM avec le module complémentaire MATLAB, notamment :

• OpenAI : Dernier modèle GPT (via API)
• Azure OpenAI : Déploiements d'entreprise
• Ollama : Modèles locaux tels que Mistral, GPT-OSS, DeepSeek et Qwen

Créer des agents d'IA efficaces

Passer des démonstrations à la production nécessite des modèles qui rendent les agents fiables, observables et sûrs. Ces approches sont éprouvées dans des systèmes agentiques réels.

Modèle 1 : ReAct (Reasoning + Acting)

Le modèle d’agent le plus courant alterne entre la réflexion et l’action. Le LLM réfléchit à la prochaine étape à suivre, agit en conséquence, observe les résultat, puis répète ce processus.

% ReAct loop pattern 
while ~taskComplete 
 % Thought: LLM reasons about next step 
 thought = generate(chat, [context, "What should I do next?"]); 
     
 % Action: Execute tool if needed 
 if needsTool(thought) 
 result = executeTool(thought.tool_call); 
 context = [context; result]; 
 end 
     
 % Observation: Update state based on results 
 taskComplete = checkCompletion(context); 
end 

Modèle 2 : Enchaînement d'outils

Les tâches complexes nécessitent l'utilisation séquentielle de plusieurs outils. La sortie de l'un devient l'entrée du suivant. Par exemple :

Modèle 3 : Humain dans la boucle

Pour les applications critiques en matière de sécurité, ajoutez des étapes d'approbation avant que l'agent n’agisse :

% Human-in-the-loop pattern 
proposedAction = generate(chat, query); 
 
% Display proposed action for approval 
fprintf("Proposed: %s\n", proposedAction.description); 
approval = input("Approve? (y/n): ", "s"); 
 
if strcmp(approval, "y") 
 result = executeAction(proposedAction); 
else 
 disp("Action cancelled."); 
end 

Conseils pratiques

Plusieurs principes directeurs constituent les clés pour garantir des agents fiables :

• Commencez simplement : faites fonctionner un seul outil avant de construire des chaînes complexes.
• Ajoutez de l’observabilité : consignez chaque appel LLM et chaque exécution d'outil car vous en aurez besoin pour le débuggage.
• Gérez les erreurs avec soin : les LLM commettent des erreurs ; mettez en place une logique de nouvelle tentative avec un retour en arrière exponentiel.
• Définissez des limites : limitez les itérations, les budgets de symboles et les outils auxquels un agent peut accéder.
• Testez de manière adversariale : testez délibérément les cas limites pour mettre à l'épreuve votre agent avant qu'il n'atteigne les utilisateurs.