Home
Blog
OpenAgents x Milvus: Cara Membangun Sistem Multi-Agen yang Lebih Cerdas yang Berbagi Memori

OpenAgents x Milvus: Cara Membangun Sistem Multi-Agen yang Lebih Cerdas yang Berbagi Memori

Tutorials

November 24, 2025

Min Yin

Sebagian besar pengembang memulai sistem agen mereka dengan satu agen dan baru kemudian menyadari bahwa pada dasarnya mereka telah membangun chatbot yang sangat mahal. Untuk tugas-tugas sederhana, agen gaya ReAct bekerja dengan baik, tetapi dengan cepat mencapai batas: tidak dapat menjalankan langkah-langkah secara paralel, kehilangan jejak rantai penalaran yang panjang, dan cenderung berantakan setelah Anda menambahkan terlalu banyak alat ke dalam campuran. Pengaturan multi-agen menjanjikan untuk memperbaiki hal ini, tetapi mereka membawa masalah mereka sendiri: koordinasi di atas kepala, handoff yang rapuh, dan konteks bersama yang membengkak yang secara diam-diam mengikis kualitas model.

OpenAgents adalah kerangka kerja sumber terbuka untuk membangun sistem multi-agen di mana agen-agen AI bekerja bersama, berbagi sumber daya, dan menangani proyek-proyek jangka panjang dalam komunitas yang gigih. Alih-alih menggunakan satu orkestrator pusat, OpenAgents memungkinkan para agen berkolaborasi dengan cara yang lebih terdistribusi: mereka dapat menemukan satu sama lain, berkomunikasi, dan berkoordinasi untuk mencapai tujuan bersama.

Dipasangkan dengan basis data vektor Milvus, pipeline ini mendapatkan lapisan memori jangka panjang yang dapat diskalakan dan berkinerja tinggi. Milvus memperkuat memori agen dengan pencarian semantik yang cepat, pilihan pengindeksan yang fleksibel seperti HNSW dan IVF, dan isolasi yang bersih melalui partisi, sehingga agen dapat menyimpan, mengambil, dan menggunakan kembali pengetahuan tanpa tenggelam dalam konteks atau menginjak data satu sama lain.

Dalam tulisan ini, kita akan membahas bagaimana OpenAgents memungkinkan kolaborasi multi-agen terdistribusi, mengapa Milvus merupakan fondasi penting untuk memori agen yang dapat diskalakan, dan bagaimana cara merakit sistem seperti itu selangkah demi selangkah.

Tantangan dalam Membangun Sistem Agen Dunia Nyata

Banyak kerangka kerja agen utama saat ini-LangChain, AutoGen, CrewAI, dan lainnya-dibangun di sekitar model yang berpusat pada tugas. Anda membentuk sekumpulan agen, memberi mereka pekerjaan, mungkin mendefinisikan alur kerja, dan membiarkannya berjalan. Ini bekerja dengan baik untuk kasus penggunaan yang sempit atau berumur pendek, tetapi dalam lingkungan produksi yang sebenarnya, ini memperlihatkan tiga batasan struktural:

Pengetahuan tetap terkotak-kotak. Pengalaman agen terbatas pada penerapannya sendiri. Agen peninjau kode di bidang teknik tidak membagikan apa yang dipelajarinya kepada agen tim produk yang mengevaluasi kelayakan. Setiap tim akhirnya membangun kembali pengetahuan dari awal, yang tidak efisien dan rapuh.
Kolaborasi bersifat kaku. Bahkan dalam kerangka kerja multi-agen, kerja sama biasanya bergantung pada alur kerja yang telah ditentukan sebelumnya. Ketika kolaborasi perlu berubah, aturan statis ini tidak dapat beradaptasi, sehingga seluruh sistem menjadi kurang fleksibel.
Kurangnya keadaan yang persisten. Sebagian besar agen mengikuti siklus hidup yang sederhana: mulai → jalankan → matikan. Mereka melupakan segala sesuatu di antara konteks yang dijalankan, hubungan, keputusan yang dibuat, dan riwayat interaksi. Tanpa state yang persisten, agen tidak dapat membangun memori jangka panjang atau mengembangkan perilakunya.

