Leitfaden · RabbitMQ

RabbitMQ für KI-Agenten: Patterns, Setup und Fallstricke

KI-Agenten verbringen den Großteil ihrer Zeit damit, auf Modell-APIs und Tools zu warten, die langsam, ratenlimitiert und manchmal nicht erreichbar sind. Genau für diese Art von Arbeit eignet sich RabbitMQ: Es hält Tasks dauerhaft vor, verteilt sie an so viele Worker, wie das Ratenlimit zulässt, wiederholt Fehlgeschlagenes und parkt, was niemals gelingen wird. Dieser Leitfaden stellt die Patterns in der Reihenfolge vor, in der Sie sie aufbauen – mit einem Worker als Ausgangspunkt und den Fallstricken, die in Produktion auftreten. Das Broker-Verhalten basiert auf der Dokumentation zu RabbitMQ 4.3, geprüft am 10. Oktober 2026.

Tyler Eastridge

Von Tyler Eastridge, Head of Operations

LinkedIn · Aktualisiert am · 10 Min. Lesezeit · 10 Abschnitte

Auf dieser Seite

RabbitMQ für Agenten in einem Absatz

RabbitMQ für Agenten in einem Absatz

Legen Sie jeden LLM- oder Tool-Job als persistente Nachricht mit eindeutiger ID auf eine Quorum Queue und veröffentlichen Sie ihn mit Confirms. Betreiben Sie konkurrierende Consumer mit einem Prefetch von 1 und manuellen Acknowledgements – dimensioniert nach dem Ratenlimit des Anbieters, nicht nach der Nachfrage. Setzen Sie ein Delivery Limit und einen Dead-Letter-Exchange, damit ein Poison Prompt einige Male scheitert und dann stoppt. Routen Sie nach Intent oder Skill über einen Topic Exchange, nutzen Sie Reply-to und Correlation IDs für Tool-Aufrufe und halten Sie einen Stream für Replay vor. Machen Sie Handler idempotent, begrenzen Sie die Queue-Länge, übergeben Sie Referenzen statt großer Payloads und bemessen Sie den Consumer-Timeout nach dem langsamsten legitimen Aufruf.

Warum Agenten einen Broker brauchen

Eine Agenten-Schleife wartet vor allem. Ein Modellaufruf dauert Sekunden oder Minuten, ein Tool läuft in einen Timeout, und der Anbieter drosselt Sie bei Lastspitzen. Synchrone Aufrufe binden jeden Aufrufer an die langsamste Abhängigkeit. Ein Broker löst diese Kopplung: Der Aufrufer veröffentlicht einen Task und macht weiter, und Worker übernehmen ihn, sobald sie Kapazität haben.

Diese eine Änderung bringt alles Weitere mit sich. Fehlgeschlagene Aufrufe werden per Redelivery wiederholt, nicht über handgeschriebene Schleifen. Backpressure ist eine wachsende Queue statt eines zusammenbrechenden Thread-Pools. Fan-out an mehrere Tools ist ein einziger Publish. Ein Task übersteht den Absturz eines Workers, weil er nie bestätigt wurde. Und ein menschlicher Freigabeschritt ist eine Queue, aus der das Tool eines Prüfers konsumiert – der Plan wartet, ohne einen Prozess offen zu halten.

LLM-Jobs als Work Queue betreiben

Die Grundform ist die Work Queue aus den RabbitMQ-Tutorials: eine Queue, viele konkurrierende Consumer, jede Nachricht wird an genau einen davon zugestellt. Zwei Einstellungen machen das für Modellaufrufe sicher. Erstens manuelle Acknowledgements: Im automatischen Modus betrachtet RabbitMQ eine Nachricht im Moment des Versands als zugestellt, und ein Worker, der mitten im Aufruf abstürzt, verliert sie. Zweitens ein Prefetch von 1. Die Dokumentation bezeichnet einen Prefetch von 1 als den konservativsten Wert und warnt, dass er Durchsatz kostet – der richtige Kompromiss, wenn jede Nachricht ein langer, kostenpflichtiger Aufruf ist und kein schneller Datenbank-Schreibvorgang.

Die Anzahl der Consumer wird damit zu Ihrem Limit für Parallelität. Erlaubt der Anbieter 50 gleichzeitige Anfragen, betreiben Sie 50 Consumer mit einem Prefetch von 1 und lassen die Queue den Rest aufnehmen. Der Durchsatz wird so zu einer bewussten Kapazitätsentscheidung statt zum Nebeneffekt einer Lastspitze – eine der einfachsten Möglichkeiten zur Kostenkontrolle.

Agenten-Tasks mit Quorum Queues dauerhaft machen

