Home
Blog
OpenAgents x Milvus: как создавать более умные мультиагентные системы с общей памятью

OpenAgents x Milvus: как создавать более умные мультиагентные системы с общей памятью

Tutorials

November 24, 2025

Min Yin

Большинство разработчиков начинают свои агентные системы с одного агента и только потом понимают, что, по сути, создали очень дорогой чатбот. Для простых задач агент в стиле ReAct работает хорошо, но быстро наступает предел: он не может выполнять шаги параллельно, теряет контроль над длинными цепочками рассуждений и имеет тенденцию разваливаться, как только вы добавляете слишком много инструментов. Многоагентные системы обещают решить эту проблему, но они несут свои собственные проблемы: накладные расходы на координацию, хрупкие передачи и раздувающийся общий контекст, который незаметно снижает качество модели.

OpenAgents - это фреймворк с открытым исходным кодом для создания мультиагентных систем, в которых агенты ИИ работают вместе, делятся ресурсами и решают долгосрочные проекты в рамках постоянных сообществ. Вместо единого центрального организатора OpenAgents позволяет агентам сотрудничать более распределенным образом: они могут обнаруживать друг друга, общаться и координироваться вокруг общих целей.

В сочетании с векторной базой данных Milvus этот конвейер получает масштабируемый и высокопроизводительный слой долговременной памяти. Milvus обеспечивает память агентов быстрым семантическим поиском, гибкими вариантами индексирования, такими как HNSW и IVF, и чистой изоляцией с помощью разбиения на разделы, поэтому агенты могут хранить, извлекать и повторно использовать знания, не утопая в контексте и не наступая на данные друг друга.

В этом посте мы расскажем, как OpenAgents обеспечивает распределенное мультиагентное взаимодействие, почему Milvus является критической основой для масштабируемой памяти агентов, и как собрать такую систему шаг за шагом.

Проблемы создания агентных систем реального мира

Многие современные агентные фреймворки - LangChain, AutoGen, CrewAI и другие - построены на модели , ориентированной на выполнение задач. Вы запускаете набор агентов, даете им задание, возможно, определяете рабочий процесс, и они начинают работать. Это хорошо подходит для узких или недолговечных случаев использования, но в реальных производственных средах это приводит к трем структурным ограничениям:

Знания остаются изолированными. Опыт агента ограничивается его собственным развертыванием. Агент, проверяющий код в инженерном отделе, не делится своими знаниями с агентом команды разработчиков продукта, оценивающим целесообразность. В итоге каждой команде приходится восстанавливать знания с нуля, что неэффективно и хрупко.
Сотрудничество негибкое. Даже в мультиагентных системах сотрудничество обычно зависит от рабочих процессов, определенных заранее. Когда сотрудничество должно измениться, эти статичные правила не могут адаптироваться, что делает всю систему менее гибкой.
Отсутствие постоянного состояния. Большинство агентов следуют простому жизненному циклу: запуск → выполнение → завершение работы. Они забывают обо всем между циклами - о контексте, отношениях, принятых решениях и истории взаимодействия. Без постоянного состояния агенты не могут создать долгосрочную память или изменить свое поведение.

Эти структурные проблемы возникают из-за того, что агенты рассматриваются как изолированные исполнители задач, а не как участники более широкой сети сотрудничества.

Команда OpenAgents считает, что будущие агентные системы нуждаются не только в более сильных рассуждениях - им нужен механизм, позволяющий агентам обнаруживать друг друга, строить отношения, обмениваться знаниями и динамически работать вместе. И что очень важно, это не должно зависеть от одного центрального контроллера. Интернет работает потому, что он распределен - ни один узел не диктует все, и система становится более надежной и масштабируемой по мере ее роста. Мультиагентные системы выигрывают от того же принципа проектирования. Именно поэтому OpenAgents отказывается от идеи всемогущего организатора и вместо этого обеспечивает децентрализованное, управляемое сетью сотрудничество.

Что такое OpenAgents?

OpenAgents - это фреймворк с открытым исходным кодом для создания сетей агентов ИИ, который обеспечивает открытое сотрудничество, где агенты ИИ работают вместе, делятся ресурсами и решают долгосрочные проекты. Она обеспечивает инфраструктуру для Интернета агентов - где агенты открыто сотрудничают с миллионами других агентов в постоянных, растущих сообществах. На техническом уровне система состоит из трех основных компонентов: Сеть агентов, сетевые моды и транспорты.