Masalah struktural ini berasal dari memperlakukan agen sebagai pelaksana tugas yang terisolasi daripada peserta dalam jaringan kolaboratif yang lebih luas.

Tim OpenAgents percaya bahwa sistem agen masa depan membutuhkan lebih dari sekadar penalaran yang lebih kuat-mereka membutuhkan mekanisme yang memungkinkan para agen untuk menemukan satu sama lain, membangun hubungan, berbagi pengetahuan, dan bekerja sama secara dinamis. Dan yang terpenting, hal ini tidak boleh bergantung pada satu pengendali pusat. Internet bekerja karena terdistribusi-tidak ada satu simpul pun yang menentukan segalanya, dan sistem menjadi lebih kuat dan terukur seiring dengan pertumbuhannya. Sistem multi-agen mendapat manfaat dari prinsip desain yang sama. Itulah mengapa OpenAgents menghilangkan gagasan tentang orkestrator yang sangat kuat dan sebagai gantinya memungkinkan kerja sama yang terdesentralisasi dan digerakkan oleh jaringan.

Apa itu OpenAgents?

OpenAgents adalah kerangka kerja sumber terbuka untuk membangun jaringan agen AI yang memungkinkan kolaborasi terbuka, di mana agen-agen AI bekerja bersama, berbagi sumber daya, dan menangani proyek-proyek jangka panjang. OpenAgents menyediakan infrastruktur untuk internet agen - di mana agen berkolaborasi secara terbuka dengan jutaan agen lain dalam komunitas yang terus berkembang. Pada tingkat teknis, sistem ini terstruktur di sekitar tiga komponen inti: Jaringan Agen, Modifikasi Jaringan, dan Transportasi.

1. Jaringan Agen: Lingkungan Bersama untuk Kolaborasi

Jaringan agen adalah lingkungan bersama di mana beberapa agen dapat terhubung, berkomunikasi, dan bekerja sama untuk menyelesaikan tugas-tugas yang kompleks. Karakteristik intinya meliputi:

Operasi yang terus-menerus: Setelah dibuat, Jaringan tetap online secara independen dari satu tugas atau alur kerja.
Agen dinamis: Agen dapat bergabung kapan saja dengan menggunakan ID Jaringan; tidak perlu melakukan pra-pendaftaran.
Dukungan multi-protokol: Lapisan abstraksi terpadu mendukung komunikasi melalui WebSocket, gRPC, HTTP, dan libp2p.
Konfigurasi otonom: Setiap Jaringan memiliki izin, tata kelola, dan sumber dayanya sendiri.

Hanya dengan satu baris kode, Anda dapat menjalankan Jaringan, dan agen mana pun dapat segera bergabung melalui antarmuka standar.

2. Mod Jaringan: Ekstensi yang Dapat Dicolokkan untuk Kolaborasi

Mods menyediakan lapisan modular fitur kolaborasi yang tetap terpisah dari sistem inti. Anda dapat memadupadankan Mods berdasarkan kebutuhan spesifik Anda, memungkinkan pola kolaborasi yang disesuaikan dengan setiap kasus penggunaan.

Mod	Tujuan	Kasus penggunaan
Perpesanan Ruang Kerja	Komunikasi pesan waktu nyata	Tanggapan streaming, umpan balik instan
Forum	Diskusi asinkron	Tinjauan proposal, musyawarah multi-ronde
Wiki	Basis pengetahuan bersama	Konsolidasi pengetahuan, kolaborasi dokumen
Sosial	Grafik hubungan	Perutean ahli, jaringan kepercayaan

Semua Mods beroperasi pada sistem peristiwa terpadu, sehingga mudah untuk memperluas kerangka kerja atau memperkenalkan perilaku khusus kapan pun diperlukan.

3. Transportasi: Saluran Protokol-Agnostik untuk Komunikasi

Transports adalah protokol komunikasi yang memungkinkan agen-agen heterogen untuk terhubung dan bertukar pesan dalam jaringan OpenAgents. OpenAgents mendukung beberapa protokol transport yang dapat berjalan secara bersamaan di dalam jaringan yang sama, termasuk:

HTTP/REST untuk integrasi lintas bahasa yang luas
WebSocket untuk komunikasi dua arah dengan latensi rendah
gRPC untuk RPC berkinerja tinggi yang cocok untuk cluster berskala besar
libp2p untuk jaringan peer-to-peer yang terdesentralisasi
A2A, protokol baru yang dirancang khusus untuk komunikasi agen-ke-agen

Semua transportasi beroperasi melalui format pesan berbasis peristiwa terpadu, sehingga memungkinkan penerjemahan yang mulus antar protokol. Anda tidak perlu khawatir tentang protokol mana yang digunakan oleh agen peer - kerangka kerja menanganinya secara otomatis. Agen yang dibangun dalam bahasa atau kerangka kerja apa pun dapat bergabung dengan jaringan OpenAgents tanpa menulis ulang kode yang ada.

Mengintegrasikan OpenAgents dengan Milvus untuk Memori Agen Jangka Panjang

OpenAgents memecahkan tantangan tentang bagaimana agen berkomunikasi, menemukan satu sama lain, dan berkolaborasi - tetapikolaborasi saja tidak cukup. Agen menghasilkan wawasan, keputusan, riwayat percakapan, hasil alat, dan pengetahuan spesifik domain. Tanpa lapisan memori yang persisten, semua itu akan menguap begitu agen dimatikan.

Di sinilah Milvus menjadi penting. Milvus menyediakan penyimpanan vektor berkinerja tinggi dan pengambilan semantik yang diperlukan untuk mengubah interaksi agen menjadi memori yang tahan lama dan dapat digunakan kembali. Ketika diintegrasikan ke dalam jaringan OpenAgents, Milvus menawarkan tiga keuntungan utama:

1. Pencarian Semantik

Milvus memberikan pencarian semantik yang cepat menggunakan algoritma pengindeksan seperti HNSW dan IVF_FLAT. Agen dapat mengambil catatan historis yang paling relevan berdasarkan makna, bukan kata kunci, sehingga memungkinkan mereka untuk

mengingat keputusan atau rencana sebelumnya,
menghindari pengulangan pekerjaan,
mempertahankan konteks cakrawala panjang di seluruh sesi.

Ini adalah tulang punggung memori agen: pengambilan yang cepat, relevan, dan kontekstual.

2. Skalabilitas Horizontal Berskala Miliaran

Jaringan agen nyata menghasilkan data dalam jumlah besar. Milvus dibangun untuk beroperasi dengan nyaman pada skala ini, menawarkan:

penyimpanan dan pencarian lebih dari miliaran vektor,
Latensi <30 ms bahkan dalam pengambilan Top-K dengan throughput tinggi,
arsitektur terdistribusi penuh yang berkembang secara linear seiring dengan meningkatnya permintaan.

Apakah Anda memiliki selusin agen atau ribuan agen yang bekerja secara paralel, Milvus menjaga pengambilan dengan cepat dan konsisten.

3. Isolasi Multi-Penyewa

Milvus menyediakan isolasi multi-tenant granular melalui Partition Key, mekanisme partisi ringan yang menyegmentasikan memori di dalam satu koleksi. Hal ini memungkinkan:

tim, proyek, atau komunitas agen yang berbeda untuk mempertahankan ruang memori yang independen,
biaya overhead yang jauh lebih rendah dibandingkan dengan mempertahankan banyak koleksi,
pengambilan lintas partisi opsional ketika pengetahuan bersama diperlukan.

Isolasi ini sangat penting untuk penyebaran multi-agen yang besar di mana batas-batas data harus dihormati tanpa mengorbankan kecepatan pengambilan.

OpenAgents terhubung ke Milvus melalui Mod khusus yang memanggil API Milvus secara langsung. Pesan agen, keluaran alat, dan log interaksi secara otomatis disematkan ke dalam vektor dan disimpan di Milvus. Pengembang dapat menyesuaikan:

model penyematan,
skema penyimpanan dan metadata,
dan strategi pengambilan (misalnya, pencarian hibrida, pencarian terpartisi).

Hal ini memberikan setiap komunitas agen sebuah lapisan memori yang dapat diskalakan, persisten, dan dioptimalkan untuk penalaran semantik.

