Startseite / Artikel

Erstellung autonomer ColdFusion-AI-Agenten und MCP (Teil 5)

ColdFusion-KI-Agenten mit Anrufen über das Gemini-Tool, ein MCP-Server-Endpunkt sowie sichere AlloyDB-Views für NL2SQL, wie in einer Demo zu Betriebsabläufen in einer Brauerei auf Google Cloud gezeigt.

Verlag: REACTAPP.TOP6 Min. Lesezeit1358 Wörter

Quellen: Building Autonomous ColdFusion AI Agents & Model Context Protocol (MCP)

Modernisierung von ColdFusion auf Google Cloud – Teil 5 von 5

Die früheren Artikel dieser Serie zeigten, wie Adobe ColdFusion-Anwendungen native Google Cloud-Dienste nutzen können:

  • Teil 1: Umstieg von einer verwalteten VM auf Cloud Run, Automatisierung der Builds mit Cloud Build sowie Sicherung des Zugriffs mit IAM Workload Identity.
  • Teil 2: AlloyDB für PostgreSQL für hochleistungsfähige ACID-Operationen zusammen mit Vektor-Embeddings für semantische Suche.
  • Teil 3: Passwortsfreier JDBC-Zugriff auf BigQuery und GQL für Eigenschaftsgraphen im Stil von Customer360.
  • Teil 4: Vertex AI AutoML-Vorhersagen anhand von Echtzeit-Batch-Daten (in der Bierbrauerei-Demo: Biergärung).

In diesem Teil erhält die Bierbrauerei ein „Gehirn“: autonome Agenten, die logisch denken, den aktuellen Zustand abfragen, Batch-Risiken bewerten und Tools als MCP-Server bereitstellen.

Agentenbasiertes ColdFusion

Frühe KI-Funktionen bedeuteten oft, dass der Benutzer eine Anfrage eintippte, die App diese an ein LLM sendete und die Antwort allein aus den Trainingsgewichten stammte. Das hilft bei Texten, kann aber keine operativen Fragen beantworten wie zum Beispiel:

  • Wie hoch sind die aktuelle Temperatur und der Druck in einem bestimmten Behälter?
  • Wie viel helles Malz wurde in den letzten 30 Minuten verbraucht?
  • Kann der Lagerbestand die für eine Herstellung von fünfzig Fässern Citra Sunset IPA benötigten Citra-Hopps liefern?

Ein agiler Arbeitsablauf trennt das Denken von der Datensuche. Das Modell fungiert als Orchesterator: Es erkennt die Absicht, wählt geeignete Tools oder Abfragen aus, prüft die Ergebnisse und erstellt eine auf Fakten basierende Antwort.

