Ihr Leitfaden zur agentischen KI mit MATLAB

Einleitung: Agentische KI mit MATLAB

Generative KI hat die Art und Weise, wie wir mit Computern interagieren, verändert. Doch um über den Chat hinauszugehen und KI-Systeme zu entwickeln, die eigenständig denken, handeln und MATLAB^®-Code ausführen können, ist ein neuer Ansatz erforderlich. Heutzutage bedeutet die Anforderung an ein großes Sprachmodell (LLM) zur Lösung eines technischen Problems oft, Code hin und her zu kopieren, Fehler manuell zu beheben und zu hoffen, dass die KI Ihr Fachgebiet verstanden hat. Agentische KI ändert dies.

Dieser Leitfaden zeigt Ihnen, wie Sie KI-Systeme entwickeln, die nicht nur Lösungen vorschlagen, sondern diese auch umsetzen. Durch die Verbindung von LLMs mit MATLAB über das Model Context Protocol (MCP) können Sie KI-Agenten erstellen, die Code schreiben, Simulationen durchführen, Ergebnisse analysieren und iterativ arbeiten, bis die Aufgabe abgeschlossen ist.

Vom Chat zur Tat: Warum agentische KI?

Wenn Sie ChatGPT oder Claude zur Unterstützung bei MATLAB Programmcode verwendet haben, kennen Sie das Vorgehen: Sie stellen eine Frage, erhalten einen Code, fügen ihn in MATLAB ein, Sie stoßen auf einen Fehler, kehren zum Chat zurück, erklären den Fehler, erhalten neuen Code und Sie wiederholen den Vorgang. Es funktioniert, aber es ist langsam und frustrierend.

Agentische KI schließt diese Schleife. Anstatt ein Textgenerator zu sein, den Sie manuell steuern, kann ein KI-Agent:

• Code schreiben und direkt ausführen
• Fehler sehen und automatisch beheben.
• Auf Ihren Workspace und Ihre Daten zugreifen
• Den Vorgang wiederholen, bis die Aufgabe abgeschlossen ist.
• Verifizierte, funktionierende Ergebnisse liefern.

Im Gegensatz dazu steht die generative KI:

• Generiert auf Anfrage Code-Snippets.
• Erfordert, dass Sie den Code manuell kopieren, einfügen und ausführen.
• Verlässt sich darauf, dass Sie Fehler interpretieren und Nachfragen stellen.
• Hat keinen Zugriff auf Ihre Dateien oder Daten.
• Kann nicht überprüfen, ob der Code tatsächlich funktioniert.

Vier Fähigkeiten, die einen Chatbot zu einem Kollegen machen

Generative KI ist wie ein Berater, der Berichte verfasst. Agentische KI ist wie ein Kollege, der die Arbeit erledigt. Die KI sagt Ihnen nicht nur, wie Sie ein Problem lösen können – sie löst es, zeigt Ihnen die Ergebnisse und fragt, ob Sie Änderungen wünschen.

Warum MATLAB mit agentischer KI kombinieren?

MATLAB ist für agentische KI im Ingenieurwesen und in den Naturwissenschaften von einzigartigem Wert, da es Folgendes bietet:

• Zuverlässige Berechnung: Große Sprachmodelle (LLMs) erzeugen mathematische Fehler, während MATLAB diese korrekt berechnet.
• Fachwissen: Es stehen mehr als 100 Toolboxes für Signalverarbeitung, Regelung, Deep Learning und weitere Bereiche zur Verfügung.
• Simulationsfähigkeiten: Verbinden Sie sich mit Simulink^® für Systemtests und Verifikation auf Systemebene.
• Professionelle Werkzeuge: Fähigkeiten zur Codeanalyse, Visualisierung und Bereitstellung sind integriert.

Verständnis des Model Context Protocol

Damit ein LLM MATLAB verwenden kann, benötigt es eine Möglichkeit, verfügbare Werkzeuge zu entdecken, diese mit den richtigen Parametern aufzurufen und Ergebnisse zu erhalten. Genau das liefert das Model Context Protocol: ein gemeinsames Framework, das die Interaktion zwischen KI und Werkzeugen ermöglicht. Betrachten Sie MCP als einen USB-C-Anschluss für KI: So wie USB-C es jedem Gerät ermöglicht, sich mit jedem Peripheriegerät zu verbinden, ermöglicht MCP jedem KI-Modell die Verbindung mit jedem Werkzeug – einschließlich MATLAB.

Der MCP-Server übersetzt zwischen KI-Anfragen und der Ausführung von MATLAB. Der AI-Agent entscheidet, was zu tun ist; MATLAB übernimmt die Berechnung.

KI-Agenten können MATLAB (MCP Core Server) verwenden

Der MATLAB MCP Core Server stellt MATLAB für jede MCP-kompatible KI-Anwendung bereit. Nach der Installation können KI-Assistenten wie Claude Desktop, GitHub Copilot oder Gemini CLI MATLAB Programmcode in Ihrem Auftrag schreiben und ausführen – wobei Sie die Kontrolle behalten.

