Home
Blog
LangChain 1.0 и Milvus: как создать готовые к производству агенты с реальной долговременной памятью

LangChain 1.0 и Milvus: как создать готовые к производству агенты с реальной долговременной памятью

Tutorials

December 19, 2025

Min Yin

LangChain - это популярный фреймворк с открытым исходным кодом для разработки приложений на основе больших языковых моделей (LLM). Он предоставляет модульный набор инструментов для создания агентов, использующих рассуждения и инструменты, подключения моделей к внешним данным и управления потоками взаимодействия.

С выходом LangChain 1.0 фреймворк делает шаг в сторону более удобной для производства архитектуры. Новая версия заменяет прежний дизайн, основанный на цепочке, стандартизированным циклом ReAct (Reason → Tool Call → Observe → Decide) и вводит Middleware для управления исполнением, контролем и безопасностью.

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

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

Почему дизайн, основанный на цепочке, не работает

В начале своего существования (версия 0.x) архитектура LangChain была основана на цепочках. Каждая цепочка определяла фиксированную последовательность действий и поставлялась с готовыми шаблонами, что делало оркестровку LLM простой и быстрой. Такой дизайн отлично подходил для быстрого создания прототипов. Но по мере развития экосистемы LLM и усложнения реальных сценариев использования в этой архитектуре стали появляться трещины.

1. Отсутствие гибкости

Ранние версии LangChain предоставляли модульные конвейеры, такие как SimpleSequentialChain или LLMChain, каждый из которых следовал фиксированному, линейному потоку - создание запроса → вызов модели → обработка вывода. Такой дизайн хорошо подходил для простых и предсказуемых задач и позволял быстро создавать прототипы.

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

2. Отсутствие контроля производственного уровня

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

Переполнение контекста: Длинные разговоры могли превысить лимит токенов, что приводило к сбоям или молчаливому обрыву.
Утечка конфиденциальных данных: Лично идентифицируемая информация (например, электронные письма или идентификаторы) может быть случайно отправлена сторонним моделям.
Неконтролируемые операции: Агенты могут удалять данные или отправлять электронную почту без одобрения человека.

3. Отсутствие кросс-модельной совместимости

Каждый провайдер LLM - OpenAI, Anthropic и многие китайские модели - реализует собственные протоколы для рассуждений и вызова инструментов. Каждый раз при смене провайдера приходилось переписывать интеграционный слой: шаблоны подсказок, адаптеры и парсеры ответов. Эта повторяющаяся работа замедляла разработку и делала эксперименты болезненными.

LangChain 1.0: Агент ReAct "все в одном

Когда команда LangChain проанализировала сотни реализаций агентов производственного уровня, выяснилось, что почти все успешные агенты естественным образом сходятся к шаблону ReAct ("Reasoning + Acting").

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

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

Чтобы поддерживать все - от простых агентов до сложных оркестров, LangChain 1.0 использует многоуровневый дизайн, сочетающий простоту использования с точным контролем:

Стандартные сценарии: Начните с функции create_agent() - чистого, стандартизированного цикла ReAct, который обрабатывает рассуждения и вызовы инструментов из коробки.
Расширенные сценарии: Добавьте Middleware, чтобы получить более тонкий контроль. Middleware позволяет контролировать или изменять происходящее внутри агента - например, добавлять обнаружение PII, контрольные точки одобрения человеком, автоматические повторы или крючки мониторинга.
Сложные сценарии: Для создания рабочих процессов с определенными состояниями или оркестровки нескольких агентов используйте LangGraph, механизм выполнения на основе графов, который обеспечивает точный контроль над логическим потоком, зависимостями и состояниями выполнения.

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

1. Функция create_agent(): Более простой способ создания агентов

Ключевой прорыв в LangChain 1.0 заключается в том, что он сводит всю сложность создания агентов к одной функции - create_agent(). Вам больше не нужно вручную управлять состоянием, обрабатывать ошибки или передавать потоковые данные. Эти функции производственного уровня теперь автоматически управляются средой выполнения LangGraph.

С помощью всего трех параметров вы можете запустить полностью функциональный агент:

модель - либо идентификатор модели (строка), либо инстанцированный объект модели.
tools - список функций, которые предоставляют агенту его возможности.
system_prompt - инструкция, определяющая роль, тон и поведение агента.

Под капотом create_agent() работает по стандартному циклу агента - вызывает модель, позволяет ей выбрать инструменты для выполнения и завершает работу, когда инструменты больше не нужны:

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

