Home
Blog
OpenAgents x Milvus: Como construir sistemas multiagentes mais inteligentes que partilham memória

OpenAgents x Milvus: Como construir sistemas multiagentes mais inteligentes que partilham memória

Tutorials

November 24, 2025

Min Yin

A maioria dos desenvolvedores começa seus sistemas agênticos com um único agente e só mais tarde percebe que basicamente construiu um chatbot muito caro. Para tarefas simples, um agente do tipo ReAct funciona bem, mas rapidamente atinge os seus limites: não consegue executar passos em paralelo, perde o controlo de cadeias de raciocínio longas e tende a desmoronar-se quando se adicionam demasiadas ferramentas à mistura. As configurações multiagente prometem resolver isto, mas trazem os seus próprios problemas: sobrecarga de coordenação, transferências frágeis e um contexto partilhado crescente que corrói silenciosamente a qualidade do modelo.

O OpenAgents é uma estrutura de código aberto para a construção de sistemas multiagentes em que os agentes de IA trabalham em conjunto, partilham recursos e lidam com projectos de longo prazo em comunidades persistentes. Em vez de um único orquestrador central, o OpenAgents permite que os agentes colaborem de uma forma mais distribuída: podem descobrir-se uns aos outros, comunicar e coordenar-se em torno de objectivos partilhados.

Em conjunto com o banco de dados vetorial Milvus, esse pipeline ganha uma camada de memória de longo prazo escalável e de alto desempenho. O Milvus alimenta a memória do agente com pesquisa semântica rápida, opções de indexação flexíveis, como HNSW e IVF, e isolamento limpo por meio de particionamento, para que os agentes possam armazenar, recuperar e reutilizar o conhecimento sem se afogar no contexto ou pisar nos dados uns dos outros.

Nesta postagem, veremos como o OpenAgents permite a colaboração multiagente distribuída, por que o Milvus é uma base crítica para a memória escalável de agentes e como montar esse sistema passo a passo.

Desafios na construção de sistemas de agentes do mundo real

Muitos dos principais frameworks de agentes atuais - LangChain, AutoGen, CrewAI e outros - são construídos em torno de um modelo centrado em tarefas. Você cria um conjunto de agentes, dá a eles um trabalho, talvez defina um fluxo de trabalho, e os deixa trabalhar. Isto funciona bem para casos de utilização restritos ou de curta duração, mas em ambientes de produção reais, expõe três limitações estruturais:

O conhecimento permanece em silos. A experiência de um agente está confinada à sua própria implantação. Um agente de revisão de código na engenharia não partilha o que aprende com um agente da equipa de produto que avalia a viabilidade. Cada equipa acaba por reconstruir o conhecimento a partir do zero, o que é ineficiente e frágil.
A colaboração é rígida. Mesmo em estruturas multi-agente, a colaboração depende normalmente de fluxos de trabalho definidos antecipadamente. Quando a colaboração precisa de mudar, estas regras estáticas não se podem adaptar, tornando todo o sistema menos flexível.
A falta de um estado persistente. A maioria dos agentes segue um ciclo de vida simples: iniciar → executar → encerrar. Esquecem-se de tudo entre execuções - contexto, relações, decisões tomadas e histórico de interações. Sem um estado persistente, os agentes não podem construir memória de longo prazo ou evoluir seu comportamento.

Estes problemas estruturais resultam do facto de tratar os agentes como executores de tarefas isoladas em vez de participantes numa rede colaborativa mais ampla.

A equipa OpenAgents acredita que os futuros sistemas de agentes precisam de mais do que um raciocínio mais forte - precisam de um mecanismo que permita que os agentes se descubram uns aos outros, construam relações, partilhem conhecimentos e trabalhem em conjunto de forma dinâmica. E, criticamente, isso não deve depender de um único controlador central. A Internet funciona porque é distribuída - nenhum nó único dita tudo, e o sistema torna-se mais robusto e escalável à medida que cresce. Os sistemas multiagentes beneficiam do mesmo princípio de conceção. É por isso que o OpenAgents elimina a ideia de um orquestrador todo-poderoso e, em vez disso, permite a cooperação descentralizada e orientada para a rede.

O que é o OpenAgents?

O OpenAgents é uma estrutura de código aberto para a criação de redes de agentes de IA que permite a colaboração aberta, onde os agentes de IA trabalham em conjunto, partilham recursos e lidam com projectos de longo prazo. Fornece a infraestrutura para uma Internet de agentes - onde os agentes colaboram abertamente com milhões de outros agentes em comunidades persistentes e em crescimento. A nível técnico, o sistema está estruturado em torno de três componentes principais: Rede de Agentes, Mods de Rede e Transportes.

1. Rede de Agentes: Um ambiente partilhado para colaboração