Eine Kundenanfrage, ein mehrstufiger Plan oder eine ausstehende Freigabe sollte einen Node-Ausfall überstehen. Deklarieren Sie diese Queues als Quorum Queues (x-queue-type auf quorum gesetzt), veröffentlichen Sie die Nachrichten als persistent und aktivieren Sie Publisher Confirms, damit der Producer weiß, dass der Broker den Task hat, bevor er die Arbeit als eingereiht meldet. Quorum Queues sind immer dauerhaft und repliziert und bieten die beiden Funktionen, auf die Agenten-Workloads am stärksten angewiesen sind: ein Delivery Limit, das seit RabbitMQ 4.0 standardmäßig 20 beträgt, und einen At-least-once-Modus für Dead-Lettering. Globales QoS unterstützen sie nicht, setzen Sie den Prefetch daher pro Consumer.

Poison Prompts mit Delivery Limit und Dead-Letter-Queue (DLQ) stoppen

Manche Eingaben werden nie erfolgreich sein: ein Prompt, den das Modell verweigert, ein Dokument, das der Parser nicht lesen kann, ein Tool-Aufruf, dessen Argumente die Validierung nicht bestehen. Endlos neu eingereiht, drehen sie Schleifen und verbrennen Tokens. Eine Quorum Queue zählt fehlgeschlagene Zustellungen im Header x-delivery-count und verwirft die Nachricht, sobald das Delivery Limit überschritten ist – oder leitet sie per Dead-Lettering weiter, wenn ein Dead-Letter-Exchange konfiguriert ist. Für kostenpflichtige Modellaufrufe ist der Standardwert von 20 großzügig; ein Limit von 3 bis 5 hält die Kosten einer einzelnen fehlerhaften Eingabe begrenzt.

Verweisen Sie die Queue auf einen Dead-Letter-Exchange und binden Sie dahinter eine Queue, die ein Mensch oder ein Triage-Agent liest. RabbitMQ fügt einen x-death-Header hinzu, der Quell-Queue, Grund und Anzahl festhält – so erklärt die Dead-Letter-Queue (DLQ), warum jeder Task dort gelandet ist. Weiß ein Worker bereits, dass ein Retry sinnlos ist, sollte er die Nachricht mit requeue auf false ablehnen und sie direkt dorthin schicken.

Ein Worker als Ausgangspunkt

Der folgende Worker nutzt aio-pika, den asyncio-Client für Python, sodass die Verbindung weiter bedient wird, während auf einen Modellaufruf gewartet wird; die Dokumentation von pika selbst warnt, dass ein lang laufender Callback die Verbindung durch einen Heartbeat-Timeout trennen kann. Er konsumiert eine Quorum Queue mit einem Delivery Limit von 5, nimmt jeweils eine Nachricht, überspringt Duplikate anhand der Message ID, wartet mit Backoff, bevor er einen ratenlimitierten Job zurückgibt, und lehnt alles, was nicht gelingen kann, direkt an den Dead-Letter-Exchange ab. run_agent_step, already_done und save_result stehen für Ihren eigenen 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())

Der Publisher setzt die Message ID, auf der die Idempotenz-Prüfung beruht, markiert die Nachricht als persistent und gibt ihr ein Ablaufdatum (aio-pika wandelt ein timedelta in die vom Protokoll verwendeten Millisekunden um, und seine Channels haben Publisher Confirms standardmäßig aktiviert).

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",
)

Die Queue-Argumente stehen inline, damit das Beispiel eigenständig läuft. In Produktion setzen Sie delivery-limit und dead-letter-exchange per Policy: Die Dokumentation empfiehlt Policies, weil sie sich ändern lassen, ohne Anwendungen neu zu deployen.

Reaktionszeitziele ab 15 Minuten, je nach Plan. Namentlich zugeordnete Senior Engineers.

Kontakt

Tool-Aufrufe und Routing: Reply-to und Topic Exchanges

Ruft ein Agent über den Broker ein Tool auf und benötigt die Antwort, nutzen Sie das Request-Reply-Pattern aus dem RabbitMQ-RPC-Tutorial: Setzen Sie reply_to auf eine Callback-Queue und correlation_id auf einen eindeutigen Wert pro Anfrage, und lassen Sie das Tool sein Ergebnis mit derselben ID in diese Queue veröffentlichen. Verwerfen Sie Antworten mit unbekannter Correlation ID. Direct Reply-to (amq.rabbitmq.reply-to) erspart das Deklarieren einer Queue für kurze interaktive Aufrufe, doch die Antworten werden nicht gespeichert und gehen verloren, wenn der Anfragende die Verbindung trennt – alles, was Sie nicht verlieren dürfen, braucht eine dauerhafte Reply-Queue.