CF-Brews untersucht zwei komplementäre Ansätze:

  1. Natürliche Orchestrierung von ColdFusion-Tools und MCP: Ein CFC (BrewMasterTools.cfc) wird an Gemini bereitgestellt, um eine deterministische Zuweisung der Tools sowie Abfragen an AlloyDB zu ermöglichen.
  • Sicheres NL2SQL: Fragen in SQL übersetzen und anschließend durch parametrierte sichere Ansichten von AlloyDB (PSVs) einschränken.
  • Aufruf nativer Tools

    Die Geschäftsregeln befinden sich in einem CFC. In api/v1/tools/BrewMasterTools.cfc sind die Hauptfunktionen:

    • checkInventory(recipeName, volumeGallons): Prüfung, ob der Lagerbestand den Anforderungen des Rezepts entspricht.
    • getRecipeDetails(recipeName): Ziel-ABV, Temperaturgrenzwerte sowie Zutatenverhältnisse.
    • checkBatchRisk(style): Überprüfung der aktiven Gärbehälter sowie Alarmierung bei Temperatur- oder Druckabweichungen.

    checkInventory verknüpft Rezepte, Zutaten und Lagerbestände, skaliert die Mengen nach dem Volumen und gibt an, was fehlt:

    component {
       /**
        * Determines if there are enough ingredients in stock to brew a specific volume.
        */
       public struct function checkInventory(required string recipeName, numeric volumeGallons = 1) {
           var response = { "can_brew": false, "recipe_found": false, "missing_ingredients": [] };
           var sql = "
               SELECT
                   r.recipe_name,
                   i.name AS item_name,
                   (ri.amount_per_gallon * :volume) AS required_amount,
                   i.quantity_on_hand AS current_stock,
                   i.unit
               FROM Recipes r
               INNER JOIN RecipeIngredients ri ON r.recipe_id = ri.recipe_id
               INNER JOIN Inventory i ON ri.inventory_item_id = i.item_id
               WHERE LOWER(r.recipe_name) = LOWER(:recipe)
           ";
           var ingredients = queryExecute(sql, {
               recipe = { value = arguments.recipeName, cfsqltype = "cf_sql_varchar" },
               volume = { value = arguments.volumeGallons, cfsqltype = "cf_sql_numeric" }
           });
           if (ingredients.recordCount == 0) {
               response.message = "Recipe '#arguments.recipeName#' not found.";
               return response;
           }
           response.recipe_found = true;
           var canBrew = true;
           var missingList = [];
           for (var row in ingredients) {
               if (row.current_stock < row.required_amount) {
                   canBrew = false;
                   arrayAppend(missingList, {
                       "item": row.item_name,
                       "required": row.required_amount,
                       "in_stock": row.current_stock,
                       "missing_amount": row.required_amount - row.current_stock,
                       "unit": row.unit
                   });
               }
           }
           response.can_brew = canBrew;
           response.missing_ingredients = missingList;
           response.message = canBrew ? "Sufficient inventory available." : "Insufficient stock.";
    
           return response;
       }
    }
    

    Deterministische Tool-Orchestrierung

    ColdFusions ChatModel() steuert einen dreistufigen Loop mit Gemini:

    1. Intent-Routing: Die Anfrage wird zusammen mit Systemanweisungen, die die verfügbaren Tools auflisten, an Gemini gesendet. Falls eine Aktion erforderlich ist, gibt Gemini strukturierte JSON-Daten zurück.
    2. Ausführung: ColdFusion parset die JSON-Daten und ruft die entsprechende CFC-Methode in AlloyDB auf.
    3. Synthese: Die Ausgabe des Tools wird erneut an ChatModel() übergeben, um eine fundierte Antwort in natürlicher Sprache zu erzeugen.
    <cfscript>
        // api/v1/agent/mcp-chat.cfm
        userPrompt = trim(deserializeJson(toString(getHttpRequestData().content)).prompt);
    
        // 1. Initialize native ChatModel with zero temperature for deterministic routing
        chatModel = ChatModel({
            "provider": "gemini",
            "modelName": "gemini-2.5-flash",
            "apiKey": trim(application.AI_STUDIO_API_KEY),
            "temperature": 0.0
        });
    
        // 2. Instruct model on available tools
        systemInstruction = 'You are the Brewmaster AI Assistant. Available tools:
    1. checkInventory(recipeName, volumeGallons)
    2. getRecipeDetails(recipeName)
    3. checkBatchRisk(style)
    
    If you need a tool, respond ONLY with JSON: {"tool": "toolName", "arguments": {...}}
    Otherwise, answer in plain text.
    
    User question: ' & userPrompt;
    
        aiReply = chatModel.chat(systemInstruction).message;
    
        // 3. Detect and execute tool call
        if (left(trim(aiReply), 1) == "{" && right(trim(aiReply), 1) == "}") {
            toolCall = deserializeJson(aiReply);
            tools = new api.v1.tools.BrewMasterTools();
    
            if (toolCall.tool == "checkInventory") {
                toolResult = tools.checkInventory(toolCall.arguments.recipeName, val(toolCall.arguments.volumeGallons ?: 1));
            } else if (toolCall.tool == "getRecipeDetails") {
                toolResult = tools.getRecipeDetails(toolCall.arguments.recipeName);
            } else if (toolCall.tool == "checkBatchRisk") {
                toolResult = tools.checkBatchRisk(toolCall.arguments.style ?: "");
            }
    
            // 4. Grounded synthesis
            synthesis = chatModel.chat("Tool '#toolCall.tool#' returned: #serializeJson(toolResult)#. Answer user: #userPrompt#");
            finalText = synthesis.message;
        } else {
            finalText = aiReply;
        }
    
        writeOutput(serializeJson({ "success": true, "text": finalText }));
    </cfscript>
    

    JSON-Richtlinien

    Modelle wie Gemini können das Sampling an ein JSON-Schema binden, sodass sie keine Zeichen aussenden, die die Struktur stören. Produktionscode sollte die Ausgabe dennoch als fehleranfällig betrachten:

    • Umhüllen Sie deserializeJson() mit try/catch.
    • Setzen Sie die Temperatur auf 0,0, um eine deterministischere Auswahl der Tools zu erzielen.
    • Falls die Deserialisierung fehlschlägt oder Typunterschiede vorliegen, fangen Sie die Ausnahme ab und bitten Sie das Modell entweder um einen Neversuch oder geben Sie dem Benutzer eine klare Alternative zurück.

    ColdFusion als MCP-Server

    Das Model Context Protocol, das von Anthropic open source veröffentlicht wurde, ist die gängige Methode, um Daten und Tools an externe KI-Kunden bereitzustellen. Ein MCP-Klient in einer KI-App kommuniziert zweigeteilt mit einem MCP-Server. Die ColdFusion 2025 Update 8 fügte MCPServer() hinzu.

    Während von onApplicationStart in Application.cfc registrieren Sie einen entfernten Wrapper um den Tools CFC:

    // Application.cfc
    public boolean function onApplicationStart() {
        application.cfbrews_dsn = this.datasource;
    
        // Initialize Native ColdFusion MCP Server
        try {
            var mcpConfig = {
                "serverInfo": { "name": "BrewMaster-Tools", "version": "1.0.0" },
                "capabilities": { "tools": true },
                "tools": [ { "cfc": "api.v1.tools.NativeBrewMasterTools" } ]
            };
            application.mcpServer = MCPServer(mcpConfig);
        } catch (any e) {
            writeLog(file="cfbrews_error", text="MCP Init Error: " & e.message);
        }
        return true;
    }
    

    Der Endpunkt api/v1/agent/mcp-server.cfm leitet Anfragen an die Laufzeitumgebung weiter:

    <cfscript>
        if (structKeyExists(application, "mcpServer")) {
            application.mcpServer.handleRequest();
        } else {
            cfheader(statusCode=503);
            writeOutput(serializeJson({ "error": "MCP Server not initialized" }));
        }
    </cfscript>
    

    NL2SQL mit PSVs

    Ein zweiter Assistent, der Database Operations Assistant bei /api/v1/ops/natural-query.cfm, leitet die generierten SQL-Anfragen über parametrisierte, sichere Ansichten weiter. PSVs verhindern Einflussnahme durch Eingabefälschung; SQL Gemini erzeugt und setzt ein Zero-Trust-Konzept um, sodass nur die von dem verbundenen Benutzer einsehbaren Datensätze zurückgegeben werden. Im Hintergrund ruft natural-query.cfm AlloyDBs in der Datenbank vorhandene Funktion ai.generate() auf, um englische Anfragen in eine ausschließlich zum Lesen geeignete SELECT-Anfrage gegen diese Ansichten umzuwandeln:

    -- Enforcing tenant/scope boundaries at the database layer
    CREATE OR REPLACE VIEW brews.secure_vatsensorreadings AS
    SELECT r.*
    FROM brews.vatsensorreadings r
    JOIN brews.vats v ON r.vat_id = v.vat_id
    WHERE CURRENT_USER = 'postgres'
       OR v.name IN ('Vat A', 'Vat B');
    

    ColdFusion führt die Abfrage gegen die Ansicht aus und verwendet anschließend Gemini über ChatModel(), um die JSON-Spalten in verständliche Prosa zusammenzufassen.

    Warum hier die Aufrufung einer Tool-Plattform besser ist als ein statischer Chatbot

    Ein Dashboard kann die Temperatur des Gärbottichs anzeigen. Ein statischer Chatbot kann erklären, was ABV bedeutet. Keiner von beiden kann auf der Grundlage einer freien Frage entscheiden, dass vor Beginn einer Charge das Lager überprüft werden muss, diese Überprüfung in AlloyDB durchführen und mit den fehlenden Kilogramm Hoppen antworten. Die Aufrufung einer Tool-Plattform liefert dem Modell eine kurze Liste zuverlässiger Aktionen und behält die SQL-Anfragen sowie Geschäftsregeln in den ColdFusion-Komponenten bei, die Sie bereits überprüft und getestet haben.

    MCP erweitert diese gleiche Schnittstelle auf andere Clients. Sobald BrewMasterTools als MCP-Server registriert ist, kann ein externer Agent dieselben Tools für Inventarverwaltung, Rezeptverwaltung und Risikomanagement ohne eine individuelle Integration pro Client nutzen. Darin besteht der Sinn des Protokolls: Eine einzige Tool-Schnittstelle, viele Nutzer.

    Zusammenfassung der Serie

    In insgesamt fünf Artikeln wurden folgende Themen behandelt:

    1. Berechnung und Laufzeit: Cloud Run für Skalierung auf Null sowie schnelles Starten.
    2. Operative Datenbank: AlloyDB mit kolonialer Caching-Technologie und Vektorabfrage.
    3. Analytische Skalierung: BigQuery GQL in Kombination mit Simba JDBC sowie passwordlosem IAM.
    4. Maschinelles Lernen: Echtzeit-Prognosen von Batch-Fehlern mithilfe von Vertex AI.
    5. Agentenbasierte Workflows: MCP-Hosting, sicheres NL2SQL mit PSVs sowie autonome Tool-Ausführung.

    Quellen

    • Backend-Repository
    • Frontend-Repository