Home
Blog
OpenAgents x Milvus: Wie man intelligentere Multi-Agenten-Systeme mit gemeinsamem Speicher aufbaut

OpenAgents x Milvus: Wie man intelligentere Multi-Agenten-Systeme mit gemeinsamem Speicher aufbaut

Tutorials

November 24, 2025

Min Yin

Die meisten Entwickler beginnen ihre agentischen Systeme mit einem einzigen Agenten und stellen erst später fest, dass sie im Grunde einen sehr teuren Chatbot gebaut haben. Für einfache Aufgaben funktioniert ein Agent im Stil von ReAct gut, aber er stößt schnell an seine Grenzen: Er kann keine Schritte parallel ausführen, er verliert den Überblick über lange Argumentationsketten und er neigt dazu, auseinanderzufallen, sobald man zu viele Tools in den Mix einbringt. Multi-Agenten-Setups versprechen, dies zu beheben, aber sie bringen ihre eigenen Probleme mit sich: Koordinationsaufwand, brüchige Übergaben und ein ausufernder gemeinsamer Kontext, der die Qualität des Modells leise untergräbt.

OpenAgents ist ein Open-Source-Framework für den Aufbau von Multi-Agenten-Systemen, in denen KI-Agenten zusammenarbeiten, Ressourcen gemeinsam nutzen und Projekte mit langen Laufzeiten in dauerhaften Gemeinschaften angehen. Anstelle eines einzigen zentralen Orchestrators ermöglicht OpenAgents den Agenten eine verteilte Zusammenarbeit: Sie können sich gegenseitig entdecken, kommunizieren und sich auf gemeinsame Ziele hin koordinieren.

In Verbindung mit der Vektordatenbank Milvus erhält diese Pipeline eine skalierbare, leistungsstarke Langzeitspeicherschicht. Milvus unterstützt den Agentenspeicher mit einer schnellen semantischen Suche, flexiblen Indizierungsoptionen wie HNSW und IVF und einer sauberen Isolierung durch Partitionierung, so dass Agenten Wissen speichern, abrufen und wiederverwenden können, ohne im Kontext zu ertrinken oder auf die Daten der anderen zu treten.

In diesem Beitrag gehen wir darauf ein, wie OpenAgents die verteilte Zusammenarbeit mehrerer Agenten ermöglicht, warum Milvus eine wichtige Grundlage für einen skalierbaren Agentenspeicher ist und wie man ein solches System Schritt für Schritt zusammenstellt.

Herausforderungen beim Aufbau von Agentensystemen in der realen Welt

Viele der heute gängigen Agenten-Frameworks - LongChain, AutoGen, CrewAI und andere - basieren auf einem aufgabenzentrierten Modell. Man stellt eine Reihe von Agenten zusammen, gibt ihnen eine Aufgabe, definiert vielleicht einen Workflow und lässt sie laufen. Dies funktioniert gut für enge oder kurzlebige Anwendungsfälle, aber in echten Produktionsumgebungen stößt man auf drei strukturelle Einschränkungen:

Das Wissen bleibt isoliert. Die Erfahrungen eines Agenten beschränken sich auf seinen eigenen Einsatz. Ein Agent in der Entwicklungsabteilung, der den Code prüft, teilt seine Erkenntnisse nicht mit einem Agenten des Produktteams, der die Machbarkeit prüft. Am Ende muss jedes Team sein Wissen von Grund auf neu aufbauen, was sowohl ineffizient als auch brüchig ist.
Die Zusammenarbeit ist starr. Selbst in Multi-Agenten-Frameworks hängt die Zusammenarbeit in der Regel von im Voraus definierten Arbeitsabläufen ab. Wenn sich die Zusammenarbeit ändern muss, können diese statischen Regeln nicht angepasst werden, was das gesamte System weniger flexibel macht.
Fehlen eines dauerhaften Zustands. Die meisten Agenten folgen einem einfachen Lebenszyklus: Starten → Ausführen → Beenden. Zwischen den einzelnen Durchläufen vergessen sie alles - Kontext, Beziehungen, getroffene Entscheidungen und Interaktionsverlauf. Ohne einen dauerhaften Zustand können Agenten kein Langzeitgedächtnis aufbauen oder ihr Verhalten weiterentwickeln.

Diese strukturellen Probleme rühren daher, dass Agenten als isolierte Ausführer von Aufgaben behandelt werden und nicht als Teilnehmer an einem breiteren kollaborativen Netzwerk.

