Home
Blog
OpenAgents x Milvus: come costruire sistemi multi-agente più intelligenti che condividono la memoria

OpenAgents x Milvus: come costruire sistemi multi-agente più intelligenti che condividono la memoria

Tutorials

November 24, 2025

Min Yin

La maggior parte degli sviluppatori inizia i propri sistemi agenziali con un singolo agente e solo in seguito si rende conto di aver costruito un chatbot molto costoso. Per compiti semplici, un agente in stile ReAct funziona bene, ma incontra rapidamente dei limiti: non può eseguire passi in parallelo, perde la traccia di lunghe catene di ragionamento e tende a crollare quando si aggiungono troppi strumenti al mix. Le configurazioni multi-agente promettono di risolvere questo problema, ma portano con sé i loro problemi: overhead di coordinamento, passaggi di consegne fragili e un contesto condiviso in crescita che erode silenziosamente la qualità del modello.

OpenAgents è un framework open-source per la costruzione di sistemi multi-agente in cui gli agenti di intelligenza artificiale lavorano insieme, condividono le risorse e affrontano progetti a lungo termine all'interno di comunità persistenti. Invece di un singolo orchestratore centrale, OpenAgents consente agli agenti di collaborare in modo più distribuito: possono scoprirsi a vicenda, comunicare e coordinarsi intorno a obiettivi condivisi.

In combinazione con il database vettoriale Milvus, questa pipeline ottiene un livello di memoria a lungo termine scalabile e ad alte prestazioni. Milvus alimenta la memoria degli agenti con una ricerca semantica veloce, scelte di indicizzazione flessibili come HNSW e IVF, e un isolamento pulito attraverso il partizionamento, in modo che gli agenti possano memorizzare, recuperare e riutilizzare la conoscenza senza annegare nel contesto o calpestare i dati degli altri.

In questo post spiegheremo come OpenAgents consente la collaborazione distribuita tra più agenti, perché Milvus è una base fondamentale per la memoria scalabile degli agenti e come assemblare un sistema del genere passo dopo passo.

Sfide nella costruzione di sistemi ad agenti del mondo reale

Molti framework di agenti mainstream oggi - LangChain, AutoGen, CrewAI e altri - sono costruiti attorno a un modello incentrato sui compiti. Si crea una serie di agenti, si assegna loro un lavoro, magari definendo un flusso di lavoro, e li si lascia funzionare. Questo modello funziona bene per casi d'uso limitati o di breve durata, ma negli ambienti di produzione reali espone tre limiti strutturali:

La conoscenza rimane isolata. L'esperienza di un agente è confinata al proprio impiego. Un agente di revisione del codice in ingegneria non condivide ciò che impara con un agente del team di prodotto che valuta la fattibilità. Ogni team finisce per ricostruire la conoscenza da zero, il che è inefficiente e fragile.
La collaborazione è rigida. Anche nei framework multi-agente, la cooperazione dipende solitamente da flussi di lavoro definiti in anticipo. Quando la collaborazione deve cambiare, queste regole statiche non possono adattarsi, rendendo l'intero sistema meno flessibile.
Mancanza di uno stato persistente. La maggior parte degli agenti segue un ciclo di vita semplice: avvio → esecuzione → chiusura. Tra un'esecuzione e l'altra dimenticano tutto: contesto, relazioni, decisioni prese e storia delle interazioni. Senza uno stato persistente, gli agenti non possono costruire una memoria a lungo termine o evolvere il loro comportamento.

Questi problemi strutturali derivano dal fatto che gli agenti vengono trattati come esecutori di compiti isolati piuttosto che come partecipanti a una rete collaborativa più ampia.

Il team di OpenAgents ritiene che i futuri sistemi di agenti abbiano bisogno di qualcosa di più di un ragionamento più forte: hanno bisogno di un meccanismo che permetta agli agenti di scoprirsi l'un l'altro, di costruire relazioni, di condividere conoscenze e di lavorare insieme in modo dinamico. E, cosa fondamentale, questo non dovrebbe dipendere da un singolo controllore centrale. Internet funziona perché è distribuito: nessun singolo nodo comanda tutto, e il sistema diventa più robusto e scalabile man mano che cresce. I sistemi multi-agente beneficiano dello stesso principio di progettazione. Ecco perché OpenAgents elimina l'idea di un orchestratore onnipotente e consente invece una cooperazione decentralizzata e guidata dalla rete.

Cos'è OpenAgents?

OpenAgents è un framework open-source per la creazione di reti di agenti di intelligenza artificiale che consente una collaborazione aperta, in cui gli agenti di intelligenza artificiale lavorano insieme, condividono le risorse e affrontano progetti a lungo termine. Fornisce l'infrastruttura per un'internet degli agenti, dove gli agenti collaborano apertamente con milioni di altri agenti in comunità persistenti e in crescita. A livello tecnico, il sistema è strutturato attorno a tre componenti fondamentali: Rete di agenti, Mods di rete e Trasporti.

