Création d’agents IA autonomes ColdFusion et MCP (Partie 5)
Des agents d’IA ColdFusion utilisant l’outil Gemini pour effectuer des appels, un point de terminaison de serveur MCP et des vues sécurisées AlloyDB pour NL2SQL, présentés lors d’une démonstration des opérations de brasserie sur Google Cloud.
Sources: Building Autonomous ColdFusion AI Agents & Model Context Protocol (MCP)
Moderniser ColdFusion sur Google Cloud - Partie 5 sur 5
Les articles précédents de cette série ont montré comment les applications Adobe ColdFusion peuvent utiliser les services natifs de Google Cloud :
- Partie 1 : passer d’une VM gérée à Cloud Run, automatiser les builds avec Cloud Build et sécuriser l’accès grâce à IAM Workload Identity.
- Partie 2 : AlloyDB pour PostgreSQL afin de gérer des opérations ACID à fort débit, associé à des embeddings vectoriels pour la recherche sémantique.
- Partie 3 : JDBC sans mot de passe vers BigQuery et GQL pour des graphes de propriétés similaires à ceux de Customer360.
- Partie 4 : Prédictions d’AutoML de Vertex AI sur des données par lots en temps réel (dans la démonstration de brasserie, pour la fermentation de la bière).
Cette partie fournit à la brasserie un « cerveau » : des agents autonomes capables de raisonner, d’interroger l’état en temps réel, d’évaluer les risques liés aux lots et de mettre à disposition des outils via un serveur MCP.
ColdFusion agentic
Les premières fonctionnalités d’IA exigeaient souvent que l’utilisateur tape une requête, que l’application la transmette à un LLM et que la réponse provienne uniquement des poids d’entraînement. Cela fonctionne bien pour le texte, mais cela ne permet pas de répondre à des questions opérationnelles telles que :
- Quelle est la température et la pression actuelles dans un réservoir spécifique ?
- Quelle quantité de malt pâle a été consommée au cours des 30 dernières minutes ?
- Le entrepôt peut-il fournir suffisamment de houblon Citra pour une production de Citra Sunset IPA sur cinquante fûts ?
Un flux de travail agent sépare le raisonnement de la récupération des données. Le modèle agit comme un orchestrateur : il interprète l’intention, choisit les outils ou les requêtes nécessaires, examine les résultats et synthétise une réponse basée sur des faits.
CF-Brews explore deux approches complémentaires :
- Orchestration native des outils ColdFusion et MCP : exposer un CFC (
BrewMasterTools.cfc) à Gemini afin d’assurer un routage des outils déterministe et des requêtes vers AlloyDB.
Appel d’outils natifs
Les règles métier se trouvent dans un CFC. Dans api/v1/tools/BrewMasterTools.cfc, les principales opérations sont :
checkInventory(recipeName, volumeGallons): vérifier si les stocks du entrepôt répondent aux besoins de la recette.getRecipeDetails(recipeName): taux d’alcool cible, seuils de température et proportions des ingrédients.checkBatchRisk(style): examiner les cuves en fermentation active et alerter en cas de variation de température ou de pression.
checkInventory relie les recettes, les ingrédients et les stocks, ajuste les quantités en fonction du volume et indique ce qui manque :
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;
}
}
Orchestration déterministe des outils
ChatModel() de ColdFusion pilote une boucle en trois étapes avec Gemini :
- Affectation de l’intention : la requête est envoyée accompagnée d’instructions système listant les outils. Gemini renvoie un JSON structuré si une action est nécessaire.
- Exécution : ColdFusion analyse le JSON et appelle la méthode CFC sur AlloyDB.
- Synthèse : les résultats de l’outil sont renvoyés à
ChatModel()afin d’obtenir une réponse en langage naturel cohérente.
<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>
Règles de sécurité pour JSON
Des modèles tels que Gemini peuvent limiter l’échantillonnage à un schéma JSON afin d’empêcher l’émission de caractères qui perturberaient sa structure. Le code en production doit néanmoins considérer la sortie comme pouvant contenir des erreurs :
- Enveloppez
deserializeJson()dans des blocs try/catch. - Fixez la température à 0,0 pour une sélection des outils plus déterministe.
- Lors d’une erreur de désérialisation ou d’incompatibilité de type, capturez l’exception et demandez soit au modèle de réessayer, soit renvoyez une solution de secours claire à l’utilisateur.
ColdFusion en tant que serveur MCP
Le Model Context Protocol, open source développé par Anthropic, est la méthode courante pour exposer des données et des outils aux clients IA externes. Un client MCP au sein d’une application IA communique deux-ways avec un serveur MCP. La mise à jour 8 de ColdFusion 2025 a ajouté la fonction MCPServer().
Pendant onApplicationStart dans Application.cfc, enregistrez un enveloppeur distant autour du CFC des outils :
// 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;
}
Le point de terminaison api/v1/agent/mcp-server.cfm délègue les requêtes au moteur d’exécution :
<cfscript>
if (structKeyExists(application, "mcpServer")) {
application.mcpServer.handleRequest();
} else {
cfheader(statusCode=503);
writeOutput(serializeJson({ "error": "MCP Server not initialized" }));
}
</cfscript>
NL2SQL avec les PSVs
Un deuxième assistant, l’Assistant aux opérations de base de données situé à /api/v1/ops/natural-query.cfm, dirige le SQL généré via des vues sécurisées paramétrées. Les PSVs atténuent les injections de commandes dans le SQL ; SQL Gemini génère et applique un principe de confiance zéro, de sorte que seules les lignes autorisées par l’utilisateur connecté sont affichées. En arrière-plan, natural-query.cfm appelle la fonction ai.generate() d’AlloyDB pour transformer du texte anglais en une requête SELECT en lecture seule ciblant ces vues :
-- 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 exécute la requête sur la vue, puis utilise Gemini via ChatModel() pour résumer les lignes JSON en texte lisible.
Pourquoi l’appel à une outil est préférable à un chatbot statique ici
Un tableau de bord peut afficher la température du réservoir. Un chatbot statique peut expliquer ce que signifie l’ABV. Aucun des deux ne peut, à partir d’une question libre, déterminer qu’il faut vérifier les stocks avant le début d’un lot, effectuer cette vérification dans AlloyDB et indiquer les kilogrammes manquants d’hop. L’appel à un outil fournit au modèle une courte liste d’actions fiables et conserve les requêtes SQL ainsi que les règles métier dans des composants ColdFusion que vous avez déjà examinés et testés.
MCP étend cette même interface à d’autres clients. Une fois BrewMasterTools enregistré en tant que serveur MCP, un agent externe peut découvrir les mêmes outils de gestion d’inventaire, de recettes et de risques sans avoir besoin d’une intégration personnalisée pour chaque client. C’est là l’objectif du protocole : une seule interface d’outils, de nombreux utilisateurs.
Conclusion de la série
Au cours de cinq articles, les thèmes abordés ont été :
- Calcul et exécution : Cloud Run pour une échelle nulle et un démarrage rapide.
- Base de données opérationnelle : mémoïsation colonne par colonne et recherche vectorielle d’AlloyDB.
- Échelle analytique : BigQuery GQL avec Simba JDBC et IAM sans mot de passe.
- Apprentissage automatique : prédiction en temps réel des échecs de batch via Vertex AI.
- Flux de travail agents : hébergement MCP, NL2SQL sécurisé avec PSVs et exécution autonome d’outils.
Source
- Repositoire backend
- Repositoire frontend