AI Agents · Aula

Protocolos de comunicação (barramentos de mensagens)

Desacople os agentes com um barramento de mensagens (Redis, NATS, Kafka) para que possam escalar e falhar de forma independente.

Aula 4 de 415 etapas

Protocolos de comunicação (barramentos de mensagens) é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Além das Conversas no Mesmo Processo

Em sistemas pequenos, os agentes chamam uns aos outros no mesmo processo. Em sistemas maiores, desacople-os por meio de um barramento de mensagens — Redis, NATS ou Kafka.

Por que Desacoplar?

Os agentes podem ser dimensionados de forma independente
As falhas ficam isoladas por agente
Fluxos de trabalho assíncronos (não é necessário esperar agentes lentos em linha)
As mensagens podem ser reproduzidas para depuração
Entre linguagens: um agente Python e um agente Go podem fazer subscribe

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']))

Pub/Sub para Difusão

Use quando vários agentes puderem querer receber informações sobre um evento (por exemplo, "user-question-received").

Filas para Distribuição de Trabalho

Use uma fila (Redis BLPOP, RabbitMQ) quando exatamente um trabalhador deverá processar cada tarefa:

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 para Velocidade

NATS é um intermediário de mensagens leve, projetado para microsserviços. Latência inferior a um milissegundo, com solicitação/resposta integrada:

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 para Durabilidade

Kafka adiciona registros duráveis e reproduzíveis. É perfeito para auditoria e reprodução:

from confluent_kafka import Producer, Consumer

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

Esquemas de Eventos

Defina o formato de cada mensagem com Pydantic ou Protobuf. Sem esquemas, seu barramento vira uma confusão:

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

IDs de Correlação

Cada mensagem relacionada carrega o mesmo correlation_id para que você possa rastrear uma tarefa entre serviços:

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

Manipuladores Idempotentes

As mensagens podem ser entregues mais de uma vez (semântica de pelo menos uma entrega). Torne os manipuladores idempotentes — o mesmo task_id é processado uma única vez.

Fila de Mensagens Mortas

Quando um manipulador falhar repetidamente, descarte a mensagem em uma DLQ para análise humana em vez de ficar repetindo o processo indefinidamente:

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

Observabilidade

Rastreie cada mensagem:

Os IDs de rastreamento percorrem o barramento
Os registros incluem task_id e correlation_id
Métricas: taxa de processamento, latência e taxa de erros por tópico

Quando Adotar

Comece de forma simples — agentes no mesmo processo. Passe para um barramento somente quando você tiver:

Mais de 5 agentes em produção
Necessidade de dimensionar os agentes de forma independente
Fluxos de trabalho que abrangem vários serviços

Pelo Menos Uma Vez?

O que a "entrega de pelo menos uma vez" exige dos seus manipuladores?

Responda na aula interativa

Recapitulação

Desacople com Redis em casos simples, NATS para obter baixa latência e Kafka para durabilidade. Esquemas, IDs de correlação, manipuladores idempotentes e DLQ.

Grátis para começar

Aprenda AI Agents com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 60
Aulas: 239

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Protocolos de comunicação (barramentos de mensagens)” é grátis?

Sim — o texto completo de “Protocolos de comunicação (barramentos de mensagens)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Protocolos de comunicação (barramentos de mensagens)”?

Desacople os agentes com um barramento de mensagens (Redis, NATS, Kafka) para que possam escalar e falhar de forma independente. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Agents?

Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Protocolos de comunicação (barramentos de mensagens)”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Agents?

Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Multiagentes baseados em conversa (AutoGen)
Supervisores hierárquicos (orquestrador + trabalhadores)
Papéis e especializações dos agentes
Protocolos de comunicação (barramentos de mensagens)

← Voltar para AI Agents