Home
Blog
OpenAgents x Milvus: Cómo crear sistemas multiagente más inteligentes que comparten memoria

OpenAgents x Milvus: Cómo crear sistemas multiagente más inteligentes que comparten memoria

Tutorials

November 24, 2025

Min Yin

La mayoría de los desarrolladores empiezan sus sistemas agénticos con un único agente y sólo más tarde se dan cuenta de que básicamente han construido un chatbot muy caro. Para tareas sencillas, un agente del estilo de ReAct funciona bien, pero enseguida se topa con sus límites: no puede ejecutar pasos en paralelo, pierde la pista de largas cadenas de razonamiento y tiende a venirse abajo en cuanto se añaden demasiadas herramientas a la mezcla. Las configuraciones multiagente prometen arreglar esto, pero traen sus propios problemas: sobrecarga de coordinación, traspasos frágiles y un contexto compartido cada vez mayor que erosiona silenciosamente la calidad del modelo.

OpenAgents es un marco de código abierto para construir sistemas multiagente en los que los agentes de IA trabajan juntos, comparten recursos y abordan proyectos a largo plazo dentro de comunidades persistentes. En lugar de un único orquestador central, OpenAgents permite a los agentes colaborar de forma más distribuida: pueden descubrirse unos a otros, comunicarse y coordinarse en torno a objetivos compartidos.

Combinado con la base de datos vectorial Milvus, este canal adquiere una capa de memoria a largo plazo escalable y de alto rendimiento. Milvus potencia la memoria de los agentes con una búsqueda semántica rápida, opciones de indexación flexibles como HNSW e IVF, y un aislamiento limpio a través de la partición, para que los agentes puedan almacenar, recuperar y reutilizar el conocimiento sin ahogarse en el contexto o pisar los datos de los demás.

En este artículo, explicaremos cómo OpenAgents permite la colaboración multiagente distribuida, por qué Milvus es una base fundamental para una memoria de agente escalable y cómo montar un sistema de este tipo paso a paso.

Desafíos en la creación de sistemas de agentes del mundo real

Muchos de los principales marcos de agentes actuales (LangChain, AutoGen, CrewAI y otros) se basan en un modelo centrado en tareas. Se crea un conjunto de agentes, se les asigna una tarea, tal vez se define un flujo de trabajo, y se les deja funcionar. Esto funciona bien para casos de uso limitados o de corta duración, pero en entornos de producción reales, expone tres limitaciones estructurales:

El conocimiento permanece aislado. La experiencia de un agente se limita a su propio despliegue. Un agente de revisión de código en ingeniería no comparte lo que aprende con un agente del equipo de producto que evalúa la viabilidad. Cada equipo acaba reconstruyendo sus conocimientos desde cero, lo que resulta ineficaz y frágil.
La colaboración es rígida. Incluso en los marcos multiagente, la cooperación suele depender de flujos de trabajo definidos de antemano. Cuando la colaboración tiene que cambiar, estas reglas estáticas no pueden adaptarse, lo que resta flexibilidad a todo el sistema.
Falta de un estado persistente. La mayoría de los agentes siguen un ciclo de vida simple: iniciar → ejecutar → apagar. Lo olvidan todo entre una ejecución y otra: el contexto, las relaciones, las decisiones tomadas y el historial de interacciones. Sin un estado persistente, los agentes no pueden construir una memoria a largo plazo ni evolucionar su comportamiento.

Estos problemas estructurales provienen de tratar a los agentes como ejecutores aislados de tareas en lugar de como participantes en una red de colaboración más amplia.

El equipo de OpenAgents cree que los futuros sistemas de agentes necesitan algo más que un razonamiento más sólido: necesitan un mecanismo que permita a los agentes descubrirse unos a otros, establecer relaciones, compartir conocimientos y trabajar juntos de forma dinámica. Y, lo que es más importante, esto no debería depender de un único controlador central. Internet funciona porque está distribuido: ningún nodo lo dicta todo, y el sistema se hace más robusto y escalable a medida que crece. Los sistemas multiagente se benefician del mismo principio de diseño. Por eso, OpenAgents elimina la idea de un orquestador todopoderoso y, en su lugar, permite la cooperación descentralizada e impulsada por la red.

¿Qué es OpenAgents?

OpenAgents es un marco de código abierto para crear redes de agentes de IA que permite la colaboración abierta, en la que los agentes de IA trabajan juntos, comparten recursos y abordan proyectos a largo plazo. Proporciona la infraestructura para una Internet de agentes, en la que éstos colaboran abiertamente con millones de otros agentes en comunidades persistentes y en crecimiento. A nivel técnico, el sistema se estructura en torno a tres componentes básicos: Red de Agentes, Mods de Red y Transportes.

