Guide · RabbitMQ

RabbitMQ pour les agents IA : patterns, mise en place et pièges

Les agents IA passent l'essentiel de leur temps à attendre des API de modèles et des outils lents, soumis à des limites de débit et parfois indisponibles. RabbitMQ gère très bien ce type de travail : il conserve les tâches de façon durable, les distribue à autant de workers que la limite de débit le permet, relance ce qui échoue et met de côté ce qui n'aboutira jamais. Ce guide présente les patterns dans l'ordre où vous les mettez en place, avec un worker de départ et les pièges qui apparaissent en production. Le comportement du broker est tiré de la documentation de RabbitMQ 4.3, vérifiée le 10 octobre 2026.

Tyler Eastridge

Par Tyler Eastridge, Directeur des opérations

LinkedIn · Mis à jour le · Lecture : 12 min · 10 sections

Sur cette page

RabbitMQ pour les agents en un paragraphe

RabbitMQ pour les agents en un paragraphe

Placez chaque tâche LLM ou d'outil sur une quorum queue sous forme de message persistant doté d'un identifiant unique, publié avec confirmations. Faites tourner des consommateurs concurrents avec un prefetch de 1 et des acquittements manuels, dimensionnés selon la limite de débit du fournisseur plutôt que selon la demande. Définissez une limite de livraison et un dead letter exchange pour qu'un prompt empoisonné échoue quelques fois puis s'arrête. Routez par intention ou compétence via un topic exchange, utilisez reply-to et des identifiants de corrélation pour les appels d'outils, et conservez un stream pour le rejeu. Rendez les handlers idempotents, plafonnez la longueur des files d'attente, transmettez des références plutôt que des charges volumineuses, et dimensionnez le timeout consommateur sur l'appel légitime le plus lent.

Pourquoi les agents ont besoin d'un broker

Une boucle d'agent passe surtout son temps à attendre. Un appel au modèle prend des secondes ou des minutes, un outil tombe en timeout, et le fournisseur vous bride dès que le trafic grimpe. Les appels en ligne lient chaque appelant à la dépendance la plus lente. Un broker rompt ce couplage : l'appelant publie une tâche et passe à la suite, et les workers la prennent quand ils ont de la capacité.

Ce seul changement apporte tout le reste. Les appels en échec sont relancés par nouvelle livraison, pas par des boucles écrites à la main. La contre-pression prend la forme d'une file d'attente qui grossit, pas d'un pool de threads qui s'effondre. Le fan-out vers plusieurs outils tient en une seule publication. Une tâche survit au crash d'un worker parce qu'elle n'a jamais été acquittée. Et une étape de validation humaine devient une file d'attente consommée par l'outil d'un relecteur : le plan attend sans maintenir un processus ouvert.

Exécuter les tâches LLM comme une file de travail

La forme de base est la file de travail des tutoriels RabbitMQ : une file d'attente, de nombreux consommateurs concurrents, chaque message livré à l'un d'eux. Deux réglages la rendent sûre pour les appels au modèle. Utilisez les acquittements manuels, car en mode automatique RabbitMQ considère un message comme livré dès son envoi, et un worker qui plante en plein appel le perd. Et réglez le prefetch à 1. La documentation qualifie un prefetch de 1 de valeur la plus conservatrice et prévient qu'il pénalise le débit : c'est le bon compromis quand chaque message est un appel long et facturé plutôt qu'une écriture rapide en base.

Le nombre de consommateurs devient alors votre limite de concurrence. Si le fournisseur autorise 50 requêtes simultanées, faites tourner 50 consommateurs avec un prefetch de 1 et laissez la file d'attente absorber le reste. Le débit devient une décision de capacité prise délibérément plutôt qu'un effet secondaire d'un pic de trafic, ce qui en fait l'un des leviers de maîtrise des coûts les plus simples.

Rendre les tâches d'agents durables avec les quorum queues

Une demande client, un plan en plusieurs étapes ou une validation en attente doivent survivre à la défaillance d'un nœud. Déclarez ces files d'attente comme quorum queues (x-queue-type défini à quorum), publiez les messages en persistant et activez les publisher confirms pour que le producteur sache que le broker détient la tâche avant de la signaler comme mise en file. Les quorum queues sont toujours durables et répliquées, et elles offrent les deux fonctionnalités sur lesquelles le travail des agents s'appuie le plus : une limite de livraison, fixée par défaut à 20 depuis RabbitMQ 4.0, et un mode de dead-lettering at-least-once. Elles ne prennent pas en charge la QoS globale : réglez donc le prefetch par consommateur.