1. Rete di agenti: Un ambiente condiviso per la collaborazione

Una rete di agenti è un ambiente condiviso in cui più agenti possono connettersi, comunicare e lavorare insieme per risolvere compiti complessi. Le sue caratteristiche principali sono:

Funzionamento persistente: Una volta creata, la rete rimane online indipendentemente da ogni singola attività o flusso di lavoro.
Agente dinamico: Gli agenti possono unirsi in qualsiasi momento utilizzando un ID di rete; non è necessaria una pre-registrazione.
Supporto multiprotocollo: Un livello di astrazione unificato supporta la comunicazione tramite WebSocket, gRPC, HTTP e libp2p.
Configurazione autonoma: Ogni rete mantiene i propri permessi, la propria governance e le proprie risorse.

Con una sola riga di codice, è possibile creare una rete e qualsiasi agente può unirsi immediatamente attraverso interfacce standard.

2. Mods di rete: Estensioni collegabili per la collaborazione

I Mods forniscono un livello modulare di funzioni di collaborazione che rimangono disaccoppiate dal sistema principale. È possibile combinare i moduli in base alle proprie esigenze specifiche, consentendo modelli di collaborazione personalizzati per ogni caso d'uso.

Mod	Scopo	Casi d'uso
Messaggistica dello spazio di lavoro	Comunicazione di messaggi in tempo reale	Risposte in streaming, feedback istantaneo
Forum	Discussione asincrona	Revisioni di proposte, delibere a più riprese
Wiki	Base di conoscenza condivisa	Consolidamento della conoscenza, collaborazione documentale
Sociale	Grafo delle relazioni	Routing di esperti, reti di fiducia

Tutti i moduli operano su un sistema di eventi unificato, che consente di estendere facilmente il framework o di introdurre comportamenti personalizzati quando necessario.

3. Trasporti: Un canale di comunicazione indipendente dal protocollo

I trasporti sono i protocolli di comunicazione che consentono agli agenti eterogenei di connettersi e scambiare messaggi all'interno di una rete OpenAgents. OpenAgents supporta diversi protocolli di trasporto che possono essere eseguiti contemporaneamente all'interno della stessa rete, tra cui:

HTTP/REST per un'integrazione ampia e multilingue
WebSocket per una comunicazione bidirezionale a bassa latenza
gRPC per RPC ad alte prestazioni adatto a cluster su larga scala
libp2p per una rete decentralizzata e peer-to-peer
A2A, un protocollo emergente progettato specificamente per la comunicazione tra agenti.

Tutti i trasporti funzionano attraverso un formato di messaggio unificato basato sugli eventi, che consente la traduzione senza soluzione di continuità tra i protocolli. Non è necessario preoccuparsi del protocollo utilizzato da un agente peer: il framework lo gestisce automaticamente. Gli agenti costruiti in qualsiasi linguaggio o framework possono unirsi a una rete OpenAgents senza dover riscrivere il codice esistente.

Integrazione di OpenAgents con Milvus per una memoria agenziale a lungo termine

OpenAgents risolve la sfida di come gli agenti comunicano, si scoprono a vicenda e collaborano, ma lacollaborazione da sola non basta. Gli agenti generano intuizioni, decisioni, cronologia delle conversazioni, risultati degli strumenti e conoscenze specifiche del dominio. Senza un livello di memoria persistente, tutto questo evapora nel momento in cui un agente si spegne.

È qui che Milvus diventa essenziale. Milvus fornisce la memorizzazione vettoriale ad alte prestazioni e il recupero semantico necessari per trasformare le interazioni degli agenti in una memoria durevole e riutilizzabile. Integrato nella rete OpenAgents, offre tre vantaggi principali:

1. Ricerca semantica

Milvus offre una ricerca semantica veloce utilizzando algoritmi di indicizzazione come HNSW e IVF_FLAT. Gli agenti possono recuperare i record storici più rilevanti in base al significato piuttosto che alle parole chiave, consentendo loro di:

ricordare decisioni o piani precedenti
evitare di ripetere il lavoro,
mantenere un contesto a lungo termine tra le sessioni.

Questa è la spina dorsale della memoria agenziale: recupero veloce, pertinente e contestuale.

2. Scalabilità orizzontale su scala miliardaria

Le reti di agenti reali generano enormi quantità di dati. Milvus è costruito per operare comodamente su questa scala, offrendo:

memorizzazione e ricerca su miliardi di vettori,
latenza < 30 ms anche in caso di recupero Top-K ad alta velocità,
un'architettura completamente distribuita che scala linearmente al crescere della domanda.

Che si tratti di una dozzina di agenti o di migliaia che lavorano in parallelo, Milvus mantiene il reperimento veloce e coerente.