Um den richtigen Agenten oder das richtige Tool zu erreichen, veröffentlichen Sie an einen Topic Exchange mit einem Routing Key aus Intent und Skill, etwa agent.billing.refund oder tool.search.web. In einem Binding steht * für genau ein Wort und # für null oder mehr – so binden Spezialisten eng gefasste Keys, während ein Audit-Consumer agent.# bindet. Eine Nachricht geht an jede Queue mit passendem Binding; so wird aus einem Publish ein Fan-out an mehrere Tools. Routing Keys sind auf 255 Byte begrenzt.

Prioritäten, veraltete Anfragen und lange Modellaufrufe

Seit RabbitMQ 4.3 unterstützen Quorum Queues strikte Prioritäten mit 32 Stufen (0 bis 31), ohne gesonderte Aktivierung; Classic Queues verwenden x-max-priority, idealerweise mit einer niedrigen einstelligen Anzahl an Stufen. Veröffentlichen Sie nutzerseitige Anfragen mit höherer Priorität als nächtliche Zusammenfassungen, dann bedienen die Worker sie zuerst.

Eine Anfrage, auf die niemand mehr wartet, ist verschwendetes Budget. Geben Sie ihr über die Eigenschaft expiration eine TTL pro Nachricht, damit ein Chat-Turn, der nicht innerhalb von beispielsweise zwei Minuten startet, verfällt, statt ausgeführt zu werden. Abgelaufene Nachrichten werden erst entfernt oder per Dead-Lettering weitergeleitet, wenn sie den Kopf der Queue erreichen – ein tiefer Rückstau hält sie also, bis die Consumer dort ankommen.

Dann der Consumer-Timeout. RabbitMQ schließt einen Channel mit dem Fehler PRECONDITION_FAILED, wenn eine Zustellung nicht innerhalb von standardmäßig 30 Minuten bestätigt wird, und reiht alle Zustellungen dieses Channels erneut ein. Ein langer Agenten-Lauf kann dieses Limit erreichen. Seit RabbitMQ 3.12 lässt sich der Timeout pro Queue setzen, mit dem Policy-Key consumer-timeout oder dem Argument x-consumer-timeout in Millisekunden. Erhöhen Sie ihn also nur für die Queues mit langen Jobs, mit Puffer über dem langsamsten legitimen Lauf.

Streams für Replay und Agenten-Gedächtnis

Eine Queue vergisst eine Nachricht, sobald sie bestätigt ist. Agenten brauchen oft das Gegenteil: eine Aufzeichnung aller Events eines Workflows, die ein neuer Agent von Anfang an lesen oder ein Debugger ab einem Zeitpunkt erneut abspielen kann. Genau das ist ein RabbitMQ-Stream: ein replizierter Append-only-Log, der gelesen wird, ohne Nachrichten zu entfernen. Binden Sie einen Stream an den Exchange, an den Ihre Agenten bereits veröffentlichen, setzen Sie die Retention mit max-age oder max-length-bytes und lassen Sie jeden Leser seinen Startpunkt mit x-stream-offset wählen: first, last, next, ein Offset, ein Zeitstempel oder ein Intervall. Streams unterstützen weder Dead-Lettering noch TTL – halten Sie die Arbeit also auf Quorum Queues und die Historie im Stream.

Frameworks und MCP

Für Python-Teams ist Celery der direkte Weg: RabbitMQ ist der Standard-Broker, und mit task_default_queue_type auf quorum landet die Standard-Queue auf Quorum Queues. Celery bestätigt einen Task standardmäßig unmittelbar vor der Ausführung; acks_late bestätigt danach, sodass ein Absturz mitten im Task zu einer erneuten Ausführung führt – deshalb verlangt die Celery-Dokumentation idempotente Tasks.

LangGraph, CrewAI und AutoGen orchestrieren den Agenten selbst, und der Broker liegt um sie herum: Ein Worker nimmt einen Task aus einer Queue und ruft den Graph oder die Crew auf. LangGraph hält den Graph-Zustand in einem Checkpointer, der über eine thread_id adressiert wird (die Dokumentation nennt In-Memory-, SQLite- und Postgres-Saver). Transportieren Sie die Thread-ID also in der Nachricht, dann kann ein erneut zugestellter Task beim letzten Checkpoint fortfahren. CrewAI-Crews starten mit kickoff() oder dessen asynchronen Varianten. Die verteilte Runtime von AutoGen nutzt gRPC und ist als experimentell gekennzeichnet. In allen Fällen transportiert RabbitMQ Arbeit zwischen Services; die Runtime des Frameworks ersetzt es nicht.

MCP, das Model Context Protocol, ist ein offener Standard, um KI-Anwendungen mit externen Tools und Daten zu verbinden, mit stdio und Streamable HTTP als Standard-Transporten. Es gibt von der Community entwickelte MCP-Server für RabbitMQ, die meist die Management-API und AMQP kapseln, damit ein Assistent Queues inspizieren oder Nachrichten veröffentlichen kann. Geben Sie jedem davon einen eigenen RabbitMQ-User mit den engsten Berechtigungen, die funktionieren – denn er handelt mit genau den Zugriffsrechten, die er besitzt.

