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.
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:
- 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.
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:
- 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.
- Ejecución: ColdFusion analiza el JSON e invoca el método CFC contra AlloyDB.
- 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:
- Procesamiento y tiempo de ejecución: Cloud Run para escalado a cero y arranque rápido.
- Banco de datos operativo: caché columnar y búsqueda vectorial en AlloyDB.
- Escala analítica: BigQuery GQL con Simba JDBC e IAM sin contraseñas.
- Aprendizaje automático: predicciones en tiempo real de fallos por lotes mediante Vertex AI.
- 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
- Notas prácticas: Protocolo de Contexto de Modelo (MCP) explicado: Guía para principiantes — Guía paso a paso de las Notas prácticas: Protocolo de Contexto de Modelo (MCP) explicado: Guía para principiantes: contratos, verificaciones y espacios para código reutilizable para equipos que implementan este patrón.
- Rastreo de una tubería de blog de LangGraph con Langfuse: intervalos, puntuaciones y advertencias — Instrumentación de una tubería multi-agente de LangGraph con Langfuse: un rastreo por artículo, intervalos anidados, advertencias, puntuaciones y una rutina de depuración para borradores deficientes.