Das OpenAgents-Team ist der Meinung, dass zukünftige Agentensysteme mehr als nur eine stärkere Argumentation benötigen - sie brauchen einen Mechanismus, der es den Agenten ermöglicht, sich gegenseitig zu entdecken, Beziehungen aufzubauen, Wissen zu teilen und dynamisch zusammenzuarbeiten. Und dies sollte nicht von einem einzigen zentralen Controller abhängen. Das Internet funktioniert, weil es verteilt ist - kein einzelner Knotenpunkt bestimmt alles, und das System wird robuster und skalierbarer, wenn es wächst. Multiagentensysteme profitieren von demselben Prinzip. Deshalb beseitigt OpenAgents die Idee eines allmächtigen Orchestrators und ermöglicht stattdessen eine dezentralisierte, netzwerkgesteuerte Zusammenarbeit.

Was ist OpenAgents?

OpenAgents ist ein Open-Source-Framework für den Aufbau von KI-Agenten-Netzwerken, das eine offene Zusammenarbeit ermöglicht, bei der KI-Agenten zusammenarbeiten, Ressourcen gemeinsam nutzen und langfristige Projekte in Angriff nehmen. Es bietet die Infrastruktur für ein Internet der Agenten, in dem Agenten offen mit Millionen anderer Agenten in dauerhaften, wachsenden Gemeinschaften zusammenarbeiten. Auf technischer Ebene ist das System um drei Kernkomponenten herum aufgebaut: Agentennetzwerk, Netzwerk-Mods und Transporte.

1. Agentennetzwerk: Ein gemeinsames Umfeld für die Zusammenarbeit

Ein Agentennetzwerk ist eine gemeinsame Umgebung, in der sich mehrere Agenten verbinden, kommunizieren und zusammenarbeiten können, um komplexe Aufgaben zu lösen. Zu seinen Hauptmerkmalen gehören:

Dauerhafter Betrieb: Einmal erstellt, bleibt das Netzwerk unabhängig von einer einzelnen Aufgabe oder einem Arbeitsablauf online.
Dynamische Agenten: Agenten können jederzeit mit einer Netzwerk-ID beitreten; eine Vorregistrierung ist nicht erforderlich.
Unterstützung mehrerer Protokolle: Eine einheitliche Abstraktionsschicht unterstützt die Kommunikation über WebSocket, gRPC, HTTP und libp2p.
Autonome Konfiguration: Jedes Netzwerk verwaltet seine eigenen Berechtigungen, Governance und Ressourcen.

Mit nur einer Zeile Code können Sie ein Netzwerk einrichten, und jeder Agent kann über Standardschnittstellen sofort beitreten.

2. Netzwerk-Mods: Steckbare Erweiterungen für die Zusammenarbeit

Mods bieten eine modulare Schicht von Kollaborationsfunktionen, die vom Kernsystem entkoppelt bleiben. Sie können Mods je nach Ihren spezifischen Anforderungen kombinieren und so auf jeden Anwendungsfall zugeschnittene Kooperationsmuster ermöglichen.

Mod	Zweck	Anwendungsfälle
Arbeitsbereich Messaging	Nachrichtenkommunikation in Echtzeit	Streaming-Antworten, sofortiges Feedback
Forum	Asynchrone Diskussion	Überprüfung von Vorschlägen, Beratung in mehreren Runden
Wiki	Gemeinsame Wissensbasis	Wissenskonsolidierung, Zusammenarbeit bei Dokumenten
Soziales	Beziehungsdiagramm	Experten-Routing, Vertrauensnetzwerke

Alle Mods arbeiten mit einem einheitlichen Ereignissystem, so dass es einfach ist, den Rahmen zu erweitern oder benutzerdefinierte Verhaltensweisen einzuführen, wann immer dies erforderlich ist.

3. Transporte: Ein protokoll-agnostischer Kommunikationskanal

Transports sind die Kommunikationsprotokolle, die es heterogenen Agenten ermöglichen, sich zu verbinden und Nachrichten innerhalb eines OpenAgents-Netzwerks auszutauschen. OpenAgents unterstützt mehrere Transportprotokolle, die gleichzeitig innerhalb desselben Netzes laufen können, darunter:

HTTP/REST für eine breite, sprachübergreifende Integration
WebSocket für bidirektionale Kommunikation mit niedriger Latenz
gRPC für Hochleistungs-RPC, geeignet für große Cluster
libp2p für dezentralisierte Peer-to-Peer-Netzwerke
A2A, ein aufkommendes Protokoll, das speziell für die Kommunikation von Agent zu Agent entwickelt wurde