1. Red de Agentes: Un entorno compartido para la colaboración

Una red de agentes es un entorno compartido en el que varios agentes pueden conectarse, comunicarse y trabajar juntos para resolver tareas complejas. Sus características principales son

Funcionamiento persistente: Una vez creada, la Red permanece en línea independientemente de cualquier tarea o flujo de trabajo.
Agente dinámico: Los agentes pueden unirse en cualquier momento utilizando un ID de Red; no es necesario registrarse previamente.
Soporte multiprotocolo: Una capa de abstracción unificada admite la comunicación a través de WebSocket, gRPC, HTTP y libp2p.
Configuración autónoma: Cada red mantiene sus propios permisos, gobernanza y recursos.

Con sólo una línea de código, se puede crear una Red, y cualquier agente puede unirse inmediatamente a través de interfaces estándar.

2. Modos de red: Extensiones enchufables para la colaboración

Los Mods proporcionan una capa modular de características de colaboración que permanecen desacopladas del sistema central. Puede mezclar y combinar Mods en función de sus necesidades específicas, permitiendo patrones de colaboración adaptados a cada caso de uso.

Mod	Propósito	Casos de uso
Mensajería en el espacio de trabajo	Comunicación de mensajes en tiempo real	Respuestas en tiempo real, feedback instantáneo
Foro	Debate asíncrono	Revisión de propuestas, deliberación en varias rondas
Wiki	Base de conocimientos compartida	Consolidación de conocimientos, colaboración documental
Social	Gráfico de relaciones	Enrutamiento de expertos, redes de confianza

Todos los Mods operan en un sistema de eventos unificado, lo que facilita la ampliación del marco o la introducción de comportamientos personalizados siempre que sea necesario.

3. Transportes: Un canal de comunicación independiente del protocolo

Los transportes son los protocolos de comunicación que permiten a agentes heterogéneos conectarse e intercambiar mensajes dentro de una red OpenAgents. OpenAgents soporta múltiples protocolos de transporte que pueden ejecutarse simultáneamente dentro de la misma red, incluyendo:

HTTP/REST para una integración amplia y multilingüe
WebSocket para una comunicación bidireccional de baja latencia
gRPC para RPC de alto rendimiento adaptado a clusters a gran escala
libp2p para redes descentralizadas de igual a igual.
A2A, un protocolo emergente diseñado específicamente para la comunicación entre agentes.

Todos los transportes funcionan a través de un formato de mensaje unificado basado en eventos, lo que permite una traducción perfecta entre protocolos. No es necesario preocuparse por el protocolo que utiliza un agente de igual a igual: el marco de trabajo lo gestiona automáticamente. Los agentes creados en cualquier lenguaje o marco de trabajo pueden unirse a una red OpenAgents sin reescribir el código existente.

Integración de OpenAgents con Milvus para una memoria de agentes a largo plazo

OpenAgents resuelve el reto de cómo los agentes se comunican, se descubren unos a otros y colaboran, perola colaboración por sí sola no es suficiente. Los agentes generan ideas, decisiones, historial de conversaciones, resultados de herramientas y conocimientos específicos del dominio. Sin una capa de memoria persistente, todo eso se evapora en el momento en que un agente se apaga.

Aquí es donde Milvus resulta esencial. Milvus proporciona el almacenamiento vectorial de alto rendimiento y la recuperación semántica necesarios para convertir las interacciones de los agentes en memoria duradera y reutilizable. Cuando se integra en la red OpenAgents, ofrece tres ventajas principales:

1. Búsqueda semántica

Milvus ofrece una búsqueda semántica rápida mediante algoritmos de indexación como HNSW e IVF_FLAT. Los agentes pueden recuperar los registros históricos más relevantes basándose en el significado y no en palabras clave, lo que les permite:

Recordar decisiones o planes anteriores,
evitar la repetición de tareas,
mantener el contexto a largo plazo entre sesiones.

Esta es la espina dorsal de la memoria agéntica: recuperación rápida, relevante y contextual.

2. Escalabilidad horizontal a escala de miles de millones

Las redes de agentes reales generan cantidades ingentes de datos. Milvus está construido para operar cómodamente a esta escala, ofreciendo:

almacenamiento y búsqueda en miles de millones de vectores,
latencia < 30 ms incluso con recuperación Top-K de alto rendimiento,
una arquitectura totalmente distribuida que escala linealmente a medida que crece la demanda.

Tanto si tiene una docena de agentes como miles trabajando en paralelo, Milvus mantiene la recuperación rápida y consistente.