Uma rede de agentes é um ambiente partilhado onde vários agentes podem ligar-se, comunicar e trabalhar em conjunto para resolver tarefas complexas. As suas principais caraterísticas incluem:

Operação persistente: Uma vez criada, a rede permanece online independentemente de qualquer tarefa ou fluxo de trabalho.
Agente dinâmico: Os agentes podem aderir a qualquer momento utilizando uma ID de rede; não é necessário pré-registo.
Suporte multi-protocolo: Uma camada de abstração unificada suporta a comunicação através de WebSocket, gRPC, HTTP e libp2p.
Configuração autónoma: Cada rede mantém suas próprias permissões, governança e recursos.

Com apenas uma linha de código, é possível criar uma rede, e qualquer agente pode entrar imediatamente através de interfaces padrão.

2. Mods de rede: Extensões plugáveis para colaboração

Os Mods fornecem uma camada modular de recursos de colaboração que permanecem desacoplados do sistema principal. Pode misturar e combinar Mods com base nas suas necessidades específicas, permitindo padrões de colaboração adaptados a cada caso de utilização.

Mod	Objetivo	Casos de uso
Mensagens do espaço de trabalho	Comunicação de mensagens em tempo real	Respostas em fluxo contínuo, feedback instantâneo
Fórum	Discussão assíncrona	Revisões de propostas, deliberação em várias rondas
Wiki	Base de conhecimentos partilhada	Consolidação de conhecimentos, colaboração em documentos
Social	Gráfico de relações	Encaminhamento de especialistas, redes de confiança

Todos os Mods funcionam num sistema de eventos unificado, o que facilita a extensão da estrutura ou a introdução de comportamentos personalizados sempre que necessário.

3. Transportes: Um canal de comunicação independente de protocolo

Os transportes são os protocolos de comunicação que permitem que agentes heterogéneos se liguem e troquem mensagens dentro de uma rede OpenAgents. O OpenAgents suporta múltiplos protocolos de transporte que podem ser executados simultaneamente dentro da mesma rede, incluindo

HTTP/REST para integração ampla e entre linguagens
WebSocket para comunicação bidirecional e de baixa latência
gRPC para RPC de alto desempenho adequado a clusters de grande escala
libp2p para redes descentralizadas e peer-to-peer
A2A, um protocolo emergente projetado especificamente para comunicação agente a agente

Todos os transportes operam através de um formato de mensagem unificado baseado em eventos, permitindo uma tradução perfeita entre protocolos. Não precisa de se preocupar com o protocolo utilizado por um agente de pares - a estrutura trata disso automaticamente. Os agentes criados em qualquer linguagem ou estrutura podem participar de uma rede OpenAgents sem reescrever o código existente.

Integração do OpenAgents com o Milvus para memória agêntica de longo prazo

O OpenAgents resolve o desafio de como os agentes se comunicam , descobrem uns aos outros e colaboram - masa colaboração por si só não é suficiente. Os agentes geram insights, decisões, histórico de conversas, resultados de ferramentas e conhecimento específico do domínio. Sem uma camada de memória persistente, tudo isso se evapora no momento em que um agente é desligado.

É aqui que o Milvus se torna essencial. O Milvus fornece o armazenamento vetorial de alto desempenho e a recuperação semântica necessários para transformar as interações dos agentes em memória duradoura e reutilizável. Quando integrado à rede OpenAgents, ele oferece três grandes vantagens:

1. Pesquisa semântica

O Milvus proporciona uma pesquisa semântica rápida utilizando algoritmos de indexação como o HNSW e o IVF_FLAT. Os agentes podem recuperar os registos históricos mais relevantes com base no significado e não em palavras-chave, permitindo-lhes

recordar decisões ou planos anteriores,
evitar a repetição de trabalho,
manter um contexto de longo prazo em todas as sessões.

Esta é a espinha dorsal da memória agêntica: recuperação rápida, relevante e contextual.

2. Escalabilidade horizontal à escala de milhares de milhões

Redes de agentes reais geram grandes quantidades de dados. Milvus foi construído para operar confortavelmente nesta escala, oferecendo

armazenamento e pesquisa em milhares de milhões de vectores,
latência < 30 ms mesmo com recuperação Top-K de alto rendimento,
uma arquitetura totalmente distribuída que se dimensiona linearmente à medida que a procura aumenta.

Quer tenha uma dúzia de agentes ou milhares a trabalhar em paralelo, o Milvus mantém a recuperação rápida e consistente.

3. Isolamento de vários inquilinos

Milvus fornece isolamento granular multi-tenant através de Partition Key, um mecanismo de particionamento leve que segmenta a memória dentro de uma única coleção. Isso permite:

diferentes equipas, projectos ou comunidades de agentes mantenham espaços de memória independentes,
uma sobrecarga drasticamente menor em comparação com a manutenção de várias colecções,
recuperação opcional entre partições quando é necessário conhecimento partilhado.

Este isolamento é crucial para grandes implementações multi-agente onde os limites dos dados devem ser respeitados sem comprometer a velocidade de recuperação.

O OpenAgents liga-se ao Milvus através de Mods personalizados que chamam diretamente as APIs do Milvus. As mensagens dos agentes, os resultados das ferramentas e os registos de interação são automaticamente incorporados nos vectores e armazenados no Milvus. Os programadores podem personalizar:

o modelo de incorporação,
o esquema de armazenamento e os metadados,
e estratégias de recuperação (por exemplo, pesquisa híbrida, pesquisa particionada).

Isto dá a cada comunidade de agentes uma camada de memória que é escalável, persistente e optimizada para raciocínio semântico.

Como criar um Chatbot multiagente com OpenAgent e Milvus

Para tornar as coisas concretas, vamos fazer uma demonstração: construir uma comunidade de suporte ao desenvolvedor onde vários agentes especializados - especialistas em Python, especialistas em banco de dados, engenheiros de DevOps e outros - colaboram para responder a perguntas técnicas. Em vez de depender de um único agente generalista sobrecarregado, cada especialista contribui com um raciocínio específico do domínio, e o sistema encaminha automaticamente as consultas para o agente mais adequado.

Este exemplo demonstra como integrar o Milvus numa implementação OpenAgents para fornecer memória de longo prazo para perguntas e respostas técnicas. As conversas dos agentes, as soluções anteriores, os registos de resolução de problemas e as consultas dos utilizadores são todos convertidos em embeddings vectoriais e armazenados no Milvus, dando à rede a capacidade de

lembrar respostas anteriores,
reutilizar explicações técnicas anteriores,
manter a consistência entre sessões, e
melhorar ao longo do tempo à medida que mais interações se acumulam.

Pré-requisitos

python3.11+
conda
Openai-key

1. Definir dependências

Defina os pacotes Python necessários para o projeto:

# Core framework
openagents>=0.6.11
# Vector database
pymilvus>=2.5.1
# Embedding model
sentence-transformers>=2.2.0
# LLM integration
openai>=1.0.0
# Environment config
python-dotenv>=1.0.0

2. Variáveis de ambiente

Aqui está o modelo para a configuração do seu ambiente:

# LLM configuration (required)
OPENAI_API_KEY=your_openai_api_key_here
OPENAI_BASE_URL=https://api.openai.com/v1
OPENAI_MODEL=gpt-4o
# Milvus configuration
MILVUS_URI=./multi_agent_memory.db
# Embedding model configuration
EMBEDDING_MODEL=text-embedding-3-large
EMBEDDING_DIMENSION=3072
# Network configuration
NETWORK_HOST=localhost
NETWORK_PORT=8700
STUDIO_PORT=8050

3. Configure sua rede OpenAgents

Defina a estrutura da sua rede de agentes e suas configurações de comunicação:

# Network transport protocol (HTTP on port 8700)
# Multi-channel messaging system (general, coordination, expert channels)
# Agent role definitions (coordinator, python_expert, etc.)
# Milvus integration settings
network:
  name: "Multi-Agent Collaboration Demo"
  transports:
    - type: "http"
      config:
        port: 8700
        host: "localhost"
  mods:
    - name: "openagents.mods.workspace.messaging"
      config:
        channels:
          - name: "general"          # User question channel
          - name: "coordination"     # Coordinator channel
          - name: "python_channel"   # Python expert channel
          - name: "milvus_channel"   # Milvus expert channel
          - name: "devops_channel"   # DevOps expert channel
  agents:
    coordinator:
      type: "coordinator"
      description: "Coordinator Agent, responsible for analyzing queries and dispatching tasks to expert agents"
      channels: ["general", "coordination"]
    python_expert:
      type: "expert"
      domain: "python"

4. Implementar a Colaboração Multi-Agente

A seguir, são mostrados trechos de código principais (não a implementação completa).