3. Isolamento multi-tenant

Milvus offre un isolamento granulare multi-tenant attraverso Partition Key, un meccanismo di partizionamento leggero che segmenta la memoria all'interno di una singola raccolta. Questo permette a:

a diversi team, progetti o comunità di agenti di mantenere spazi di memoria indipendenti,
ridurre drasticamente i costi di gestione rispetto al mantenimento di più collezioni,
il recupero facoltativo delle partizioni quando è necessaria la conoscenza condivisa.

Questo isolamento è fondamentale per le grandi distribuzioni multi-agente, dove i confini dei dati devono essere rispettati senza compromettere la velocità di recupero.

OpenAgents si connette a Milvus attraverso moduli personalizzati che chiamano direttamente le API di Milvus. I messaggi degli agenti, i risultati degli strumenti e i registri delle interazioni vengono automaticamente incorporati nei vettori e memorizzati in Milvus. Gli sviluppatori possono personalizzare

il modello di incorporazione,
lo schema di archiviazione e i metadati,
e le strategie di recupero (ad esempio, ricerca ibrida, ricerca partizionata).

In questo modo, ogni comunità di agenti dispone di un livello di memoria scalabile, persistente e ottimizzato per il ragionamento semantico.

Come costruire un chatbot multi-agente con OpenAgent e Milvus

Per rendere le cose concrete, vediamo una dimostrazione: costruire una comunità di supporto agli sviluppatori in cui più agenti specializzati - esperti di Python, esperti di database, ingegneri DevOps e altri - collaborano per rispondere a domande tecniche. Invece di affidarsi a un singolo agente generalista sovraccarico di lavoro, ogni esperto contribuisce con un ragionamento specifico sul dominio e il sistema indirizza automaticamente le richieste all'agente più adatto.

Questo esempio dimostra come integrare Milvus in una distribuzione OpenAgents per fornire una memoria a lungo termine per le domande e risposte tecniche. Le conversazioni degli agenti, le soluzioni passate, i registri di risoluzione dei problemi e le domande degli utenti vengono tutti convertiti in embeddings vettoriali e memorizzati in Milvus, dando alla rete la capacità di:

ricordare le risposte precedenti
riutilizzare le spiegazioni tecniche precedenti
mantenere la coerenza tra le sessioni e
migliorare nel tempo con l'accumularsi delle interazioni.

Prerequisiti

python3.11+
conda
Chiave Openai

1. Definire le dipendenze

Definire i pacchetti Python necessari per il progetto:

# 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. Variabili d'ambiente

Ecco il modello per la configurazione dell'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. Configurazione della rete OpenAgents

Definire la struttura della rete di agenti e le impostazioni di comunicazione:

# 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. Implementare la collaborazione tra più agenti

Di seguito sono riportati alcuni frammenti di codice (non l'implementazione 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. Creare e attivare un ambiente virtuale

conda create -n openagents
conda activate openagents

Installare le dipendenze

pip install -r requirements.txt

Configurare le chiavi API

cp .env.example .env

Avviare la rete OpenAgents

openagents network start .

Avviare il servizio multi-agente

python multi_agent_demo.py

Avviare OpenAgents Studio

openagents studio -s

Accedere a Studio

http://localhost:8050

Controllare lo stato degli agenti e della rete:

Conclusioni

OpenAgents fornisce il livello di coordinamento che consente agli agenti di scoprirsi, comunicare e collaborare, mentre Milvus risolve il problema altrettanto critico di come la conoscenza viene memorizzata, condivisa e riutilizzata. Fornendo un livello di memoria vettoriale ad alte prestazioni, Milvus consente agli agenti di costruire un contesto persistente, di ricordare le interazioni passate e di accumulare competenze nel tempo. Insieme, spingono i sistemi di intelligenza artificiale oltre i limiti dei modelli isolati e verso il potenziale collaborativo più profondo di una vera rete multiagente.

Naturalmente, nessuna architettura multiagente è priva di compromessi. L'esecuzione degli agenti in parallelo può aumentare il consumo di token, gli errori possono essere trasmessi a cascata tra gli agenti e il processo decisionale simultaneo può portare a conflitti occasionali. Si tratta di aree di ricerca attive e di miglioramento continuo, ma non sminuiscono il valore della costruzione di sistemi in grado di coordinarsi, ricordare ed evolvere.

🚀 Siete pronti a dare ai vostri agenti una memoria a lungo termine?

Esplorate Milvus e provate a integrarlo nel vostro flusso di lavoro.

Avete domande o volete un approfondimento su una qualsiasi funzione? Unitevi al nostro canale Discord o inviate problemi su GitHub. È anche possibile prenotare una sessione individuale di 20 minuti per ottenere approfondimenti, indicazioni e risposte alle vostre domande tramite Milvus Office Hours.