Arrêter les prompts empoisonnés avec une limite de livraison et une dead-letter queue (DLQ)

Certaines entrées n'aboutiront jamais : un prompt que le modèle refuse, un document que le parseur ne sait pas lire, un appel d'outil dont les arguments échouent à la validation. Remis en file indéfiniment, ils tournent en boucle et brûlent des tokens. Une quorum queue compte les livraisons en échec dans l'en-tête x-delivery-count et, une fois la limite de livraison dépassée, supprime le message, ou le passe en dead-letter si un dead letter exchange est configuré. Pour des appels au modèle facturés, la valeur par défaut de 20 est généreuse ; une limite de 3 à 5 borne le coût d'une mauvaise entrée.

Associez la file d'attente à un dead letter exchange et liez derrière lui une file lue par une personne ou un agent de tri. RabbitMQ ajoute un en-tête x-death qui enregistre la file source, le motif et le compteur : la dead-letter queue (DLQ) explique ainsi pourquoi chaque tâche y a atterri. Quand un worker sait déjà qu'une nouvelle tentative est inutile, il doit rejeter le message avec requeue à false pour l'y envoyer directement.

Un worker de départ

Le worker ci-dessous utilise aio-pika, le client asyncio pour Python, afin que la connexion reste servie pendant l'attente d'un appel au modèle ; la documentation de pika elle-même prévient qu'un callback de longue durée peut faire tomber la connexion par timeout de heartbeat. Il consomme une quorum queue avec une limite de livraison de 5, prend un message à la fois, ignore les doublons par identifiant de message, temporise avant de rendre une tâche soumise à la limite de débit, et rejette directement vers le dead letter exchange tout ce qui ne peut pas aboutir. run_agent_step, already_done et save_result représentent votre propre code.

import asyncio
import json
import aio_pika

class Transient(Exception):
    """Rate limit, timeout or 5xx from the model or a tool: worth retrying."""

async def handle(msg):
    key = msg.message_id                    # stable per task, set by the publisher
    if await already_done(key):             # duplicate delivery: do not repeat the work
        await msg.ack()
        return
    try:
        job = json.loads(msg.body)
        result = await run_agent_step(job)  # the slow model or tool call
        await save_result(key, result)      # record the outcome before acknowledging
        await msg.ack()
    except Transient:
        attempt = int((msg.headers or {}).get("x-delivery-count", 0))
        await asyncio.sleep(min(2 ** attempt, 60))  # back off before handing it back
        await msg.nack(requeue=True)        # counts toward the delivery limit
    except Exception:
        await msg.reject(requeue=False)     # cannot succeed: straight to the DLX

async def main():
    conn = await aio_pika.connect_robust("amqps://agent-worker:PASSWORD@broker.example.com/agents")
    ch = await conn.channel()
    await ch.set_qos(prefetch_count=1)      # one job in flight per worker

    dlx = await ch.declare_exchange("agents.dlx", aio_pika.ExchangeType.FANOUT, durable=True)
    dead = await ch.declare_queue("llm-jobs.dead", durable=True,
                                  arguments={"x-queue-type": "quorum"})
    await dead.bind(dlx)

    jobs = await ch.declare_queue("llm-jobs", durable=True, arguments={
        "x-queue-type": "quorum",
        "x-delivery-limit": 5,
        "x-dead-letter-exchange": "agents.dlx",
    })
    async with jobs.iterator() as messages:
        async for msg in messages:
            await handle(msg)

asyncio.run(main())

