AI Agents · Leçon

Protocoles de communication (bus de messages)

Découplez les agents avec un bus de messages (Redis, NATS, Kafka) afin qu’ils puissent évoluer et échouer indépendamment.

Protocoles de communication (bus de messages) est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Au-delà des conversations en processus

Dans les petits systèmes, les agents s'appellent directement au sein du processus. Dans les systèmes plus importants, découplez-les au moyen d'un bus de messages : Redis, NATS ou Kafka.

Pourquoi découpler ?

Les agents peuvent évoluer indépendamment
Les défaillances sont isolées pour chaque agent
Flux de travail asynchrones, sans devoir attendre les agents lents dans le processus
Rejouer les messages pour le débogage
Interopérabilité entre langages : un agent Python et un agent Go peuvent tous deux s'abonner

Simple Bus: Redis Pub/Sub

import redis
r = redis.Redis()

# Publisher
r.publish('agent.research.task', json.dumps({'task_id': 'abc', 'query': '...'}))

# Subscriber
p = r.pubsub()
p.subscribe('agent.research.task')
for msg in p.listen():
    if msg['type'] == 'message':
        handle_task(json.loads(msg['data']))

Publication et abonnement pour la diffusion

Utilisez cette approche lorsque plusieurs agents peuvent vouloir être informés d'un événement, par exemple « question-utilisateur-reçue ».

Files d'attente pour distribuer le travail

Utilisez une file d'attente (Redis BLPOP, RabbitMQ) lorsqu'un seul agent doit traiter chaque tâche :

import json, queue

r = queue.Queue()

# Producer
r.put(json.dumps({'task_id': 'abc', 'kind': 'research'}))

def process(task):
    print('processing', task)

# Worker
while not r.empty():
    raw = r.get()
    task = json.loads(raw)
    process(task)

NATS pour la rapidité

NATS est un courtier de messages léger conçu pour les microservices. Il offre une latence inférieure à la milliseconde et intègre le modèle requête/réponse :

import nats
nc = await nats.connect('nats://localhost:4222')

await nc.publish('agent.research', json.dumps(task).encode())

# Request/reply
response = await nc.request('agent.research', payload, timeout=10)

Kafka pour la durabilité

Kafka ajoute des journaux durables et rejouables. Il est parfait pour l'audit et la relecture :

from confluent_kafka import Producer, Consumer

producer.produce('agent-events', key=task_id, value=json.dumps(task))
producer.flush()

Schémas d'événements

Définissez la structure de chaque message avec Pydantic ou Protobuf. Sans schémas, votre bus devient vite ingérable :

class ResearchTask(BaseModel):
    task_id: str
    user_id: str
    query: str
    deadline: datetime

class ResearchResult(BaseModel):
    task_id: str
    findings: list[str]
    duration_ms: int

Identifiants de corrélation

Chaque message associé transporte le même identifiant de corrélation afin que vous puissiez suivre une tâche à travers les services :

record = {'correlation_id': 'abc', 'task_id': 'def', 'span': 'llm_call'}
print(record)

Gestionnaires idempotents

Les messages peuvent être remis plusieurs fois, selon une sémantique de livraison au moins une fois. Rendez les gestionnaires idempotents : une même tâche n'est traitée qu'une seule fois.

Queue de lettres mortes

Lorsqu'un gestionnaire échoue à plusieurs reprises, déposez le message dans une DLQ pour qu'une personne l'examine, au lieu de boucler indéfiniment :

if attempts > MAX_RETRIES:
    r.rpush('queue:research:dlq', raw)
    log.error('Sent to DLQ', extra={'task_id': task_id})

Observabilité

Suivez chaque message :

Les identifiants de suivi transitent par le bus
Les journaux contiennent l'identifiant de tâche et l'identifiant de corrélation
Métriques : débit, latence et taux d'erreur pour chaque sujet

Quand adopter cette approche

Commencez simplement, avec des agents au sein du processus. Passez à un bus uniquement lorsque vous avez :

5 agents ou plus en production
Besoin de faire évoluer les agents indépendamment
Des flux de travail qui s'étendent sur plusieurs services

Au moins une fois ?

Qu'exige une « livraison au moins une fois » de la part de vos gestionnaires ?

Récapitulatif

Découplez avec Redis pour les cas simples, NATS pour la latence et Kafka pour la durabilité. Utilisez des schémas, des identifiants de corrélation, des gestionnaires idempotents et une DLQ.

Questions Fréquemment Posées

La leçon « Protocoles de communication (bus de messages) » est-elle gratuite ?

Oui — le texte complet de « Protocoles de communication (bus de messages) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Protocoles de communication (bus de messages) » ?

Découplez les agents avec un bus de messages (Redis, NATS, Kafka) afin qu’ils puissent évoluer et échouer indépendamment. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Protocoles de communication (bus de messages) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Multi-agents fondés sur la conversation (AutoGen)
Superviseurs hiérarchiques (orchestrateur et exécutants)
Rôles et spécialisations des agents
Protocoles de communication (bus de messages)

← Retour à AI Agents