from langchain.agents import create_agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather, query_database],
    system_prompt="You are a customer service assistant who helps users check the weather and order information."
)
result = agent.invoke({
    "messages": [{"role": "user", "content": "What’s the weather like in Shanghai today?"}]
})

2. Среднее ПО: Композитный слой для управления, готового к производству

Middleware - это ключевой мост, который переводит LangChain от прототипа к производству. Оно открывает крючки в стратегических точках цикла выполнения агента, позволяя вам добавлять пользовательскую логику без переписывания основного процесса ReAct.

Основной цикл агента следует трехступенчатому процессу принятия решений - Модель → Инструмент → Завершение:

LangChain 1.0 предоставляет несколько готовых промежуточных модулей для общих паттернов. Вот четыре примера.

Обнаружение PII: Любое приложение, обрабатывающее конфиденциальные данные пользователя.

from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[],  # Add tools as needed
middleware=[
# Redact emails in user input
PIIMiddleware(“email”, strategy=“redact”, apply_to_input=True),
# Mask credit cards (show last 4 digits)
PIIMiddleware(“credit_card”, strategy=“mask”, apply_to_input=True),
# Custom PII type with regex
PIIMiddleware(
“api_key”,
detector=r"sk-[a-zA-Z0-9]{32}",
strategy=“block”,  # Raise error if detected
),
],
)

Суммирование: Автоматическое обобщение истории разговоров при приближении к лимиту токенов.

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[weather_tool, calculator_tool],
middleware=[
SummarizationMiddleware(
model=“gpt-4o-mini”,  #Summarize using a cheaper model  
max_tokens_before_summary=4000,  # Trigger summarization at 4000 tokens
messages_to_keep=20,  # Keep last 20 messages after summary
),
],
)

Повторные вызовы инструментов: Автоматическое повторение неудачных вызовов инструментов с настраиваемым экспоненциальным отступлением.

from langchain.agents import create_agent
from langchain.agents.middleware import ToolRetryMiddleware
agent = create_agent(
    model="gpt-4o",
    tools=[search_tool, database_tool],
    middleware=[
        ToolRetryMiddleware(
            max_retries=3,  # Retry up to 3 times
            backoff_factor=2.0,  # Exponential backoff multiplier
            initial_delay=1.0,  # Start with 1 second delay
            max_delay=60.0,  # Cap delays at 60 seconds
            jitter=True,  # Add random jitter to avoid thundering herd (±25%)
    ),
],

)

Пользовательское промежуточное ПО

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

Например, в приведенном ниже фрагменте показано, как регистрировать вызовы модели перед выполнением:

from langchain.agents.middleware import before_model
from langchain.agents.middleware import AgentState
from langgraph.runtime import Runtime
@before_model
def log_before_model(state: AgentState, runtime: Runtime) -> dict | None:
    print(f"About to call model with {len(state['messages'])} messages")
    return None  # Returning None means the normal flow continues
agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[log_before_model],
)

3. Структурированный вывод: Стандартизированный способ работы с данными

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

В LangChain 1.0 структурированный вывод обрабатывается напрямую через параметр response_format в create_agent(). Вам нужно только один раз определить схему данных. LangChain автоматически выбирает наилучшую стратегию исполнения в зависимости от используемой модели - не требуется никаких дополнительных настроек или кода, специфичного для конкретного производителя.

from langchain.agents import create_agent
from pydantic import BaseModel, Field
class WeatherReport(BaseModel):
    location: str = Field(description="City name")
    temperature: float = Field(description="Temperature (°C)")
    condition: str = Field(description="Weather condition")
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather],
    response_format=WeatherReport  # Use the Pydantic model as the response schema
)
result = agent.invoke({"role": "user", "content": "What’s the weather like in Shanghai today??"})
weather_data = result['structured_response']  # Retrieve the structured response
print(f"{weather_data.location}: {weather_data.temperature}°C, {weather_data.condition}")

LangChain поддерживает две стратегии структурированного вывода:

1. Стратегия провайдера: Некоторые провайдеры моделей поддерживают структурированный вывод через свои API (например, OpenAI и Grok). При наличии такой поддержки LangChain использует встроенную схему провайдера напрямую. Такой подход обеспечивает наивысший уровень надежности и согласованности, поскольку модель сама гарантирует формат вывода.

2. Стратегия вызова инструмента: Для моделей, которые не поддерживают собственный структурированный вывод, LangChain использует вызов инструментов для достижения того же результата.

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