Im Hintergrund stellt der MCP Core Server fünf grundlegende Funktionen bereit, die es KI-Agenten ermöglichen, eigenständig mit MATLAB zu arbeiten. Sie müssen diese nicht direkt aufrufen; der AI-Agent verwendet sie jeweils automatisch basierend auf dem, was Sie anfragen:

Der agentische Workflow in Aktion

Eine typische Interaktion sieht folgendermaßen aus: Sie bitten darum, einen Butterworth-Filter für dieses verrauschte Signal zu erstellen. Die KI schreibt den Code, führt ihn in MATLAB aus, überprüft, ob Fehler oder unerwartete Ergebnisse vorliegen, verfeinert ihren Ansatz und liefert funktionierenden Code mit einem Diagramm, alles ohne jegliches Kopieren oder Einfügen Ihrerseits.

Installation

Laden Sie den MATLAB MCP Core Server von GitHub herunter:

# Klonen des Repository
git clone https://github.com/mathworks/matlab-mcp-core-server

# Befolgen der Einrichtungshinweise für Ihren KI-Client
# (Claude Desktop, VS Code mit Copilot, Gemini CLI usw.)

Konfigurationsbeispiel (Claude Desktop)

Fügen Sie zu Ihrer claude_desktop_config.json hinzu:

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

Verstehen, was Sie ermöglichen

Agentische KI-Werkzeuge können Code auf Ihrem Gerät schreiben und ausführen und haben Zugriff auf Ihre Dateien. Diese Fähigkeit ist wirkungsvoll, erfordert jedoch Vertrauen. Überprüfen Sie, was die KI vorschlägt, bevor Sie bedeutende Maßnahmen genehmigen, insbesondere in Produktionsumgebungen.

Erstellen von KI-Agenten in MATLAB (MCP-Client)

Was ist, wenn Sie Ihren eigenen KI-Agenten erstellen möchten, der innerhalb von MATLAB läuft und externe Werkzeuge sowie APIs aufrufen kann? Der MATLAB MCP-Client macht dies möglich und verwandelt MATLAB in eine Plattform für die Entwicklung agentischer KI.

Wesentliche Fähigkeiten von MATLAB als Host für den KI-Agenten

• Werkzeuge entdecken: Abfragen eines beliebigen MCP-Servers zur Auflistung verfügbarer Werkzeuge und deren Eingabeschemata.
• Werkzeuge aufrufen: Rufen Sie externe Werkzeuge ebenso einfach auf wie lokale MATLAB-Funktionen mit callTool.
• LLM-Integration: Konvertieren Sie Werkzeug-Schemata in OpenAIFunction-Objekte für nahtloses Funktionsaufrufen.

Als Nächstes betrachten wir ein Beispiel für den Aufbau eines agentischen Workflows innerhalb von MATLAB:

% Verbindung zu einem MCP-Server herstellen 
client = mcpClient("path/to/mcp-server"); 
 
% Liste der verfügbaren Werkzeuge vom Server anzeigen 
tools = listTools(client); 
disp(tools); 
 
% Werkzeuge in das OpenAI-Funktionsformat für das LLM konvertieren 
functions = openAIFunction(tools); 
 
% Erstellen Sie einen Chat mit aktivierter Funktionsaufruf-Funktionalität 
chat = openAIChat("Sie sind ein hilfreicher Assistent.", ... 
 Tools=functions); 
 
% Senden Sie eine Benutzeranfrage – das LLM entscheidet, ob ein Werkzeug benötigt wird 
response = generate(chat, "What is the 10th prime number?"); 
 
% Falls ein LLM einen Werkzeugaufruf anfordert, führen Sie ihn aus. 
if isfield(response, 'tool_calls') 
 toolRequest = response.tool_calls; 
 result = callTool(client, toolRequest); 
     
 % Ergebnis zurück an das LLM für die endgültige Antwort übermitteln 
 finalResponse = generate(chat, result); 
end 

Womit können Sie sich verbinden?

Jeder MCP-Server funktioniert mit dem MATLAB MCP-Client. Dies umfasst Server für Datenbanken, Web-APIs, Dateisysteme, andere KI-Dienste und benutzerdefinierte Werkzeuge, die Sie erstellen. Das Ökosystem wächst schnell.

Implementierung des Werkzeugaufrufs in MATLAB

Das Aufrufen von Werkzeugen ist der Mechanismus im Zentrum der agentischen KI. Das LLM führt Funktionen nicht direkt aus, sondern gibt eine strukturierte Anfrage aus, die beschreibt, welche Funktion mit welchen Argumenten aufgerufen werden soll. Ihr Code führt dann die Funktion aus und gibt die Ergebnisse an das LLM zurück.

Das LLM überlegt, was berechnet werden soll. MATLAB übernimmt die korrekte Berechnung. Wenn ein Anwender eine Anfrage stellt, interpretiert das LLM die Absicht und entscheidet, welches Werkzeug mit welchen Parametern aufgerufen wird. MATLAB führt dann die Funktion aus und gibt das Ergebnis zurück. Das LLM formatiert eine Antwort in natürlicher Sprache. Anwender müssen niemals selbst Code schreiben oder ausführen.