Cara Membangun Chatbot Multi-Agen dengan OpenAgent dan Milvus

Untuk memperjelasnya, mari kita lihat sebuah demo: membangun komunitas dukungan pengembang di mana beberapa agen spesialis - pakar Python, pakar database, insinyur DevOps, dan banyak lagi - berkolaborasi untuk menjawab pertanyaan teknis. Alih-alih mengandalkan satu agen generalis yang terlalu banyak bekerja, setiap ahli menyumbangkan penalaran spesifik domain, dan sistem mengarahkan pertanyaan ke agen yang paling cocok secara otomatis.

Contoh ini menunjukkan cara mengintegrasikan Milvus ke dalam penerapan OpenAgents untuk menyediakan memori jangka panjang untuk tanya jawab teknis. Percakapan agen, solusi sebelumnya, log pemecahan masalah, dan pertanyaan pengguna semuanya dikonversi ke dalam penyematan vektor dan disimpan di Milvus, sehingga memberikan kemampuan kepada jaringan untuk

mengingat jawaban sebelumnya,
menggunakan kembali penjelasan teknis sebelumnya,
menjaga konsistensi di seluruh sesi, dan
meningkat dari waktu ke waktu seiring dengan bertambahnya interaksi.

Prasyarat

python3.11+
conda
Openai-key

1. Mendefinisikan Ketergantungan

Tentukan paket Python yang diperlukan untuk proyek:

# 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. Variabel Lingkungan

Berikut ini adalah templat untuk konfigurasi lingkungan Anda:

# 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. Mengkonfigurasi Jaringan OpenAgents Anda

Tentukan struktur jaringan agen Anda dan pengaturan komunikasinya:

# 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. Menerapkan Kolaborasi Multi-Agen

Berikut ini adalah cuplikan kode inti (bukan implementasi penuh).

# 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. Membuat dan Mengaktifkan Lingkungan Virtual

conda create -n openagents
conda activate openagents

Menginstal Ketergantungan

pip install -r requirements.txt

Mengonfigurasi Kunci API

cp .env.example .env

Memulai Jaringan OpenAgents

openagents network start .

Memulai Layanan Multi-Agen

python multi_agent_demo.py

Memulai OpenAgents Studio

openagents studio -s

Akses Studio

http://localhost:8050

Periksa status agen dan jaringan Anda:

Kesimpulan

OpenAgents menyediakan lapisan koordinasi yang memungkinkan para agen menemukan satu sama lain, berkomunikasi, dan berkolaborasi, sementara Milvus memecahkan masalah yang sama pentingnya yaitu bagaimana pengetahuan disimpan, dibagikan, dan digunakan kembali. Dengan menghadirkan lapisan memori vektor berkinerja tinggi, Milvus memungkinkan agen untuk membangun konteks yang persisten, mengingat kembali interaksi masa lalu, dan mengakumulasi keahlian dari waktu ke waktu. Bersama-sama, mereka mendorong sistem AI melampaui batas-batas model yang terisolasi dan menuju potensi kolaboratif yang lebih dalam dari jaringan multi-agen yang sebenarnya.

Tentu saja, tidak ada arsitektur multi-agen yang tanpa trade-off. Menjalankan agen secara paralel dapat meningkatkan konsumsi token, kesalahan dapat mengalir di seluruh agen, dan pengambilan keputusan secara simultan dapat menyebabkan konflik sesekali. Ini adalah area penelitian aktif dan perbaikan yang sedang berlangsung - tetapi tidak mengurangi nilai membangun sistem yang dapat berkoordinasi, mengingat, dan berevolusi.

🚀 Siap memberikan memori jangka panjang kepada agen Anda?

Jelajahi Milvus dan coba integrasikan dengan alur kerja Anda.

Ada pertanyaan atau ingin mendalami fitur apa pun? Bergabunglah dengan saluran Discord kami atau ajukan pertanyaan di GitHub. Anda juga dapat memesan sesi tatap muka selama 20 menit untuk mendapatkan wawasan, panduan, dan jawaban atas pertanyaan Anda melalui Milvus Office Hours.