Как Milvus улучшает память агентов

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

Milvus - одна из самых совершенных векторных баз данных с открытым исходным кодом, созданная специально для крупномасштабного векторного поиска в приложениях ИИ. Она интегрируется с LangChain, поэтому вам не придется вручную заниматься векторизацией, управлением индексами или поиском по сходству. Пакет langchain_milvus оборачивает Milvus в стандартный интерфейс VectorStore, позволяя вам подключать его к своим агентам всего несколькими строчками кода.

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

1. Быстрое извлечение информации из массивных баз знаний

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

from langchain.agents import create_agent
from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings
# Initialize the vector database as a knowledge base
vectorstore = Milvus(
    embedding=OpenAIEmbeddings(),  
    collection_name="company_knowledge",
    connection_args={"uri": "http://localhost:19530"}  #
)
# Convert the retriever into a Tool for the Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[vectorstore.as_retriever().as_tool(
        name="knowledge_search",
        description="Search the company knowledge base to answer professional questions"
    )],
    system_prompt="You can retrieve information from the knowledge base to answer questions."
)

2. Постоянная долговременная память

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

from langchain_milvus import Milvus
from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
from langgraph.checkpoint.memory import InMemorySaver
# Long-term memory storage(Milvus)
long_term_memory = Milvus.from_documents(
    documents=[],  # Initially empty; dynamically updated at runtime
    embedding=OpenAIEmbeddings(),
    connection_args={"uri": "./agent_memory.db"}
)
# Short-term memory management(LangGraph Checkpointer + Summarization)
agent = create_agent(
    model="openai:gpt-4o",
    tools=[long_term_memory.as_retriever().as_tool(
        name="recall_memory",
        description="Retrieve the agent’s historical memories and past experiences"
    )],
    checkpointer=InMemorySaver(),  # Short-term memory
    middleware=[
        SummarizationMiddleware(
            model="openai:gpt-4o-mini",
            max_tokens_before_summary=4000  # When the threshold is exceeded, summarize and store it in Milvus
        )
    ]
)

3. Унифицированное управление мультимодальным контентом

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

# Filter retrievals by source (e.g., search only medical reports)
vectorstore.similarity_search(
    query="What is the patient's blood pressure reading?",
    k=3,
    expr="source == 'medical_reports' AND modality == 'text'"  # Milvus scalar filtering
)

LangChain vs. LangGraph: Как выбрать подходящий вариант для ваших агентов

Обновление до LangChain 1.0 - важный шаг на пути к созданию агентов производственного уровня, но это не значит, что он всегда является единственным или лучшим выбором для каждого случая использования. От правильного выбора фреймворка зависит, как быстро вы сможете объединить эти возможности в работающую и поддерживаемую систему.

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

Ниже приведено краткое сравнение того, как они различаются по техническому позиционированию:

Размер	LangChain 1.0	LangChain 1.0
Уровень абстракции	Высокоуровневая абстракция, предназначенная для стандартных агентских сценариев	Низкоуровневая структура оркестровки, предназначенная для сложных рабочих процессов
Основные возможности	Стандартный цикл ReAct (причина → вызов инструмента → наблюдение → ответ)	Пользовательские машины состояний и сложная логика ветвления (StateGraph + условная маршрутизация)
Механизм расширения	Среднее программное обеспечение для возможностей производственного уровня	Ручное управление узлами, ребрами и переходами состояний
Базовая реализация	Ручное управление узлами, ребрами и переходами состояний	Нативная среда выполнения со встроенными функциями сохранения и восстановления
Типичные сценарии использования	80 % стандартных агентских сценариев	Совместная работа нескольких агентов и оркестровка длительных рабочих процессов
Кривая обучения	Создание агента за ~10 строк кода	Требуется понимание графов состояний и оркестровки узлов

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

Оба фреймворка могут сосуществовать в одном проекте - вы можете начать с LangChain и перейти на LangGraph, когда вашей системе потребуется больше контроля и гибкости. Главное - выбрать правильный инструмент для каждой части вашего рабочего процесса.

Заключение

Три года назад LangChain начинался как легкая обертка для вызова LLM. Сегодня он превратился в полноценный фреймворк производственного уровня.

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

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

🚀 Готовы обеспечить своему агенту надежную и долговременную память? Изучите Milvus и узнайте, как он обеспечивает интеллектуальную долговременную память для агентов LangChain в производстве.

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