Definieren Sie ein Werkzeug in MATLAB

% Definieren Sie eine Funktion, die das LLM aufrufen kann 
function result = addTwoNumbers(x1, x2) 
 result = x1 + x2; 
end 
 
% Erstellen Sie eine Werkzeugdefinition für das LLM 
addTool = openAIFunction("addTwoNumbers", ... 
 "Addieren Sie zwei Zahlen miteinander"); 
addTool = addParameter(addTool, "x1", "number", ... 
 "Erste Zahl zum Addieren", Required=true); 
addTool = addParameter(addTool, "x2", "number", ... 
 "Zweite Zahl zum Addieren", Required=true);

Erstellen Sie einen einfachen KI-Agenten

function aiAgent(userQuery) 
 % Chat mit Werkzeugen initialisieren 
 chat = ollamaChat("mistral-nemo", Tools=addTool); 
     
 % LLM-Antwort erhalten 
 response = generate(chat, userQuery); 
     
 % Überprüfen, ob das LLM ein Werkzeug aufrufen möchte 
 if isfield(response, 'tool_calls') 
 % Details zum Funktionsaufruf extrahieren 
 funcName = response.tool_calls.function.name; 
 args = response.tool_calls.function.arguments; 
         
 fprintf("AI requested: %s(%f, %f)\n", ... 
 funcName, args.x1, args.x2); 
         
 % Führen Sie die Funktion aus 
 result = addTwoNumbers(args.x1, args.x2); 
 fprintf("Result: %f\n", result); 
 else 
 % Kein Werkzeugaufruf – direkte Antwort anzeigen 
 disp(response.content); 
 end 
end

Der Werkzeugaufruf funktioniert mit mehreren Anbietern über die LLMs mit dem MATLAB-Add-on, einschließlich:

• OpenAI: Neuestes GPT-Modell (über API)
• Azure OpenAI: Unternehmenseinsätze
• Ollama: Lokale Modelle wie Mistral, GPT-OSS, DeepSeek und Qwen

Erstellung effektiver KI-Agenten

Der Übergang von Demonstrationen zur Produktion erfordert Muster, die Agenten zuverlässig, beobachtbar und sicher machen. Diese Ansätze sind in realen agentischen Systemen erprobt.

Muster 1: ReAct (Überlegen + Handeln)

Das gebräuchlichste Agentenmuster wechselt zwischen Nachdenken und Handeln. Das LLM überlegt, was als Nächstes zu tun ist, ergreift eine Maßnahme, beobachtet das Ergebnis und wiederholt den Vorgang.

% ReAct-Schleifenmuster 
while ~taskComplete 
 % Gedanke: Das große Sprachmodell überlegt den nächsten Schritt. 
 thought = generate(chat, [context, "What should I do next?"]); 
     
 % Aktion: Führen Sie das Werkzeug bei Bedarf aus. 
 if needsTool(thought) 
 result = executeTool(thought.tool_call); 
 context = [context; result]; 
 end 
     
 % Beobachtung: Aktualisieren Sie den Status basierend auf den Ergebnissen. 
 taskComplete = checkCompletion(context); 
end 

Muster 2: Werkzeugverkettung

Komplexe Aufgaben erfordern den sequenziellen Einsatz mehrerer Werkzeuge. Die Ausgabe des einen wird zum Eingang des nächsten. Beispielsweise:

Muster 3: Mensch in der Schleife

Für sicherheitskritische Anwendungen fügen Sie Genehmigungsschritte hinzu, bevor der Agent Maßnahmen ergreift:

% Mensch-in-der-Schleife-Muster 
proposedAction = generate(chat, query); 
 
% Vorgeschlagene Maßnahme zur Genehmigung anzeigen 
fprintf("Proposed: %s\n", proposedAction.description); 
approval = input("Approve? (y/n): ", "s"); 
 
if strcmp(approval, "y") 
 result = executeAction(proposedAction); 
else 
 disp("Aktion abgebrochen."); 
end 

Praktische Anleitung

Mehrere Richtlinien dienen als Schlüssel zur Gewährleistung zuverlässiger Agenten:

• Beginnen Sie einfach: Lassen Sie ein einzelnes Werkzeug funktionieren, bevor Sie komplexe Ketten erstellen.
• Fügen Sie Beobachtbarkeit hinzu: Protokollieren Sie jeden LLM-Aufruf und jede Werkzeugausführung, da Sie dies für die Fehlerbehebung benötigen werden.
• Fehler elegant behandeln: LLMs machen Fehler; implementieren Sie eine Wiederholungslogik mit Binary Exponential Backoff.
• Grenzen setzen: Begrenzen Sie Iterationen, Token-Budgets und die Werkzeuge, auf die ein Agent zugreifen kann.
• Testen Sie gezielt adverseriell: Testen Sie absichtlich Grenzfälle, um Ihren Agenten zu durchbrechen, bevor er die Anwender erreicht.