Fallstricke in Produktion

  • Unbegrenzte Queues, wenn die Modell-API drosselt. Sobald der Anbieter Rate-Limit-Fehler liefert, werden die Consumer langsamer, und die Queue wächst, bis ein Memory- oder Disk-Alarm jede veröffentlichende Verbindung auf dem Knoten blockiert. Begrenzen Sie Queues mit Nutzer-Traffic per max-length und dem Overflow reject-publish, damit ein Publisher mit Confirms ein basic.nack erhält und den Nutzer um einen erneuten Versuch bitten kann. Der Standard-Overflow drop-head verwirft die älteste Nachricht oder leitet sie per Dead-Lettering weiter, wenn ein Dead-Letter-Exchange gesetzt ist.
  • Lange Läufe, die in den Consumer-Timeout laufen. Bemessen Sie consumer-timeout pro Queue, halten Sie den Prefetch bei langsamer Arbeit auf 1 und bestätigen Sie auf jedem Codepfad, auch bei Fehlern.
  • Große Payloads. Die maximale Nachrichtengröße beträgt standardmäßig 16 MiB (max_message_size, konfigurierbar bis 512 MiB); größere Nachrichten werden abgelehnt. Legen Sie Dokumente, Bilder und Embedding-Batches in Object Storage oder einer Vektordatenbank ab und packen Sie eine Referenz in die Nachricht.
  • Annahmen zur Reihenfolge. Eine Queue bewahrt die Veröffentlichungsreihenfolge, doch bei mehreren Consumern und Requeues kann jeder Consumer Nachrichten außer der Reihe sehen. Für strikte Reihenfolge pro Konversation nutzen Sie eine Queue mit Single Active Consumer oder transportieren eine Sequenznummer.
  • Retries, die Seiteneffekte wiederholen. Die Zustellung erfolgt at least once: Ein Worker kann die Arbeit abschließen und vor dem Acknowledgement abstürzen, und die Nachricht kommt mit gesetztem redelivered-Flag zurück. Verknüpfen Sie jeden Seiteneffekt (eine versendete E-Mail, ein eröffnetes Ticket, eine ausgelöste Erstattung) mit der Message ID des Tasks und prüfen Sie diese zuerst – so wie der Worker oben.

Häufig gestellte Fragen

Lässt sich RabbitMQ für KI-Agenten einsetzen?

Ja. Worker konsumieren LLM- und Tool-Jobs mit manuellen Acknowledgements, Quorum Queues halten Tasks dauerhaft vor, Delivery Limits und Dead-Letter-Exchanges stoppen Poison Prompts, Topic Exchanges routen nach Skill, und Streams bewahren eine abspielbare Historie.

Welche Message Queue eignet sich für KI-Agenten?

Das hängt vom Workload ab. Die Übergabe von Tasks mit Retries, Prioritäten und Acknowledgement pro Task passt zu einem Queue-Broker wie RabbitMQ; umfangreiche Event-Streams, die viele Consumer erneut abspielen, passen zu einem Log wie Kafka oder RabbitMQ-Streams.

Wie verhindere ich, dass lange LLM-Aufrufe in den RabbitMQ-Consumer-Timeout laufen?

Der Standard-Timeout beträgt 30 Minuten. Setzen Sie ab RabbitMQ 3.12 consumer-timeout per Policy oder x-consumer-timeout als Queue-Argument auf den Queues mit langen Jobs, halten Sie den Prefetch auf 1 und bestätigen Sie auf jedem Codepfad.

Funktioniert LangChain oder LangGraph mit RabbitMQ?

Sie werden gemeinsam eingesetzt, wobei RabbitMQ die Task-Schicht um den Graph bildet. Ein Worker konsumiert einen Task und ruft den Graph auf, während der Checkpointer von LangGraph – laut Dokumentation In-Memory, SQLite oder Postgres – den Graph-Zustand unter einer thread_id speichert, die in der Nachricht mitgeführt wird.

Wie sollte ein KI-Agent mit doppelten RabbitMQ-Nachrichten umgehen?

Gehen Sie von At-least-once-Zustellung aus. Geben Sie jedem Task eine stabile Message ID, speichern Sie abgeschlossene IDs zusammen mit dem Ergebnis und überspringen Sie jede Zustellung, deren ID bereits erfasst ist, bevor ein Seiteneffekt wiederholt wird.

Kostenlose Beratung

Lassen Sie Experten auf Ihre RabbitMQ-Cluster-Umgebung schauen

Ob Sie einen Produktionsvorfall beheben, eine Migration planen oder eine zweite Meinung zu Ihrer Architektur wünschen – unser Team steht bereit. Kein Verkaufsgespräch, nur Antworten.

E-Mail schreiben