Home
Blog
OpenAgents x Milvus : Comment construire des systèmes multi-agents plus intelligents qui partagent la mémoire

OpenAgents x Milvus : Comment construire des systèmes multi-agents plus intelligents qui partagent la mémoire

Tutorials

November 24, 2025

Min Yin

La plupart des développeurs commencent leurs systèmes agentiques avec un seul agent et ne réalisent que plus tard qu'ils ont essentiellement construit un chatbot très coûteux. Pour les tâches simples, un agent de type ReAct fonctionne bien, mais il atteint rapidement ses limites : il ne peut pas exécuter des étapes en parallèle, il perd la trace de longues chaînes de raisonnement et il a tendance à s'effondrer dès que vous ajoutez trop d'outils au mélange. Les configurations multi-agents promettent d'y remédier, mais elles apportent leurs propres problèmes : frais généraux de coordination, transferts fragiles, et un contexte partagé en expansion qui érode discrètement la qualité du modèle.

OpenAgents est un cadre open-source pour la construction de systèmes multi-agents dans lesquels les agents d'intelligence artificielle travaillent ensemble, partagent des ressources et s'attaquent à des projets à long terme au sein de communautés persistantes. Au lieu d'un orchestrateur central unique, OpenAgents permet aux agents de collaborer de manière plus distribuée : ils peuvent se découvrir les uns les autres, communiquer et se coordonner autour d'objectifs communs.

Associé à la base de données vectorielle Milvus, ce pipeline bénéficie d'une couche de mémoire à long terme évolutive et très performante. Milvus alimente la mémoire des agents avec une recherche sémantique rapide, des choix d'indexation flexibles comme HNSW et IVF, et une isolation propre grâce au partitionnement, de sorte que les agents peuvent stocker, récupérer et réutiliser les connaissances sans se noyer dans le contexte ou marcher sur les données des autres.

Dans ce billet, nous verrons comment OpenAgents permet une collaboration multi-agents distribuée, pourquoi Milvus est une base essentielle pour une mémoire d'agent évolutive et comment assembler un tel système étape par étape.

Défis dans la construction de systèmes d'agents dans le monde réel

De nombreux cadres d'agents courants aujourd'hui - LangChain, AutoGen, CrewAI et d'autres - sont construits autour d'un modèle centré sur les tâches. Vous créez un ensemble d'agents, vous leur donnez une tâche, vous définissez éventuellement un flux de travail et vous les laissez travailler. Cela fonctionne bien pour les cas d'utilisation étroits ou de courte durée, mais dans les environnements de production réels, cela expose trois limites structurelles :

Les connaissances restent cloisonnées. L'expérience d'un agent est confinée à son propre déploiement. Un agent chargé de l'examen du code en ingénierie ne partage pas ce qu'il apprend avec un agent de l'équipe produit qui évalue la faisabilité. Chaque équipe finit par reconstruire les connaissances à partir de zéro, ce qui est à la fois inefficace et fragile.
La collaboration est rigide. Même dans les cadres multi-agents, la coopération dépend généralement de flux de travail définis à l'avance. Lorsque la collaboration doit changer, ces règles statiques ne peuvent pas s'adapter, ce qui rend l'ensemble du système moins flexible.
L'absence d'état persistant. La plupart des agents suivent un cycle de vie simple : démarrage → exécution → arrêt. Ils oublient tout entre deux exécutions : le contexte, les relations, les décisions prises et l'historique des interactions. Sans état persistant, les agents ne peuvent pas construire une mémoire à long terme ou faire évoluer leur comportement.

Ces problèmes structurels sont dus au fait que les agents sont traités comme des exécutants de tâches isolées plutôt que comme des participants à un réseau de collaboration plus large.

L'équipe d'OpenAgents pense que les futurs systèmes d'agents ont besoin de plus qu'un raisonnement plus fort - ils ont besoin d'un mécanisme qui permette aux agents de se découvrir les uns les autres, d'établir des relations, de partager des connaissances et de travailler ensemble de manière dynamique. Et surtout, cela ne devrait pas dépendre d'un seul contrôleur central. L'internet fonctionne parce qu'il est distribué : aucun nœud ne dicte tout, et le système devient plus robuste et évolutif au fur et à mesure qu'il se développe. Les systèmes multi-agents bénéficient du même principe de conception. C'est pourquoi OpenAgents supprime l'idée d'un orchestrateur tout-puissant et permet à la place une coopération décentralisée, pilotée par le réseau.

Qu'est-ce qu'OpenAgents ?

OpenAgents est un cadre open-source pour la construction de réseaux d'agents d'IA qui permet une collaboration ouverte, où les agents d'IA travaillent ensemble, partagent des ressources et s'attaquent à des projets à long terme. Il fournit l'infrastructure pour un internet des agents - où les agents collaborent ouvertement avec des millions d'autres agents dans des communautés persistantes et croissantes. Sur le plan technique, le système s'articule autour de trois composants principaux : Le réseau d'agents, les modules de réseau et les transports.

