Gérer les charges de travail d’IA sur Fastly Compute n’est pas seulement possible : c’est une réalité hautement efficace, grâce à la faible latence de la périphérie et l’isolation stricte de notre environnement. Dans cet article, nous allons nous intéresser à plusieurs modèles pour ajouter des fonctionnalités d’agent à vos services Fastly Compute en utilisant les API LLM. Nous expliquerons aussi comment notre plateforme Compute, exécutant du code dans des bacs à sable WebAssembly, s’assure que votre agent fonctionne avec une vitesse optimale et une sécurité de niveau entreprise.
Concevoir des boucles de rétroaction pour un agent d’IA
Ce gif animé montre un assistant d’IA récemment lancé sur le panneau de contrôle de Fastly. Lorsque vous soumettez une invite à un chat basé sur l’IA comme celui-ci, vous avez sans doute l’habitude d’attendre que l’agent d’IA « réfléchisse ». Plutôt que de s’appuyer sur le calcul au moment du test (TTC) du modèle lui-même, où le modèle « réfléchit » plus profondément avant de fournir une réponse, vous pouvez implémenter ce type de processus de réflexion en concevant un agent qui utilise les résultats des appels d’API LLM comme retour pour atteindre un objectif. Cette méthode est souvent appelée une « boucle d’agent ». C’est un processus qui répète en continu une série d’étapes, telles que le raisonnement, la planification, l’utilisation d’outils et l’observation des résultats, jusqu’à ce que l’objectif soit atteint.
Le flux d’exécution de cette boucle de rétroaction est illustré ci-dessous. Bien que souvent, un seul échange où un LLM génère immédiatement une réponse à une invite ne puisse pas donner la réponse souhaitée, ce mécanisme permet à l’agent de poursuivre de manière autonome la boucle d’exécution et d’évaluation répétées des étapes (1) à (3), améliorant ainsi la précision et livrant le résultat final.
Cette boucle peut être déployée dans divers environnements, de l’infrastructure locale aux serveurs distants. Examinons le flux de traitement dans un environnement distant en utilisant Fastly Compute via une mise en œuvre minimale. Par exemple, le SDK JavaScript de Fastly Compute permet cette mise en œuvre, comme illustré ci-dessous. Notez que ce code peut être validé en initialisant un Starter Kit TypeScript avec $npx fastly compute init, en remplaçant src/index.ts par le code suivant ;
addEventListener("fetch", (event) => event.respondWith(handleRequest(event)));
async function handleRequest(event: FetchEvent) {
let payload = {
model: 'gpt-5.2',
messages: [{role: "user", content: "what's the weather today?"}],
tools: [{ "type": "function", "function": {
"name": "get_weather",
"description": "retrieve weather forecast",
"parameters": {}}}]}
while(true){ // Agent loop begins
let res = await (await fetch("https://<LLM_API_ENDPOINT>/chat/completion", {
method: "POST",
headers: new Headers({
"Content-Type": "application/json",
"Authorization" : "Bearer <YOUR_ACCESS_TOKEN>",
}),
body: JSON.stringify(payload)
})).json();
if (res.choices[0].finish_reason != "tool_calls") {
return new Response(JSON.parse(res.choices[0].message.content))
}
if (res.choices[0].message.tool_calls != undefined) {
for (const toolCall of res.choices[0].message.tool_calls ) {
if (toolCall.type === "function") {
payload.messages.push({
role: "user",
content: "{\"weather\":\"windy and rainy\"}" // pseudo result
});
}
}
}
}
}
L'exécution de ce code suit ce flux de haut niveau :
Soumettez l’invite « what’s the weather today? » à l’API LLM.
L’API LLM renvoie une instruction pour exécuter l’outil
get_weather.Ajoutez une valeur fictive
« windy and rainy »comme résultat provisoire à l’invite et relancez l’API LLM (boucle d’agent).Vous recevez un signal d’achèvement de l’API LLM (« stop » est renvoyé en tant que valeur
finish_reason) et le résultat final s’affiche.
Exécution de ce programme dans mon environnement de laboratoire en utilisant GPT-5.2. Le modèle a donné le résultat suivant pour l’étape 4 :
« Il y a du vent et il pleut aujourd’hui. Si vous sortez, prenez un imperméable et un parapluie, et surveillez les routes glissantes et les fortes rafales. Vous souhaitez un détail horaire ou des conseils pour vos trajets domicile-travail ou vos activités de plein air ? »
Le résultat dérivé de cette boucle d’agent itérative illustre la boucle de rétroaction évoquée précédemment : une technique de traitement fréquemment utilisée derrière la réflexion dans les interfaces de chat modernes.
La Boucle de l'Agent en Constante Évolution
Les boucles d’agents attirent l’attention depuis un certain temps, mais cette année, l’émergence d’interfaces d’outils externes tels que MCP (par exemple, le serveur MCP de Fastly) et les appels d’outils les ont considérablement renforcées. Cette évolution est simplifiée dans le schéma ci-dessous.
Vous trouverez ici un exemple concret de traitement de code Compute comprenant des appels d’outils à distance. Dans cet exemple, nous utilisons l’API de réponses d’OpenAI (annoncée en mai) comme exemple. Elle permet des appels d’outils à distance, bien que des opérations similaires soient possibles avec l’API de messages d’Anthropic et d’autres. Vous pouvez exécuter ce code en suivant les étapes ci-dessous. En environ 60 lignes de code JavaScript, nous résumons les bonnes pratiques pour migrer les services Fastly VCL vers Compute en fonction des résultats de recherche de documents, générant un fichier PowerPoint modifiable (et non un fichier pdf).
$ mkdir compute-agent-demo && cd compute-agent-demo
$ npx fastly compute init -l javascript -i
$ npm install pptxgenjs openai hono @fastly/hono-fastly-compute abortcontroller-polyfill
$ curl -s "https://gist.githubusercontent.com/remore/25a1638a3a2183daa609044cfa1ce6f9/raw/818322d634d59c10950878932517c4173b746dd3/index.js" > src/index.js
$ vi src/index.js # Put your API Token and rmeote MCP server address
$ fastly compute serveVoici un exemple du fichier PowerPoint généré. En tirant parti de la capacité du LLM à résumer des informations et à générer du code, nous sommes maintenant en mesure de générer un fichier binaire PowerPoint éditable (.pptx) avec un contenu persuasif qui répond à l’objectif.
La différence majeure entre cet exemple de code et le précédent est qu’il n’y a pas d’instruction while () dans le programme. Cette fois, puisque la boucle de l’agent d’IA est exécutée du côté de l’API LLM, le code Compute (agissant en tant qu’agent) n’implémente pas de boucle while(). Cela améliore la lisibilité du programme et démontre comment les avancées récentes ont favorisé un environnement où les flux de travail d’IA sont considérablement plus faciles à mettre en œuvre.
const bestPractices = await callLLM(
'What are the best practices to migrate a fastly vcl service to compute? Outline ten practices and give each a summary of at least 300 characters.',
[{
"type": "mcp",
"server_label": "fastly-doc-search",
"server_url": "https://xxxxxxx.edgecompute.app/mcp",
"require_approval": "never",
}]
)
Nous avons également implémenté cette démo en l’intégrant à un serveur MCP distant fonctionnant sur Compute sous le domaine edgecompute.app lors de l’invocation de la fonction callLLM(), comme indiqué dans le code ci-dessus. Bien que tout serveur MCP distant soit compatible, j’ai utilisé un serveur MCP implémenté sur Fastly Compute pour profiter de la plateforme serverless en périphérie, toujours invoquée depuis le data center le plus proche de l’API LLM. Cela minimise la latence pour les appels aux outils, contribuant ainsi à optimiser le temps de chargement du premier jeton (TTFT). Les capacités de Fastly Compute, y compris l’exécution en périphérie à faible latence et la prise en charge de la diffusion des réponses, fournissent un puissant soutien pour le développement de votre agent d’IA. Pour plus de détails sur la mise en œuvre d’un serveur MCP utilisant Compute, veuillez consulter mon précédent blog.
Comment la plateforme Fastly et le sandboxing WASM sécurisent votre charge de travail d’IA
Enfin, abordons la question de la sécurité, qui est essentielle pour une IA digne de confiance. La détermination des autorisations à accorder aux agents d’IA et la manière de les gérer ont constitué une préoccupation majeure pour les développeurs. Bien que les discussions portent souvent sur la conception de modèles permissifs pour accélérer le développement lors de l’utilisation d’agents de codage tels que Claude Code, Gemini CLI et Codex, la conception de flux de travail d’IA d’entreprise nécessite une perspective sur la conception des permissions restrictives.
En utilisant Fastly Compute, les programmes bénéficient facilement des avantages de l’isolation en bac à sable de l’exécution WebAssembly et des fonctionnalités de sécurité mémoire telles que la vérification des limites de mémoire linéaire dans des limites de sécurité claires. Par exemple, l’exécution dynamique de code à l’aide du constructeur AsyncFunction(), tel qu’il est mis en œuvre dans l’exemple ci-dessus, est généralement considérée comme un risque de vulnérabilité et un anti-modèle dans de nombreuses exécutions JavaScript. Bien qu’elle nécessite une utilisation avec précaution même dans Fastly Compute, la plateforme fonctionne dans un environnement WebAssembly isolé qui manque intrinsèquement d’accès au système de fichiers, d’E/S réseau ou de capacités d’exécution de commandes externes, permettant à l’agent d’effectuer un traitement autonome avec une surface d’attaque minimisée.
Et ce n’est pas tout : les appels d’hôte enrichis fournis par la plateforme Fastly Compute incluent également diverses considérations de sécurité. Par exemple, les limites sur le nombre d’appels de récupération/envoi en back-end aident à empêcher l’émission de requêtes externes excessives. De plus, notre mécanisme Static Backend peut limiter le trafic vers des serveurs externes prédéfinis, empêchant ainsi l’agent d’effectuer des requêtes HTTP vers des serveurs externes non désirés/inconnus.
// example of dynamic backend
fetch("https://example.com/some-path")
// example of static backend, restricting traffic to pre-defined external servers
fetch("https://example.com/some-path", {backend: "example-com"})Ce mécanisme protège non seulement les flux de travail d’IA des exécutions malveillantes, mais permet également l’autorisation sélective de comportements plus larges via une fonctionnalité appelée « Dynamic Backends ». En permettant l’attribution granulaire des capacités aux programmes exécutés en tant que modules WASM au sein d’une infrastructure sécurisée, Fastly Compute simplifie la mise en œuvre de la sécurité dans les flux de travail d’IA.
Sécuriser le contrôle en s’appuyant sur des technologies et des spécifications normalisées
Dans cet article, nous avons présenté plusieurs méthodes pour implémenter efficacement les agents d’IA sur Fastly Compute. Les agents d’IA sont devenus indispensables pour générer des améliorations significatives en termes de productivité et d’efficacité opérationnelle. En utilisant Fastly Compute, un environnement de niveau entreprise qui allie performances et sécurité, vous pouvez développer des agents qui exploitent pleinement la puissance de l’IA. J’espère que cet article vous aidera à profiter d’une meilleure expérience de développement d’agents d’IA. Rejoignez la conversation sur notre forum et parlez-nous de ce que vous développez.