Le producteur définit l'identifiant de message dont dépend le contrôle d'idempotence, marque le message comme persistant et lui donne une expiration (aio-pika convertit un timedelta en millisecondes, l'unité du protocole, et ses canaux ont les publisher confirms activés par défaut).

from datetime import timedelta

await ch.default_exchange.publish(
    aio_pika.Message(
        json.dumps(job).encode(),
        message_id=job["task_id"],                  # idempotency key
        delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
        expiration=timedelta(minutes=2),            # stale after two minutes
    ),
    routing_key="llm-jobs",
)

Les arguments de file sont déclarés en ligne pour que l'exemple fonctionne seul. En production, définissez delivery-limit et dead-letter-exchange par policy : la documentation recommande les policies car elles se modifient sans redéployer les applications.

Objectifs de réponse à partir de 15 minutes, selon le plan. Ingénieurs seniors attitrés.

Nous contacter

Appels d'outils et routage : reply-to et topic exchanges

Quand un agent appelle un outil via le broker et attend la réponse, utilisez le pattern requête-réponse du tutoriel RPC de RabbitMQ : définissez reply_to sur une file de retour et correlation_id sur une valeur unique par requête, et faites publier par l'outil son résultat dans cette file avec le même identifiant. Ignorez les réponses dont vous ne reconnaissez pas l'identifiant de corrélation. Le direct reply-to (amq.rabbitmq.reply-to) évite de déclarer une file pour les appels interactifs courts, mais ses réponses ne sont pas stockées et sont perdues si le demandeur se déconnecte : tout ce que vous ne pouvez pas vous permettre de perdre exige une file de réponse durable.

Pour atteindre le bon agent ou le bon outil, publiez sur un topic exchange avec une clé de routage construite à partir de l'intention et de la compétence, par exemple agent.billing.refund ou tool.search.web. Dans un binding, * correspond à exactement un mot et # à zéro ou plusieurs : les spécialistes lient des clés précises tandis qu'un consommateur d'audit lie agent.#. Un message part vers chaque file dont le binding correspond, et c'est ainsi qu'une seule publication se diffuse en fan-out vers plusieurs outils. Les clés de routage sont limitées à 255 octets.

Priorités, requêtes périmées et appels au modèle longs

Dans RabbitMQ 4.3, les quorum queues prennent en charge des priorités strictes sur 32 niveaux (0 à 31), sans activation préalable ; les files classiques utilisent x-max-priority, idéalement avec un petit nombre de niveaux, inférieur à dix. Publiez les requêtes utilisateur au-dessus des synthèses nocturnes, et les workers les traiteront en premier.

Une requête que plus personne n'attend, c'est de la dépense perdue. Donnez-lui un TTL par message avec la propriété expiration, de sorte qu'un tour de chat non démarré sous, par exemple, deux minutes expire au lieu de s'exécuter. Les messages expirés ne sont supprimés, ou passés en dead-letter, qu'une fois arrivés en tête de file : un backlog profond les retient donc jusqu'à ce que les consommateurs les atteignent.

Reste le timeout consommateur. RabbitMQ ferme un canal avec une erreur PRECONDITION_FAILED lorsqu'une livraison n'est pas acquittée sous 30 minutes par défaut, et remet en file toutes les livraisons de ce canal. Une longue exécution d'agent peut atteindre cette limite. Depuis RabbitMQ 3.12, le timeout se règle par file d'attente, avec la clé de policy consumer-timeout ou l'argument x-consumer-timeout en millisecondes : relevez-le uniquement sur les files qui portent des tâches longues, avec une marge au-dessus de l'exécution légitime la plus lente.

Streams pour le rejeu et la mémoire des agents

Une file d'attente oublie un message dès qu'il est acquitté. Les agents ont souvent besoin de l'inverse : un historique de chaque événement produit par un workflow, qu'un nouvel agent peut lire depuis le début ou qu'un débogueur peut rejouer à partir d'un instant donné. C'est le rôle d'un stream RabbitMQ, un journal répliqué en ajout seul (append-only), lu sans retirer les messages. Liez un stream à l'exchange sur lequel vos agents publient déjà, réglez la rétention avec max-age ou max-length-bytes, et laissez chaque lecteur choisir son point de départ avec x-stream-offset : first, last, next, un offset, un horodatage ou un intervalle. Les streams ne prennent en charge ni le dead-lettering ni le TTL : gardez le travail sur des quorum queues et l'historique dans le stream.

Frameworks et MCP

Pour les équipes Python, Celery est la voie la plus directe : RabbitMQ est son broker par défaut, et définir task_default_queue_type à quorum bascule la file par défaut sur les quorum queues. Par défaut, Celery acquitte une tâche juste avant de l'exécuter ; acks_late l'acquitte après, si bien qu'un crash en cours de tâche la fait réexécuter, d'où l'exigence de tâches idempotentes dans la documentation de Celery.

LangGraph, CrewAI et AutoGen orchestrent l'agent lui-même, et le broker s'articule autour : un worker prend une tâche dans une file et invoque le graphe ou la crew. LangGraph conserve l'état du graphe dans un checkpointer indexé par un thread_id (sa documentation cite des savers en mémoire, SQLite et Postgres) : transmettez l'identifiant de thread dans le message, et une tâche relivrée pourra reprendre depuis le dernier checkpoint. Les crews CrewAI démarrent avec kickoff() ou ses variantes asynchrones. Le runtime distribué d'AutoGen utilise gRPC et est marqué expérimental. Dans chaque cas, RabbitMQ achemine le travail entre services ; il ne remplace pas le runtime du framework.

MCP, le Model Context Protocol, est un standard ouvert pour connecter des applications d'IA à des outils et données externes, avec stdio et Streamable HTTP comme transports standard. Il existe des serveurs MCP communautaires pour RabbitMQ, qui encapsulent généralement l'API de management et AMQP pour qu'un assistant puisse inspecter des files ou publier. Attribuez à chacun son propre utilisateur RabbitMQ avec les permissions les plus restreintes possibles, car il agit avec tous les accès dont il dispose.

Les pièges qui apparaissent en production

  • Des files sans limite quand l'API du modèle bride. Dès que le fournisseur renvoie des erreurs de limite de débit, les consommateurs ralentissent et la file grossit jusqu'à ce qu'une alarme mémoire ou une alarme disque bloque toutes les connexions de publication du nœud. Plafonnez les files qui reçoivent le trafic utilisateur avec max-length et le débordement reject-publish : un producteur utilisant les confirmations reçoit alors un basic.nack et peut inviter l'utilisateur à réessayer. Le débordement par défaut, drop-head, supprime le message le plus ancien, ou le passe en dead-letter si un dead letter exchange est défini.
  • Des exécutions longues qui atteignent le timeout consommateur. Dimensionnez consumer-timeout par file, gardez le prefetch à 1 pour le travail lent et acquittez sur chaque chemin de code, y compris en cas d'erreur.
  • Des charges volumineuses. La taille maximale de message par défaut est de 16 Mio (max_message_size, configurable jusqu'à 512 Mio) ; au-delà, les messages sont rejetés. Stockez documents, images et lots d'embeddings dans un stockage objet ou une base vectorielle, et placez une référence dans le message.
  • Des hypothèses sur l'ordre. Une file conserve l'ordre de publication, mais avec plusieurs consommateurs et des remises en file, chaque consommateur peut recevoir les messages dans le désordre. Pour un ordre strict par conversation, utilisez une file avec un seul consommateur actif, ou transmettez un numéro de séquence.
  • Des nouvelles tentatives qui répètent les effets de bord. La livraison est at-least-once : un worker peut terminer le travail et planter avant d'acquitter, et le message revient avec le flag redelivered. Indexez chaque effet de bord (un e-mail envoyé, un ticket ouvert, un remboursement émis) sur l'identifiant de message de la tâche et vérifiez-le d'abord, comme le fait le worker ci-dessus.

Questions fréquentes

Peut-on utiliser RabbitMQ pour des agents IA ?

Oui. Les workers consomment les tâches LLM et d'outils avec des acquittements manuels, les quorum queues rendent les tâches durables, les limites de livraison et les dead letter exchanges arrêtent les prompts empoisonnés, les topic exchanges routent par compétence et les streams conservent un historique rejouable.

Quelle file d'attente de messages choisir pour des agents IA ?

Cela dépend de la charge de travail. La distribution de tâches avec nouvelles tentatives, priorités et acquittement par tâche convient à un broker de files comme RabbitMQ ; les flux d'événements à fort volume rejoués par de nombreux consommateurs conviennent à un journal, comme Kafka ou les streams RabbitMQ.

Comment éviter que les appels LLM longs atteignent le timeout consommateur de RabbitMQ ?

Le timeout par défaut est de 30 minutes. À partir de RabbitMQ 3.12, définissez consumer-timeout par policy, ou x-consumer-timeout comme argument de file, sur les files qui portent des tâches longues, gardez le prefetch à 1 et acquittez sur chaque chemin de code.

LangChain ou LangGraph fonctionnent-ils avec RabbitMQ ?

Ils s'utilisent ensemble, RabbitMQ servant de couche de tâches autour du graphe. Un worker consomme une tâche et invoque le graphe, tandis que le checkpointer de LangGraph, en mémoire, SQLite ou Postgres selon sa documentation, conserve l'état du graphe sous un thread_id transmis dans le message.

Comment un agent IA doit-il gérer les messages RabbitMQ en double ?

Partez du principe d'une livraison at-least-once. Attribuez à chaque tâche un identifiant de message stable, enregistrez les identifiants traités avec le résultat, et ignorez toute livraison dont l'identifiant est déjà enregistré avant de répéter un effet de bord.

Consultation gratuite

Un regard expert sur votre cluster RabbitMQ

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire