Как создавать готовые к производству агенты искусственного интеллекта с помощью Deep Agents и Milvus

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

Такие фреймворки, как Deep Agents, выпущенные компанией LangChain, помогают организовать эти рабочие процессы. Он предоставляет структурированный способ запуска агентов с поддержкой планирования задач, доступа к файлам и делегирования полномочий субагентам. Это облегчает создание агентов, которые могут более надежно справляться с длинными многоэтапными задачами.

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

В этой статье мы объясним, как работает Deep Agents, и покажем, как объединить его с Milvus для создания ИИ-агентов со структурированными рабочими процессами и долговременной памятью.

Что такое Deep Agents?

Deep Agents - это фреймворк для агентов с открытым исходным кодом, созданный командой LangChain. Он призван помочь агентам более надежно справляться с длительными многоэтапными задачами. Он фокусируется на трех основных возможностях:

1. Планирование задач

В Deep Agents встроены такие инструменты, как write_todos и read_todos. Агент разбивает сложную задачу на четкий список дел, затем пошагово выполняет каждый пункт, отмечая задачи как выполненные.

2. Доступ к файловой системе

С помощью таких инструментов, как ls, read_file и write_file, агент может просматривать, читать и записывать файлы. Если инструмент выдает большой результат, он автоматически сохраняется в файл, а не остается в контекстном окне модели. Это помогает предотвратить заполнение контекстного окна.

3. Делегирование полномочий субагентам

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

Технически агент, созданный с помощью create_deep_agent, представляет собой скомпилированный LangGraph StateGraph. (LangGraph - это библиотека рабочих процессов, разработанная командой LangChain, а StateGraph - это ее основная структура состояний). Благодаря этому Deep Agents могут напрямую использовать такие возможности LangGraph, как потоковый вывод, контрольные точки и взаимодействие "человек в цикле".

Что же делает Deep Agents полезными на практике?

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

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

Кастомизация в глубоких агентах

Общий фреймворк не может охватить все отрасли или потребности бизнеса. Deep Agents спроектирован гибким, поэтому разработчики могут настраивать его в соответствии с собственными сценариями использования.

С помощью кастомизации вы можете:

• Подключать собственные внутренние инструменты и API

• Определять рабочие процессы, специфичные для конкретной области

• Обеспечить соблюдение агентом бизнес-правил

• Поддерживать память и обмен знаниями между сеансами.

Вот основные способы настройки агентов Deep Agents:

Настройка системной подсказки

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

Хорошая пользовательская подсказка может включать:

• Правила рабочего процесса домена

Пример: "Для задач анализа данных всегда выполняйте исследовательский анализ перед построением модели".

• Конкретные примеры

Пример: "Объединить похожие запросы на поиск литературы в один пункт todo".

• Правила остановки

Пример: "Остановиться, если использовано более 100 вызовов инструментов".

• Руководство по координации инструментов

Пример: "Используйте grep для поиска местоположения кода, затем используйте read_file для просмотра деталей".

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

Инструменты

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

from deepagents import create_deep_agent
def internet_search(query: str) -> str:
    """Run a web search"""
    return tavily_client.search(query)
agent = create_deep_agent(tools=[internet_search])

Deep Agents также поддерживает инструменты, которые следуют стандарту Model Context Protocol (MCP) через langchain-mcp-adapters.

from langchain_mcp_adapters.client import MultiServerMCPClient
from deepagents import create_deep_agent
async def main():
    mcp_client = MultiServerMCPClient(...)
    mcp_tools = await mcp_client.get_tools()
    agent = create_deep_agent(tools=mcp_tools)
    async for chunk in agent.astream({"messages": [{"role": "user", "content": "..."}]}):
        chunk["messages"][-1].pretty_print()

Промежуточное ПО

Вы можете написать пользовательское промежуточное ПО, чтобы:

• Добавлять или изменять инструменты

• настраивать подсказки

• подключаться к различным этапам выполнения агента.

from langchain_core.tools import tool
from deepagents import create_deep_agent
from deepagents.middleware import AgentMiddleware
@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."
class WeatherMiddleware(AgentMiddleware):
    tools = [get_weather]
agent = create_deep_agent(middleware=[WeatherMiddleware()])

Deep Agents также включает встроенное промежуточное ПО для планирования, управления субагентами и контроля выполнения.

Промежуточное ПО	Функция
TodoListMiddleware	Предоставляет инструменты write_todos и read_todos для управления списками задач
FilesystemMiddleware	Предоставляет инструменты для работы с файлами и автоматически сохраняет большие результаты работы инструментов
SubAgentMiddleware	Предоставляет инструмент задачи для делегирования работы субагентам
SummarizationMiddleware	Автоматически подводит итоги, когда контекст превышает 170 тыс. лексем
AnthropicPromptCachingMiddleware	Включает кэширование подсказок для моделей Anthropic
PatchToolCallsMiddleware	Исправляет неполные вызовы инструментов, вызванные прерываниями
HumanInTheLoopMiddleware	Настраивает инструменты, требующие одобрения человека

Субагенты

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

from deepagents import create_deep_agent
research_subagent = {
    "name": "research-agent",
    "description": "Used to research in-depth questions",
    "prompt": "You are an expert researcher",
    "tools": [internet_search],
    "model": "openai:gpt-4o",  # Optional, defaults to main agent model
}
agent = create_deep_agent(subagents=[research_subagent])

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

from deepagents import CompiledSubAgent, create_deep_agent
custom_graph = create_agent(model=..., tools=..., prompt=...)
agent = create_deep_agent(
    subagents=[CompiledSubAgent(
        name="data-analyzer",
        description="Specialized agent for data analysis",
        runnable=custom_graph
    )]
)

interrupt_on (Контроль одобрения человеком)

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

from langchain_core.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver
@tool
def delete_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"
agent = create_deep_agent(
    tools=[delete_file],
    interrupt_on={
        "delete_file": {
            "allowed_decisions": ["approve", "edit", "reject"]
        }
    },
    checkpointer=MemorySaver()
)

Настройка бэкэнда (хранение)

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

• StateBackend (временное хранилище)

• FilesystemBackend (локальное дисковое хранилище).

StoreBackend(persistent storage)、CompositeBackend(hybrid routing)。
from deepagents import create_deep_agent
from deepagents.backends import FilesystemBackend
agent = create_deep_agent(
    backend=FilesystemBackend(root_dir="/path/to/project")
)

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

Почему стоит использовать Deep Agents с Milvus для агентов искусственного интеллекта?

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

По умолчанию Deep Agents использует StateBackend, который хранит данные только в течение одной сессии. Когда сессия заканчивается, все данные очищаются. Это означает, что он не может поддерживать долгосрочную межсессионную память.

Чтобы обеспечить постоянную память, мы используем Milvus в качестве векторной базы данных вместе с StoreBackend. Вот как это работает: важное содержание разговора и результаты работы инструментов преобразуются в эмбеддинги (числовые векторы, отражающие смысл) и сохраняются в Milvus. Когда начинается новая задача, агент выполняет семантический поиск для извлечения связанных с ней прошлых воспоминаний. Это позволяет агенту "вспомнить" соответствующую информацию из предыдущих сессий.

Milvus хорошо подходит для этого варианта использования благодаря своей архитектуре разделения вычислений и хранения данных. Она поддерживает:

• Горизонтальное масштабирование до десятков миллиардов векторов

• Высокоскоростные запросы

• Обновление данных в реальном времени

• Готовое к производству развертывание для крупномасштабных систем

Технически Deep Agents использует CompositeBackend для маршрутизации различных путей к различным бэкендам хранения:

Путь	Бэкенд	Назначение
/workspace/, /temp/	StateBackend	Временные данные, очищаемые после завершения сеанса
/memories/, /knowledge/	StoreBackend + Milvus	Постоянные данные, доступные для поиска во всех сессиях

При такой настройке разработчикам нужно сохранять только долгосрочные данные по путям типа /memories/. Система автоматически обрабатывает межсессионную память. Подробные шаги по настройке приведены в разделе ниже.

Практическое занятие: Создание ИИ-агента с долговременной памятью с помощью Milvus и Deep Agents

В этом примере показано, как предоставить агенту на базе DeepAgents постоянную память с помощью Milvus.

Шаг 1: Установите зависимости

pip install deepagents tavily-python langchain-milvus

Шаг 2: Настройте бэкэнд памяти

from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langchain_milvus.storage import MilvusStore
# from langgraph.store.memory import InMemoryStore # for testing only
# Configure Milvus storage
milvus_store = MilvusStore(
    collection_name="agent_memories",
    embedding_service=... # embedding is required here, or use MilvusStore default configuration
)
backend = CompositeBackend(
    default=StateBackend(),
    routes={"/memories/": StoreBackend(store=InMemoryStore())} 
)

Шаг 3: Создайте агента

from tavily import TavilyClient
import os
tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
def internet_search(query: str, max_results: int = 5) -> str:
    """Perform an internet search"""
    results = tavily_client.search(query, max_results=max_results)
    return "\n".join([f"{r['title']}: {r['content']}" for r in results["results"]])
agent = create_deep_agent(
    tools=[internet_search],
    system_prompt="You are a research expert. Write important findings to the /memories/ directory for cross-session reuse.",
    backend=backend
)
# Run the agent
result = agent.invoke({
    "messages": [{"role": "user", "content": "Research the technical features of the Milvus vector database"}]
})

Ключевые моменты

• Постоянный путь

Любые файлы, сохраненные по адресу /memories/, будут храниться постоянно, и к ним можно будет обращаться в разных сессиях.

• Производственная настройка

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

• Автоматическая память

Агент автоматически сохраняет результаты исследований и важные результаты в папке /memories/. В последующих задачах он может искать и извлекать соответствующую прошлую информацию.

Обзор встроенных инструментов

Deep Agents включает в себя несколько встроенных инструментов, предоставляемых через промежуточное ПО. Они делятся на три основные группы:

Управление задачами (TodoListMiddleware)

• write_todos

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

• read_todos

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

Инструменты файловой системы (FilesystemMiddleware)

• ls

Перечисляет файлы в каталоге. Должен использоваться абсолютный путь (начиная с /).

• read_file

Читает содержимое файлов. Поддерживает offset и limit для больших файлов.

• write_file

Создает или перезаписывает файл.

• edit_file

Заменяет определенный текст в файле.

• glob

Находит файлы по шаблонам, например **/*.py для поиска всех файлов Python.

• grep

Поиск текста внутри файлов.

• execute

Выполняет команды оболочки в среде "песочницы". Требуется, чтобы бэкенд поддерживал SandboxBackendProtocol.

Делегирование субагента (SubAgentMiddleware)

• task

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

Как обрабатываются выходные данные инструментов

Если инструмент выдает большой результат, Deep Agents автоматически сохраняет его в файл.

Например, если internet_search возвращает 100 КБ содержимого, система сохраняет его в файл типа /tool_results/internet_search_1.txt. Агент сохраняет в своем контексте только путь к файлу. Это сокращает использование токенов и уменьшает размер контекстного окна.

DeepAgents против Agent Builder: Когда следует использовать каждый из них?

Поскольку эта статья посвящена DeepAgents, полезно также понять, как они соотносятся с Agent Builder, еще одним вариантом создания агентов в экосистеме LangChain.

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

DeepAgents предназначен для создания автономных агентов, выполняющих длительные многоэтапные задачи. Он дает разработчикам полный контроль над тем, как агент планирует задачи, использует инструменты и управляет памятью. Поскольку он построен на LangGraph, вы можете настраивать компоненты, интегрировать инструменты Python и изменять бэкэнд хранения данных. Благодаря этому DeepAgents хорошо подходит для сложных рабочих процессов и производственных систем, где важны надежность и гибкость.

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

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

Заключение

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

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

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

У вас есть вопросы о Deep Agents или использовании Milvus в качестве бэкенда постоянной памяти? Присоединяйтесь к нашему каналу в Slack или запишитесь на 20-минутную сессию Milvus Office Hours, чтобы обсудить ваш вариант использования.