Inicio / Artículos

Creación de agentes autónomos de IA con ColdFusion y MCP (Parte 5)

Agentes de IA de ColdFusion con llamadas a la herramienta Gemini, un punto de extremo del servidor MCP y vistas seguras de AlloyDB para NL2SQL, mostrados en una demostración de operaciones de cervecería en Google Cloud.

Editor: REACTAPP.TOP6 min de lectura1358 palabras

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

Modernizando ColdFusion en Google Cloud - Parte 5 de 5

Los artículos anteriores de esta serie mostraron cómo las aplicaciones Adobe ColdFusion pueden utilizar servicios nativos de Google Cloud:

  • Parte 1: pasar de una VM gestionada a Cloud Run, automatizar las compilaciones con Cloud Build y proteger el acceso con IAM Workload Identity.
  • Parte 2: AlloyDB para PostgreSQL para operaciones ACID de alto rendimiento junto con embeddings vectoriales para búsquedas semánticas.
  • Parte 3: JDBC sin contraseñas hacia BigQuery y GQL para gráficos de propiedades al estilo Customer360.
  • Parte 4: Predicciones de Vertex AI AutoML con datos por lotes en tiempo real (en la demostración de cervecería, la fermentación de la cerveza).

Esta parte proporciona a la cervecería un “cerebro”: agentes autónomos que razonan, consultan el estado en tiempo real, evalúan riesgos de lotes y exponen herramientas como un servidor MCP.

ColdFusion con agentes

Las primeras funciones de la IA solían requerir que el usuario escribiera una instrucción, la aplicación la enviara a un LLM y la respuesta proviniera únicamente de los pesos de entrenamiento. Eso funciona bien con texto, pero no puede responder a preguntas operativas como:

  • ¿Cuál es la temperatura y presión actuales en un tanque específico?
  • ¿Cuánto malta pálida se ha consumido en los últimos 30 minutos?
  • ¿Puede el almacén cubrir las lúpulas Citra necesarias para producir una IPA Citra Sunset de cincuenta barriles?

Un flujo de trabajo basado en agentes separa el razonamiento de la recuperación de datos. El modelo actúa como orquestador: lee la intención, elige herramientas o consultas, examina los resultados y sintetiza una respuesta basada en hechos.

CF-Brews explora dos patrones complementarios:

  1. Orquestación de herramientas nativas de ColdFusion y MCP: exponer un CFC (BrewMasterTools.cfc) a Gemini para una ruta de herramientas determinista y consultas a AlloyDB.
  • Secure NL2SQL: traduce las consultas a SQL y luego restringe su ejecución mediante vistas seguras parametrizadas de AlloyDB (PSV).
  • Llamada a herramientas nativas

    Las reglas de negocio se encuentran en un CFC. En api/v1/tools/BrewMasterTools.cfc las operaciones principales son:

    • checkInventory(recipeName, volumeGallons): verifica si el stock del almacén satisface las necesidades de la receta.
    • getRecipeDetails(recipeName): indica el grado alcohólico deseado, los umbrales de temperatura y las proporciones de ingredientes.
    • checkBatchRisk(style): examina los tanques de fermentación activos y emite alertas ante cambios en la temperatura o presión.

    checkInventory combina recetas, ingredientes e inventario, escala las cantidades según el volumen y informa qué falta:

    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;
       }
    }
    

    Orquestación determinística de herramientas

    ChatModel() de ColdFusion impulsa un bucle de tres pasos con Gemini:

    1. Enrutamiento de intenciones: la solicitud se envía junto con instrucciones del sistema que enumeran las herramientas. Gemini devuelve JSON estructurado si se necesita realizar alguna acción.
    2. Ejecución: ColdFusion analiza el JSON e invoca el método CFC contra AlloyDB.
    3. Síntesis: la salida de la herramienta vuelve a ChatModel() para obtener una respuesta en lenguaje natural coherente.
    <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>
    

    Límites de JSON

    Modelos como Gemini pueden restringir el muestreo a un esquema JSON para que no emitan caracteres que dañen la estructura. El código de producción aún debe tratar la salida como algo propenso a errores:

    • Rodee deserializeJson() con try/catch.
    • Establezca la temperatura en 0.0 para una selección de herramientas más determinista.
    • En caso de fallo en la deserialización o incoherencias de tipo, capture la excepción y pida al modelo que intente nuevamente o devuelva una solución alternativa clara al usuario.

    ColdFusion como servidor MCP

    El Protocolo de Contexto de Modelos, de código abierto desarrollado por Anthropic, es la forma común de exponer datos y herramientas a clientes de IA externos. Un cliente MCP dentro de una aplicación de IA se comunica bidireccionalmente con un servidor MCP. La actualización 8 de ColdFusion 2025 añadió MCPServer().

    Durante onApplicationStart en Application.cfc, registre un envoltorio remoto alrededor del CFC de las herramientas:

    // 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;
    }
    

    El endpoint api/v1/agent/mcp-server.cfm delega las solicitudes al entorno de ejecución:

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

    NL2SQL con PSVs

    Un segundo asistente, el Asistente de Operaciones de Bases de Datos en /api/v1/ops/natural-query.cfm, dirige el SQL generado a través de Vistas Seguras Parametrizadas. Los PSVs reducen la inyección de comandos en SQL; Gemini genera y aplica un modelo de confianza cero, de modo que las filas devueltas son únicamente aquellas que el usuario conectado puede ver. En el fondo, natural-query.cfm llama a la función ai.generate() de AlloyDB, integrada en la base de datos, para convertir el texto en inglés en una consulta SELECT de solo lectura contra esas vistas:

    -- 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 ejecuta la consulta contra la vista y luego utiliza Gemini a través de ChatModel() para resumir las filas en JSON en texto legible.

    Por qué es mejor utilizar herramientas que un chatbot estático

    Un panel de control puede mostrar la temperatura del tanque. Un chatbot estático puede explicar qué significa el ABV. Ninguno de los dos puede, a partir de una pregunta abierta, decidir que es necesario verificar el inventario antes de iniciar un lote, realizar esa verificación en AlloyDB y responder con los kilogramos faltantes de lúpulo. Al utilizar herramientas, se proporciona al modelo una lista corta de acciones confiables y se mantienen las reglas SQL y de negocio dentro de componentes de ColdFusion que ya se han revisado y probado.

    MCP extiende esa misma interfaz a otros clientes. Una vez que BrewMasterTools está registrado como servidor MCP, un agente externo puede acceder a las mismas herramientas de inventario, recetas y gestión de riesgos sin necesidad de una integración personalizada para cada cliente. Ese es el propósito del protocolo: una única interfaz de herramientas, muchos usuarios.

    Resumen de la serie

    A lo largo de cinco artículos, los temas abordados fueron:

    1. Procesamiento y tiempo de ejecución: Cloud Run para escalado a cero y arranque rápido.
    2. Banco de datos operativo: caché columnar y búsqueda vectorial en AlloyDB.
    3. Escala analítica: BigQuery GQL con Simba JDBC e IAM sin contraseñas.
    4. Aprendizaje automático: predicciones en tiempo real de fallos por lotes mediante Vertex AI.
    5. Flujos de trabajo basados en agentes: alojamiento MCP, NL2SQL seguro con PSVs y ejecución autónoma de herramientas.

    Fuentes

    • Repositorio de backend
    • Repositorio de frontend

    Lecturas relacionadas