1. Le réseau d'agents : Un environnement partagé pour la collaboration

Un réseau d'agents est un environnement partagé dans lequel plusieurs agents peuvent se connecter, communiquer et travailler ensemble pour résoudre des tâches complexes. Ses principales caractéristiques sont les suivantes

Fonctionnement permanent : Une fois créé, le réseau reste en ligne indépendamment de toute tâche ou flux de travail.
Agent dynamique : Les agents peuvent se joindre à tout moment à l'aide d'un identifiant de réseau ; aucun enregistrement préalable n'est nécessaire.
Prise en charge multiprotocole : Une couche d'abstraction unifiée prend en charge les communications via WebSocket, gRPC, HTTP et libp2p.
Configuration autonome : Chaque réseau conserve ses propres autorisations, sa propre gouvernance et ses propres ressources.

Avec une seule ligne de code, vous pouvez créer un réseau, et n'importe quel agent peut le rejoindre immédiatement grâce à des interfaces standard.

2. Mods de réseau : Extensions enfichables pour la collaboration

Les Mods fournissent une couche modulaire de fonctionnalités de collaboration qui restent découplées du système principal. Vous pouvez combiner les modules en fonction de vos besoins spécifiques, ce qui permet de créer des modèles de collaboration adaptés à chaque cas d'utilisation.

Mod	Objectif	Cas d'utilisation
Messagerie de l'espace de travail	Communication de messages en temps réel	Réponses en continu, retour d'information instantané
Forum	Discussion asynchrone	Examen des propositions, délibérations à plusieurs tours
Wiki	Base de connaissances partagée	Consolidation des connaissances, collaboration documentaire
Social	Graphique des relations	Routage d'experts, réseaux de confiance

Tous les modules fonctionnent sur un système d'événements unifié, ce qui facilite l'extension du cadre ou l'introduction de comportements personnalisés lorsque cela est nécessaire.

3. Transports : Un canal de communication indépendant du protocole

Les transports sont les protocoles de communication qui permettent à des agents hétérogènes de se connecter et d'échanger des messages au sein d'un réseau OpenAgents. OpenAgents prend en charge plusieurs protocoles de transport qui peuvent fonctionner simultanément au sein d'un même réseau :

HTTP/REST pour une intégration étendue et multilingue
WebSocket pour une communication bidirectionnelle à faible latence
gRPC pour une communication RPC haute performance adaptée aux clusters à grande échelle
libp2p pour une mise en réseau décentralisée, de pair à pair
A2A, un protocole émergent conçu spécifiquement pour la communication d'agent à agent.

Tous les transports fonctionnent selon un format de message unifié basé sur les événements, ce qui permet une traduction transparente entre les protocoles. Vous n'avez pas à vous préoccuper du protocole utilisé par un agent homologue, le cadre de travail s'en charge automatiquement. Les agents construits dans n'importe quel langage ou cadre peuvent rejoindre un réseau OpenAgents sans réécrire le code existant.

Intégration d'OpenAgents à Milvus pour une mémoire agentique à long terme

OpenAgents résout le problème de la communication, de la découverte et de la collaboration desagents , maisla collaboration seule ne suffit pas. Les agents génèrent des idées, des décisions, des historiques de conversation, des résultats d'outils et des connaissances spécifiques au domaine. Sans couche de mémoire persistante, tout cela s'évapore dès qu'un agent s'éteint.

C'est là que Milvus devient essentiel. Milvus fournit le stockage vectoriel haute performance et la récupération sémantique nécessaires pour transformer les interactions des agents en une mémoire durable et réutilisable. Lorsqu'il est intégré au réseau OpenAgents, il offre trois avantages majeurs :

1. Recherche sémantique

Milvus permet une recherche sémantique rapide à l'aide d'algorithmes d'indexation tels que HNSW et IVF_FLAT. Les agents peuvent retrouver les documents historiques les plus pertinents en se basant sur le sens plutôt que sur les mots-clés, ce qui leur permet de :

de se souvenir de décisions ou de plans antérieurs,
d'éviter de répéter le travail,
maintenir un contexte à long terme entre les sessions.

Il s'agit là de l'épine dorsale de la mémoire agentique: une récupération rapide, pertinente et contextuelle.

2. Évolutivité horizontale à l'échelle du milliard

Les réseaux d'agents réels génèrent des quantités massives de données. Milvus est conçu pour fonctionner confortablement à cette échelle, en offrant :

le stockage et la recherche sur des milliards de vecteurs,
une latence < 30 ms, même en cas de recherche Top-K à haut débit,
une architecture entièrement distribuée qui s'adapte linéairement à la croissance de la demande.