1. Сеть агентов: Общая среда для совместной работы

Агентская сеть - это общая среда, в которой несколько агентов могут подключаться, общаться и работать вместе для решения сложных задач. Ее основные характеристики включают:

Постоянная работа: Созданная однажды, сеть остается в режиме онлайн независимо от отдельной задачи или рабочего процесса.
Динамический агент: Агенты могут присоединиться к сети в любой момент, используя идентификатор сети; предварительная регистрация не требуется.
Поддержка нескольких протоколов: Унифицированный уровень абстракции поддерживает взаимодействие через WebSocket, gRPC, HTTP и libp2p.
Автономная конфигурация: Каждая сеть поддерживает свои собственные разрешения, управление и ресурсы.

Всего одна строка кода позволяет создать Сеть, и любой агент может немедленно присоединиться к ней через стандартные интерфейсы.

2. Сетевые модули: Подключаемые расширения для совместной работы

Модули обеспечивают модульный уровень функций совместной работы, который остается независимым от основной системы. Вы можете смешивать и сочетать модули в зависимости от ваших конкретных потребностей, обеспечивая шаблоны совместной работы, адаптированные к каждому случаю использования.

Мод	Назначение	Примеры использования
Обмен сообщениями в рабочем пространстве	Обмен сообщениями в режиме реального времени	Потоковые ответы, мгновенная обратная связь
Форум	Асинхронное обсуждение	Рассмотрение предложений, многораундовое обсуждение
Вики	Общая база знаний	Консолидация знаний, совместная работа над документами
Социальная	Граф отношений	Маршрутизация экспертов, сети доверия

Все модули работают на единой системе событий, что позволяет легко расширять фреймворк или внедрять пользовательское поведение, когда это необходимо.

3. Транспорты: Протокольно-агностический канал для коммуникации

Транспорты - это коммуникационные протоколы, которые позволяют разнородным агентам соединяться и обмениваться сообщениями в сети OpenAgents. OpenAgents поддерживает несколько транспортных протоколов, которые могут работать одновременно в одной сети, включая:

HTTP/REST для широкой межъязыковой интеграции
WebSocket для двунаправленного обмена данными с низкой задержкой
gRPC для высокопроизводительного RPC, подходящего для крупномасштабных кластеров
libp2p для децентрализованной одноранговой сети
A2A, новый протокол, разработанный специально для связи между агентами.

Все транспорты работают через единый формат сообщений, основанный на событиях, что позволяет легко переводить их между протоколами. Вам не нужно беспокоиться о том, какой протокол использует агент-агент - фреймворк справится с этим автоматически. Агенты, созданные на любом языке или фреймворке, могут присоединиться к сети OpenAgents, не переписывая существующий код.

Интеграция OpenAgents с Milvus для долговременной агентской памяти

OpenAgents решает проблему того, как агенты общаются, обнаруживают друг друга и сотрудничают, ноодного сотрудничества недостаточно. Агенты генерируют идеи, решения, историю разговоров, результаты работы инструментов и знания, специфичные для конкретной области. Без слоя постоянной памяти все это испарится в тот момент, когда агент выключится.

Именно здесь Milvus становится незаменимым. Milvus обеспечивает высокопроизводительное векторное хранение и семантический поиск, необходимые для превращения взаимодействий агентов в долговременную память многократного использования. При интеграции в сеть OpenAgents он предлагает три основных преимущества:

1. Семантический поиск

Milvus обеспечивает быстрый семантический поиск с использованием таких алгоритмов индексирования, как HNSW и IVF_FLAT. Агенты могут извлекать наиболее значимые исторические записи на основе смысла, а не ключевых слов, что позволяет им:

вспомнить предыдущие решения или планы,
избегать повторения работы,
поддерживать долгосрочный контекст во время сеансов.

Это основа агентской памяти: быстрое, релевантное, контекстное извлечение информации.

2. Горизонтальная масштабируемость в миллиардных масштабах

Реальные агентские сети генерируют огромные объемы данных. Milvus создан для комфортной работы в таких масштабах, предлагая:

хранение и поиск по миллиардам векторов,
задержки < 30 мс даже при высокопроизводительном поиске по методу Top-K,
полностью распределенную архитектуру, которая линейно масштабируется по мере роста спроса.

Независимо от того, работает ли у вас десяток агентов или тысячи параллельно, Milvus обеспечивает быстрый и последовательный поиск.

3. Изоляция нескольких арендаторов