Alle Transporte funktionieren über ein einheitliches, ereignisbasiertes Nachrichtenformat, das eine nahtlose Übersetzung zwischen den Protokollen ermöglicht. Sie müssen sich nicht darum kümmern, welches Protokoll ein Peer-Agent verwendet - das Framework erledigt dies automatisch. Agenten, die in einer beliebigen Sprache oder einem beliebigen Framework erstellt wurden, können einem OpenAgents-Netzwerk beitreten, ohne dass vorhandener Code umgeschrieben werden muss.

Integration von OpenAgents mit Milvus für ein langfristiges Agentengedächtnis

OpenAgents löst die Herausforderung, wie Agenten kommunizieren, sich gegenseitig entdecken und zusammenarbeiten - aberZusammenarbeit allein ist nicht genug. Agenten generieren Erkenntnisse, Entscheidungen, Gesprächsverläufe, Toolergebnisse und domänenspezifisches Wissen. Ohne eine persistente Speicherebene verpufft all dies in dem Moment, in dem ein Agent heruntergefahren wird.

An dieser Stelle wird Milvus unverzichtbar. Milvus bietet den leistungsstarken Vektorspeicher und die semantische Abfrage, die erforderlich sind, um Agenteninteraktionen in einen dauerhaften, wiederverwendbaren Speicher zu verwandeln. Wenn es in das OpenAgents-Netzwerk integriert wird, bietet es drei wesentliche Vorteile:

1. Semantische Suche

Milvus bietet eine schnelle semantische Suche mit Indexierungsalgorithmen wie HNSW und IVF_FLAT. Agenten können die relevantesten historischen Aufzeichnungen auf der Grundlage von Bedeutungen und nicht von Schlüsselwörtern abrufen, was es ihnen ermöglicht:

frühere Entscheidungen oder Pläne abzurufen,
die Wiederholung von Arbeit zu vermeiden,
einen langfristigen Kontext über mehrere Sitzungen hinweg aufrechtzuerhalten.

Dies ist das Rückgrat des agenturischen Gedächtnisses: schnelles, relevantes und kontextbezogenes Abrufen.

2. Horizontale Skalierbarkeit im Milliardenmaßstab

Echte Agentennetzwerke erzeugen riesige Datenmengen. Milvus ist für einen komfortablen Betrieb in diesem Umfang ausgelegt und bietet:

Speicherung und Suche über Milliarden von Vektoren,
< 30 ms Latenzzeit selbst bei Top-K-Abrufen mit hohem Durchsatz,
eine vollständig verteilte Architektur, die bei wachsendem Bedarf linear skaliert.

Egal, ob Sie ein Dutzend Agenten oder Tausende parallel arbeiten lassen, Milvus sorgt für eine schnelle und konsistente Abfrage.

3. Multi-Mandanten-Isolierung

Milvus bietet eine granulare Multi-Tenant-Isolation durch Partition Key, einen leichtgewichtigen Partitionierungsmechanismus, der den Speicher innerhalb einer einzigen Sammlung segmentiert. Dies ermöglicht:

Verschiedene Teams, Projekte oder Agentengemeinschaften können unabhängige Speicherbereiche verwalten,
einen drastisch geringeren Overhead im Vergleich zur Verwaltung mehrerer Sammlungen,
optionales Abrufen von Wissen über mehrere Partitionen hinweg, wenn gemeinsames Wissen benötigt wird.

Diese Isolierung ist entscheidend für große Multi-Agent-Einsätze, bei denen Datengrenzen respektiert werden müssen, ohne die Abrufgeschwindigkeit zu beeinträchtigen.

OpenAgents stellt die Verbindung zu Milvus über benutzerdefinierte Mods her, die Milvus-APIs direkt aufrufen. Agentenmeldungen, Toolausgaben und Interaktionsprotokolle werden automatisch in Vektoren eingebettet und in Milvus gespeichert. Entwickler können anpassen:

das Einbettungsmodell,
das Speicherschema und die Metadaten,
und Abrufstrategien (z. B. hybride Suche, partitionierte Suche).

Dadurch erhält jede Agentengemeinschaft eine Speicherebene, die skalierbar, beständig und für semantische Schlussfolgerungen optimiert ist.

Wie man einen Multi-Agenten-Chatbot mit OpenAgent und Milvus erstellt