Que vous ayez une douzaine d'agents ou des milliers travaillant en parallèle, Milvus assure une recherche rapide et cohérente.

3. Isolation multi-locataires

Milvus offre une isolation granulaire multi-locataires grâce à Partition Key, un mécanisme de partitionnement léger qui segmente la mémoire à l'intérieur d'une collection unique. Cela permet

à différentes équipes, projets ou communautés d'agents de conserver des espaces mémoire indépendants,
de réduire considérablement les frais généraux par rapport à la gestion de plusieurs collections,
la récupération optionnelle des partitions lorsque des connaissances partagées sont nécessaires.

Cette isolation est cruciale pour les grands déploiements multi-agents où les limites des données doivent être respectées sans compromettre la vitesse de récupération.

OpenAgents se connecte à Milvus par le biais de modules personnalisés qui appellent directement les API de Milvus. Les messages des agents, les sorties d'outils et les journaux d'interaction sont automatiquement intégrés dans les vecteurs et stockés dans Milvus. Les développeurs peuvent personnaliser

le modèle d'intégration,
le schéma de stockage et les métadonnées,
et les stratégies de recherche (par exemple, recherche hybride, recherche partitionnée).

Chaque communauté d'agents dispose ainsi d'une couche de mémoire évolutive, persistante et optimisée pour le raisonnement sémantique.

Comment construire un chatbot multi-agent avec OpenAgent et Milvus

Pour rendre les choses plus concrètes, passons en revue une démo : construire une communauté d'assistance aux développeurs où plusieurs agents spécialisés - experts en Python, experts en bases de données, ingénieurs DevOps, et autres - collaborent pour répondre aux questions techniques. Au lieu de s'appuyer sur un seul agent généraliste surchargé, chaque expert apporte un raisonnement spécifique au domaine, et le système achemine automatiquement les requêtes vers l'agent le mieux adapté.

Cet exemple montre comment intégrer Milvus dans un déploiement OpenAgents afin de fournir une mémoire à long terme pour les questions-réponses techniques. Les conversations des agents, les solutions antérieures, les journaux de dépannage et les requêtes des utilisateurs sont tous convertis en vecteurs et stockés dans Milvus, ce qui permet au réseau de

se souvenir des réponses précédentes,
de réutiliser les explications techniques antérieures,
maintenir la cohérence d'une session à l'autre
s'améliorer dans le temps au fur et à mesure que les interactions s'accumulent.

Prérequis

python3.11+
conda
Openai-key

1. Définir les dépendances

Définir les paquets Python nécessaires au projet :

# 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 d'environnement

Voici le modèle de configuration de votre environnement :

# 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. Configurer votre réseau OpenAgents

Définissez la structure de votre réseau d'agents et ses paramètres de communication :

# 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. Mettre en œuvre la collaboration multi-agents

Ce qui suit montre des extraits de code de base (et non l'implémentation complète).

# 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. Créer et activer un environnement virtuel

conda create -n openagents
conda activate openagents

Installer les dépendances

pip install -r requirements.txt

Configurer les clés API

cp .env.example .env

Démarrer le réseau OpenAgents

openagents network start .

Démarrer le service Multi-Agent

python multi_agent_demo.py

Démarrer OpenAgents Studio

openagents studio -s

Accéder à Studio

http://localhost:8050

Vérifiez l'état de vos agents et de votre réseau :

Conclusion

OpenAgents fournit la couche de coordination qui permet aux agents de se découvrir, de communiquer et de collaborer, tandis que Milvus résout le problème tout aussi critique du stockage, du partage et de la réutilisation des connaissances. En fournissant une couche de mémoire vectorielle très performante, Milvus permet aux agents de construire un contexte persistant, de se souvenir des interactions passées et d'accumuler de l'expertise au fil du temps. Ensemble, ils poussent les systèmes d'IA au-delà des limites des modèles isolés et vers le potentiel de collaboration plus profond d'un véritable réseau multi-agents.

Bien entendu, aucune architecture multi-agents n'est exempte de compromis. L'exécution d'agents en parallèle peut augmenter la consommation de jetons, les erreurs peuvent se répercuter en cascade sur les agents et la prise de décision simultanée peut entraîner des conflits occasionnels. Il s'agit là de domaines de recherche active et d'amélioration continue, mais ils ne diminuent en rien la valeur de la construction de systèmes capables de se coordonner, de se souvenir et d'évoluer.

🚀 Prêt à doter vos agents d'une mémoire à long terme ?

Découvrez Milvus et essayez de l'intégrer à votre propre flux de travail.

Vous avez des questions ou souhaitez approfondir une fonctionnalité ? Rejoignez notre canal Discord ou déposez des problèmes sur GitHub. Vous pouvez également réserver une session individuelle de 20 minutes pour obtenir des informations, des conseils et des réponses à vos questions dans le cadre des Milvus Office Hours.