Milvus обеспечивает гранулированную многопользовательскую изоляцию с помощью Partition Key- легкого механизма разделения, который сегментирует память внутри одной коллекции. Это позволяет:

различным командам, проектам или сообществам агентов поддерживать независимые пространства памяти,
значительно снизить накладные расходы по сравнению с поддержкой нескольких коллекций,
опциональный межраздельный поиск, когда необходимы общие знания.

Такая изоляция очень важна для крупных мультиагентных развертываний, где границы данных должны соблюдаться без ущерба для скорости поиска.

OpenAgents подключается к Milvus через пользовательские модули, которые напрямую вызывают API Milvus. Сообщения агентов, результаты работы инструментов и журналы взаимодействия автоматически встраиваются в векторы и хранятся в Milvus. Разработчики могут настраивать:

модель встраивания,
схему хранения и метаданные,
и стратегии поиска (например, гибридный поиск, поиск по разделам).

Таким образом, каждое сообщество агентов получает слой памяти, который является масштабируемым, постоянным и оптимизированным для семантических рассуждений.

Как построить многоагентный чатбот с помощью OpenAgent и Milvus

Чтобы конкретизировать ситуацию, давайте рассмотрим демонстрационный пример: создание сообщества поддержки разработчиков, в котором несколько агентов-специалистов - эксперты в области программирования на языке Python, эксперты по базам данных, инженеры DevOps и другие - сотрудничают для ответа на технические вопросы. Вместо того чтобы полагаться на одного перегруженного работой агента широкого профиля, каждый эксперт вносит свой вклад в рассуждения о конкретной области, а система автоматически направляет запросы к наиболее подходящему агенту.

Этот пример демонстрирует, как интегрировать Milvus в развертывание OpenAgents, чтобы обеспечить долговременную память для технических вопросов и ответов. Разговоры агентов, прошлые решения, журналы устранения неполадок и запросы пользователей преобразуются в векторные вкрапления и хранятся в Milvus, обеспечивая сети возможность

запоминать предыдущие ответы,
повторно использовать предыдущие технические объяснения,
поддерживать согласованность между сессиями и
улучшаться с течением времени по мере накопления количества взаимодействий.

Необходимые условия

python3.11+
conda
Openai-key

1. Определение зависимостей

Определите пакеты Python, необходимые для проекта:

# 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. Переменные окружения

Здесь приведен шаблон для настройки окружения:

# 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. Настройка сети OpenAgents

Определите структуру сети агентов и параметры связи:

# 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. Реализация совместной работы нескольких агентов

Ниже показаны основные фрагменты кода (не полная реализация).

# 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. Создание и активация виртуальной среды

conda create -n openagents
conda activate openagents

Установка зависимостей

pip install -r requirements.txt

Настройте ключи API

cp .env.example .env

Запуск сети OpenAgents

openagents network start .

Запустите мультиагентную службу

python multi_agent_demo.py

Запуск OpenAgents Studio

openagents studio -s

Доступ к студии

http://localhost:8050

Проверьте состояние агентов и сети:

Заключение

OpenAgents обеспечивает координационный слой, позволяющий агентам обнаруживать друг друга, общаться и сотрудничать, а Milvus решает не менее важную проблему хранения, обмена и повторного использования знаний. Предоставляя высокопроизводительный слой векторной памяти, Milvus позволяет агентам создавать постоянный контекст, вспоминать прошлые взаимодействия и накапливать опыт с течением времени. Вместе они выводят системы искусственного интеллекта за пределы изолированных моделей и открывают более глубокий совместный потенциал настоящей мультиагентной сети.

Конечно, ни одна мультиагентная архитектура не обходится без компромиссов. Параллельный запуск агентов может увеличить потребление токенов, ошибки могут передаваться от одного агента к другому, а одновременное принятие решений может привести к конфликтам. Это активные области исследований и постоянного совершенствования, но они не умаляют ценности создания систем, которые могут координировать, запоминать и развиваться.

🚀 Готовы наделить своих агентов долговременной памятью?

Изучите Milvus и попробуйте интегрировать его в свой рабочий процесс.

У вас есть вопросы или вы хотите получить подробную информацию о какой-либо функции? Присоединяйтесь к нашему каналу Discord или создавайте проблемы на GitHub. Вы также можете заказать 20-минутную индивидуальную сессию, чтобы получить знания, рекомендации и ответы на свои вопросы в Milvus Office Hours.