Um die Dinge konkret zu machen, lassen Sie uns eine Demo durchgehen: Aufbau einer Entwickler-Support-Community, in der mehrere spezialisierte Agenten - Python-Experten, Datenbankexperten, DevOps-Ingenieure und andere - zusammenarbeiten, um technische Fragen zu beantworten. Anstatt sich auf einen einzigen überlasteten Generalisten-Agenten zu verlassen, steuert jeder Experte domänenspezifische Argumente bei, und das System leitet Anfragen automatisch an den am besten geeigneten Agenten weiter.

Dieses Beispiel zeigt, wie Milvus in einen OpenAgents-Einsatz integriert werden kann, um ein Langzeitgedächtnis für technische Fragen und Antworten bereitzustellen. Agentengespräche, frühere Lösungen, Fehlerbehebungsprotokolle und Benutzeranfragen werden alle in Vektoreinbettungen umgewandelt und in Milvus gespeichert, so dass das Netzwerk in der Lage ist:

sich an frühere Antworten zu erinnern,
frühere technische Erklärungen wiederzuverwenden,
die Konsistenz über Sitzungen hinweg aufrechtzuerhalten und
sich im Laufe der Zeit zu verbessern, wenn sich mehr Interaktionen ansammeln.

Voraussetzung

python3.11+
conda
Openai-Schlüssel

1. Abhängigkeiten definieren

Definieren Sie die für das Projekt benötigten Python-Pakete:

# 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. Umgebungsvariablen

Hier finden Sie die Vorlage für Ihre Umgebungskonfiguration:

# 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. Konfigurieren Sie Ihr OpenAgents-Netzwerk

Definieren Sie die Struktur Ihres Agentennetzes und seine Kommunikationseinstellungen:

# 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. Implementieren Sie die Multi-Agenten-Zusammenarbeit

Im Folgenden finden Sie die wichtigsten Codeschnipsel (nicht die vollständige Implementierung).

# 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. Erstellen und Aktivieren einer virtuellen Umgebung

conda create -n openagents
conda activate openagents

Abhängigkeiten installieren

pip install -r requirements.txt

API-Schlüssel konfigurieren

cp .env.example .env

Starten Sie das OpenAgents-Netzwerk

openagents network start .

Starten Sie den Multi-Agenten-Dienst

python multi_agent_demo.py

OpenAgents Studio starten

openagents studio -s

Zugang zum Studio

http://localhost:8050

Überprüfen Sie den Status Ihrer Agenten und Ihres Netzwerks:

Schlussfolgerung

OpenAgents stellt die Koordinationsschicht bereit, die es Agenten ermöglicht, sich gegenseitig zu entdecken, zu kommunizieren und zusammenzuarbeiten, während Milvus das ebenso kritische Problem löst, wie Wissen gespeichert, gemeinsam genutzt und wiederverwendet wird. Durch die Bereitstellung einer hochleistungsfähigen Vektorspeicherschicht ermöglicht Milvus den Agenten den Aufbau eines dauerhaften Kontexts, die Erinnerung an vergangene Interaktionen und die Anhäufung von Fachwissen im Laufe der Zeit. Zusammen bringen sie KI-Systeme über die Grenzen isolierter Modelle hinaus und in Richtung des tieferen kollaborativen Potenzials eines echten Multi-Agenten-Netzwerks.

Natürlich ist keine Multi-Agenten-Architektur ohne Kompromisse. Die parallele Ausführung von Agenten kann den Token-Verbrauch erhöhen, Fehler können sich über die Agenten hinweg ausbreiten, und die gleichzeitige Entscheidungsfindung kann zu gelegentlichen Konflikten führen. Dies sind Bereiche, in denen noch geforscht und Verbesserungen vorgenommen werden, aber sie schmälern nicht den Wert von Systemen, die sich koordinieren, erinnern und weiterentwickeln können.

🚀 Sind Sie bereit, Ihren Agenten ein Langzeitgedächtnis zu verleihen?

Lernen Sie Milvus kennen und versuchen Sie, es in Ihren eigenen Arbeitsablauf zu integrieren.

Haben Sie Fragen oder möchten Sie eine Funktion genauer kennenlernen? Treten Sie unserem Discord-Kanal bei oder stellen Sie Fragen auf GitHub. Sie können auch eine 20-minütige Einzelsitzung buchen, um Einblicke, Anleitung und Antworten auf Ihre Fragen in den Milvus-Sprechstunden zu erhalten.