3. Aislamiento multiusuario

Milvus proporciona un aislamiento granular multiusuario a través de Partition Key, un mecanismo de partición ligero que segmenta la memoria dentro de una única colección. Esto permite

que diferentes equipos, proyectos o comunidades de agentes mantengan espacios de memoria independientes,
reducir drásticamente la sobrecarga en comparación con el mantenimiento de múltiples colecciones,
recuperación opcional entre particiones cuando se necesitan conocimientos compartidos.

Este aislamiento es crucial para grandes despliegues multiagente en los que deben respetarse los límites de los datos sin comprometer la velocidad de recuperación.

OpenAgents se conecta a Milvus a través de Mods personalizados que llaman directamente a las APIs de Milvus. Los mensajes de los agentes, las salidas de las herramientas y los registros de interacción se incrustan automáticamente en los vectores y se almacenan en Milvus. Los desarrolladores pueden personalizar

el modelo de incrustación
el esquema de almacenamiento y los metadatos,
y las estrategias de recuperación (por ejemplo, búsqueda híbrida, búsqueda particionada).

Esto proporciona a cada comunidad de agentes una capa de memoria escalable, persistente y optimizada para el razonamiento semántico.

Cómo construir un chatbot multiagente con OpenAgent y Milvus

Para concretar, veamos una demostración: crear una comunidad de asistencia a desarrolladores en la que varios agentes especializados (expertos en Python, expertos en bases de datos, ingenieros de DevOps, etc.) colaboren para responder a preguntas técnicas. En lugar de depender de un único agente generalista sobrecargado de trabajo, cada experto contribuye con un razonamiento específico del dominio, y el sistema dirige las consultas al agente más adecuado de forma automática.

Este ejemplo demuestra cómo integrar Milvus en un despliegue de OpenAgents para proporcionar memoria a largo plazo para preguntas y respuestas técnicas. Las conversaciones de los agentes, las soluciones anteriores, los registros de resolución de problemas y las consultas de los usuarios se convierten en incrustaciones vectoriales y se almacenan en Milvus, lo que proporciona a la red la capacidad de:

recordar respuestas anteriores,
reutilizar explicaciones técnicas anteriores,
mantener la coherencia entre sesiones y
mejorar con el tiempo a medida que se acumulan más interacciones.

Requisitos previos

python3.11+
conda
Openai-key

1. Definir dependencias

Definir los paquetes de Python necesarios para el proyecto:

# 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. Variables de entorno

Aquí está la plantilla para la configuración de su entorno:

# 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 su red OpenAgents

Defina la estructura de su red de agentes y sus ajustes de comunicación:

# 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 la Colaboración Multi-Agente

A continuación se muestran fragmentos de código básico (no la implementación 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. Crear y activar un entorno virtual

conda create -n openagents
conda activate openagents

Instalación de dependencias

pip install -r requirements.txt

Configurar claves API

cp .env.example .env

Iniciar la red OpenAgents

openagents network start .

Iniciar el Servicio Multi-Agente

python multi_agent_demo.py

Iniciar OpenAgents Studio

openagents studio -s

Acceder a Studio

http://localhost:8050

Compruebe el estado de sus agentes y red:

Conclusión

OpenAgents proporciona la capa de coordinación que permite a los agentes descubrirse unos a otros, comunicarse y colaborar, mientras que Milvus resuelve el problema igualmente crítico de cómo se almacena, comparte y reutiliza el conocimiento. Al ofrecer una capa de memoria vectorial de alto rendimiento, Milvus permite a los agentes crear un contexto persistente, recordar interacciones pasadas y acumular experiencia a lo largo del tiempo. Juntos, llevan a los sistemas de IA más allá de los límites de los modelos aislados y hacia el potencial de colaboración más profundo de una verdadera red multiagente.

Por supuesto, ninguna arquitectura multiagente está exenta de contrapartidas. Ejecutar agentes en paralelo puede aumentar el consumo de tokens, los errores pueden producirse en cascada entre los agentes y la toma simultánea de decisiones puede provocar conflictos ocasionales. Estas son áreas activas de investigación y mejora continua, pero no disminuyen el valor de la construcción de sistemas que pueden coordinar, recordar y evolucionar.

¿Listo para dotar a tus agentes de memoria a largo plazo?

Explora Milvus y prueba a integrarlo en tu propio flujo de trabajo.

Tienes preguntas o quieres una inmersión profunda en alguna característica? Únete a nuestro canal de Discord o presenta incidencias en GitHub. También puede reservar una sesión individual de 20 minutos para obtener información, orientación y respuestas a sus preguntas a través de Milvus Office Hours.