# SharedMemory: Milvus’s SharedMemory system
# CoordinatorAgent: Coordinator Agent, responsible for analyzing queries and dispatching tasks to expert agents
# PythonExpertAgent: Python Expert
# MilvusExpertAgent: Milvus Expert
# DevOpsExpertAgent: DevOps Expert
import os
import asyncio
import json
from typing import List, Dict
from dotenv import load_dotenv
from openagents.agents.worker_agent import WorkerAgent
from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType
import openai
load_dotenv()
class SharedMemory:
    """SharedMemory in Milvus for all Agents"""
    def __init__(self):
        connections.connect(uri="./multi_agent_memory.db")
        self.setup_collections()
        self.openai_client = openai.OpenAI(
            api_key=os.getenv("OPENAI_API_KEY"),
            base_url=os.getenv("OPENAI_BASE_URL")
        )
    def setup_collections(self):
        """Create memory collections: expert knowledge, collaboration history, problem solutions"""
        collections = {
            "expert_knowledge": "expert knowledge",
            "collaboration_history": "collaboration history", 
            "problem_solutions": "problem solutions"
        }
        # Code to create vector collections...
    async def search_knowledge(self, query: str, collection_name: str):
        """Search for relevant knowledge"""
        # Vector search implementation...
    async def store_knowledge(self, agent_id: str, content: str, metadata: dict, collection_name: str):
        """Store knowledge"""
        # Store into the vector database...
class CoordinatorAgent(WorkerAgent):
    """Coordinator Agent - analyzes questions and coordinates other Agent"""
    def __init__(self):
        super().__init__(agent_id="coordinator")
        self.expert_agents = {
            "python": "python_expert",
            "milvus": "milvus_expert", 
            "devops": "devops_expert"
        }
    async def analyze_question(self, question: str) -> List[str]:
        """Determine which experts are needed for the question"""
        keywords = {
            "python": ["python", "django", "flask", "async"],
            "milvus": ["milvus", "vector", "index", "performance"],
            "devops": ["deployment", "docker", "kubernetes", "operations"]
        }
        # Keyword matching logic...
        return needed_experts
    async def coordinate_experts(self, question: str, needed_experts: List[str]):
        """Coordinate collaboration among expert Agent"""
        # 1. Notify experts to begin collaborating
        # 2. Dispatch tasks to each expert
        # 3. Collect expert responses
        # 4. Return expert opinions
    async def on_channel_post(self, context):
        """Main logic for handling user questions"""
        content = context.incoming_event.payload.get('content', {}).get('text', '')
        if content and not content.startswith('🎯'):
            # 1. Analyze question → 2. Coordinate experts → 3. Merge answers → 4. Reply to user
class PythonExpertAgent(WorkerAgent):
    """Python Expert Agent"""
    async def analyze_python_question(self, question: str) -> str:
        """Analyze Python-related questions and provide expert advice"""
        # 1. Search for relevant experience
        # 2. Use LLM to generate expert response
        # 3. Store result in collaboration history
        return answer
# Start all Agens
async def run_multi_agent_demo():
    coordinator = CoordinatorAgent()
    python_expert = PythonExpertAgent()
    milvus_expert = MilvusExpertAgent()
    devops_expert = DevOpsExpertAgent()
    # Connect to the OpenAgents network
    await coordinator.async_start(network_host="localhost", network_port=8700)
    # ... Start other Agent
    while True:
        await asyncio.sleep(1)
if __name__ == "__main__":
    asyncio.run(run_multi_agent_demo())

5. Criar e ativar um ambiente virtual

conda create -n openagents
conda activate openagents

Instalar dependências

pip install -r requirements.txt

Configurar chaves de API

cp .env.example .env

Iniciar a rede OpenAgents

openagents network start .

Iniciar o Serviço Multi-Agente

python multi_agent_demo.py

Iniciar o OpenAgents Studio

openagents studio -s

Acessar o Studio

http://localhost:8050

Verificar o estado dos agentes e da rede:

Conclusão

O OpenAgents fornece a camada de coordenação que permite que os agentes descubram uns aos outros, se comuniquem e colaborem, enquanto o Milvus resolve o problema igualmente crítico de como o conhecimento é armazenado, compartilhado e reutilizado. Ao fornecer uma camada de memória vetorial de elevado desempenho, o Milvus permite que os agentes criem um contexto persistente, recordem interações passadas e acumulem conhecimentos ao longo do tempo. Juntos, levam os sistemas de IA para além dos limites dos modelos isolados e em direção ao potencial de colaboração mais profundo de uma verdadeira rede multiagente.

Naturalmente, nenhuma arquitetura multiagente está isenta de compromissos. A execução de agentes em paralelo pode aumentar o consumo de tokens, os erros podem ocorrer em cascata entre agentes e a tomada simultânea de decisões pode levar a conflitos ocasionais. Estas são áreas activas de investigação e melhoria contínua - mas não diminuem o valor da construção de sistemas que podem coordenar, lembrar e evoluir.

Pronto para dar aos seus agentes uma memória de longo prazo?

Explore o Milvus e tente integrá-lo no seu próprio fluxo de trabalho.

Tem dúvidas ou quer um mergulho profundo em qualquer recurso? Junte-se ao nosso canal Discord ou registre problemas no GitHub. Você também pode reservar uma sessão individual de 20 minutos para obter insights, orientações e respostas às suas perguntas através do Milvus Office Hours.