За пределами контекстной перегрузки: Как Parlant × Milvus обеспечивает контроль и ясность в поведении агентов LLM

Представьте, что вам нужно выполнить задание, включающее 200 бизнес-правил, 50 инструментов и 30 демо-версий, а у вас на это всего час. Это просто невозможно. Однако мы часто ожидаем от больших языковых моделей именно этого, когда превращаем их в "агентов" и перегружаем инструкциями.

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

Для решения этой проблемы в последнее время на GitHub набирает обороты агентный фреймворк с открытым исходным кодом под названием Parlant. В нем реализован новый подход под названием Alignment Modeling, а также механизм надзора и условные переходы, которые делают поведение агентов гораздо более контролируемым и объяснимым.

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

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

Почему традиционные агентские фреймворки терпят крах

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

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

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

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

Что такое Parlant и как он работает

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

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

Гранулярные рекомендации: Основа моделирования согласования

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

Каждое руководство состоит из трех частей:

• Условие - описание на естественном языке того, когда должно применяться правило. Parlant преобразует это условие в семантический вектор и сопоставляет его с вводом пользователя, чтобы определить, насколько оно релевантно.

• Действие - четкая инструкция, определяющая, как агент должен реагировать на выполнение условия. Это действие внедряется в контекст LLM только при срабатывании.

• Инструменты - любые внешние функции или API, связанные с конкретным правилом. Они открываются агенту только при активном правиле, что позволяет контролировать использование инструментов и учитывать контекст.

await agent.create_guideline(
    condition="The user asks about a refund and the order amount exceeds 500 RMB",
    action="First call the order status check tool to confirm whether the refund conditions are met, then provide a detailed explanation of the refund process",
    tools=[check_order_status, calculate_refund_amount]
)

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

Механизм контроля точности и согласованности

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

1. Генерирование ответа-кандидата - агент создает первоначальный ответ на основе сопоставленных рекомендаций и текущего контекста разговора.

2. Проверка соответствия - ответ сравнивается с активными рекомендациями, чтобы убедиться, что все инструкции были выполнены правильно.

3. Пересмотр или подтверждение - если обнаружены какие-либо проблемы, система корректирует вывод; если все в порядке, ответ утверждается и отправляется пользователю.

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

Условные переходы для контроля и безопасности

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

# The balance inquiry tool is exposed only when the condition "the user wants to make a transfer" is met
await agent.create_guideline(
    condition="The user wants to make a transfer",
    action="First check the account balance. If the balance is below 500 RMB, remind the user that an overdraft fee may apply.",
    tools=[get_user_account_balance]
)

Этот механизм превращает вызов инструмента в условный переход - инструменты переходят из состояния "неактивно" в состояние "активно" только при выполнении условий их запуска. Структурируя выполнение таким образом, Parlant гарантирует, что каждое действие происходит осознанно и контекстно, предотвращая злоупотребления и повышая эффективность и безопасность системы.

Как Milvus обеспечивает работу Parlant

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

Как Milvus поддерживает процесс сопоставления рекомендаций Parlant

Сопоставление рекомендаций происходит за счет семантического сходства. Поле "Условие" каждого руководства преобразуется в векторную вставку, которая отражает его смысл, а не только буквальный текст. Когда пользователь отправляет сообщение, Parlant сравнивает семантику этого сообщения со всеми сохраненными вложениями рекомендаций, чтобы найти наиболее релевантные из них.

Вот как пошагово работает этот процесс:

1. Кодирование запроса - сообщение пользователя и история последних разговоров преобразуются в вектор запроса.

2. Поиск сходства - система выполняет поиск сходства в хранилище векторов рекомендаций, чтобы найти наиболее близкие совпадения.

3. Получение результатов Top-K - возвращаются три-пять наиболее семантически релевантных рекомендаций.

4. Вставка в контекст - эти совпадающие рекомендации динамически вставляются в контекст LLM, чтобы модель могла действовать в соответствии с правильными правилами.

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

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

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

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType
import parlant.sdk as p
# Connect to Milvus
connections.connect(host=“localhost”, port=“19530”)
# Define the schema for the guideline collection
fields = [
FieldSchema(name=“guideline_id”, dtype=DataType.VARCHAR, max_length=100, is_primary=True),
FieldSchema(name=“condition_vector”, dtype=DataType.FLOAT_VECTOR, dim=768),
FieldSchema(name=“condition_text”, dtype=DataType.VARCHAR, max_length=1000),
FieldSchema(name=“action_text”, dtype=DataType.VARCHAR, max_length=2000),
FieldSchema(name=“priority”, dtype=DataType.INT64),
FieldSchema(name=“business_domain”, dtype=DataType.VARCHAR, max_length=50)
]
schema = CollectionSchema(fields=fields, description=“Agent Guidelines”)
guideline_collection = Collection(name=“agent_guidelines”, schema=schema)
# Create an HNSW index for high-performance retrieval
index_params = {
“index_type”: “HNSW”,
“metric_type”: “COSINE”,
“params”: {“M”: 16, “efConstruction”: 200}
}
guideline_collection.create_index(field_name=“condition_vector”, index_params=index_params)

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

1. Ректоризация запроса - преобразование пользовательского ввода в 768-мерный вектор.

2. Гибридный поиск - запуск поиска по векторному сходству в Milvus с фильтрацией метаданных (например, business_domain="transfer").

3. Ранжирование результатов - Ранжирование рекомендаций-кандидатов на основе оценок сходства в сочетании с их приоритетными значениями.

4. Инжекция контекста - инжектирование action_text руководящих принципов, вошедших в топ-3, в контекст агента Parlant.

В этой конфигурации Milvus обеспечивает задержку P99 менее 15 мс даже при масштабировании библиотеки рекомендаций до 100 000 записей. Для сравнения, использование традиционной реляционной базы данных с подбором ключевых слов обычно приводит к задержкам свыше 200 мс и значительно более низкой точности подбора.

Как Milvus обеспечивает долговременную память и персонализацию

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

# store user’s past interactions
user_memory_fields = [
    FieldSchema(name="interaction_id", dtype=DataType.VARCHAR, max_length=100, is_primary=True),
    FieldSchema(name="user_id", dtype=DataType.VARCHAR, max_length=50),
    FieldSchema(name="interaction_vector", dtype=DataType.FLOAT_VECTOR, dim=768),
    FieldSchema(name="interaction_summary", dtype=DataType.VARCHAR, max_length=500),
    FieldSchema(name="timestamp", dtype=DataType.INT64)
]
memory_collection = Collection(name="user_memory", schema=CollectionSchema(user_memory_fields))

Когда тот же пользователь возвращается, агент может извлечь из Milvus наиболее релевантные исторические взаимодействия и использовать их для создания более связного, похожего на человеческий, опыта. Например, если на прошлой неделе пользователь спрашивал об инвестиционном фонде, агент может вспомнить этот контекст и проактивно ответить на него: "С возвращением! У вас еще есть вопросы о фонде, который мы обсуждали в прошлый раз?".

Как оптимизировать производительность агентских систем на базе Milvus

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

1. Выбор правильного типа индекса

Важно выбрать подходящую структуру индекса. Например, HNSW (Hierarchical Navigable Small World) идеально подходит для сценариев с высокой точностью вызова, таких как финансы или здравоохранение, где точность имеет решающее значение. IVF_FLAT лучше подходит для крупномасштабных приложений, таких как рекомендации в электронной коммерции, где немного меньшая запоминаемость приемлема в обмен на более высокую производительность и меньшее использование памяти.

2. Стратегия шардинга

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

3. Конфигурация кэша

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

Практическая демонстрация: Как построить умную систему вопросов и ответов с помощью Parlant и Milvus Lite

Milvus Lite - это облегченная версия Milvus - библиотеки Python, которая может быть легко встроена в ваши приложения. Она идеально подходит для быстрого создания прототипов в таких средах, как Jupyter Notebooks, или для работы на периферийных и интеллектуальных устройствах с ограниченными вычислительными ресурсами. Несмотря на небольшой размер, Milvus Lite поддерживает те же API, что и другие развертывания Milvus. Это означает, что код на стороне клиента, написанный для Milvus Lite, может впоследствии легко подключаться к полноценному экземпляру Milvus или Zilliz Cloud - рефакторинг не требуется.

В этой демонстрации мы используем Milvus Lite в сочетании с Parlant, чтобы показать, как создать интеллектуальную систему вопросов и ответов, которая предоставляет быстрые, контекстно-зависимые ответы с минимальными настройками.

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

1.Parlant GitHub: https://github.com/emcie-co/parlant

2.документация Parlant: https://parlant.io/docs

3.python3.10+

4.OpenAI_key

5.MlivusLite

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

# Install required Python packages
pip install pymilvus parlant openai
# Or, if you’re using a Conda environment:
conda activate your_env_name
pip install pymilvus parlant openai

Шаг 2: Настройте переменные окружения

# Set your OpenAI API key
export OPENAI_API_KEY="your_openai_api_key_here"
# Verify that the variable is set correctly
echo $OPENAI_API_KEY

Шаг 3: Реализация основного кода

• Создайте пользовательский OpenAI Embedder

class OpenAIEmbedder(p.Embedder):
    # Converts text into vector embeddings with built-in timeout and retry
    # Dimension: 1536 (text-embedding-3-small)
    # Timeout: 60 seconds; Retries: up to 2 times

• Инициализация базы знаний

1.Создайте коллекцию Milvus с именем kb_articles.

2.Вставьте данные образца (например, политика возврата, политика обмена, время доставки).

3.Создайте индекс HNSW для ускорения поиска.

• Создайте инструмент векторного поиска

@p.tool
async def vector_search(query: str, top_k: int = 5, min_score: float = 0.35):
    # 1. Convert user query into a vector
    # 2. Perform similarity search in Milvus
    # 3. Return results with relevance above threshold

• Настройте агент Parlant.

Рекомендация 1: Для вопросов, связанных с фактами или политикой, агент должен сначала выполнить векторный поиск.

Принцип 2: Когда доказательства найдены, агент должен ответить на вопрос, используя структурированный шаблон (резюме + ключевые моменты + источники).

# Guideline 1: Run vector search for factual or policy-related questions
await agent.create_guideline(
            condition="User asks a factual question about policy, refund, exchange, or shipping",
            action=(
                "Call vector_search with the user's query. "
                "If evidence is found, synthesize an answer by quoting key sentences and cite doc_id/title. "
                "If evidence is insufficient, ask a clarifying question before answering."
            ),
            tools=[vector_search],
# Guideline 2: Use a standardized, structured response when evidence is available
await agent.create_guideline(
condition=“Evidence is available”,
action=(
“Answer with the following template:\n”
“Summary: provide a concise conclusion.\n”
“Key points: 2-3 bullets distilled from evidence.\n”
“Sources: list doc_id and title.\n”
“Note: if confidence is low, state limitations and ask for clarification.”
),
tools=[],
)
tools=[],

)

• Напишите полный код

import os
import asyncio
import json
from typing import List, Dict, Any
import parlant.sdk as p
from pymilvus import MilvusClient, DataType
# 1) Environment variables: using OpenAI (as both the default generation model and embedding service)
# Make sure the OPENAI_API_KEY is set
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
if not OPENAI_API_KEY:
    raise RuntimeError("Please set OPENAI_API_KEY environment variable")
# 2) Initialize Milvus Lite (runs locally, no standalone service required)
# MilvusClient runs in Lite mode using a local file path (requires pymilvus >= 2.x)
client = MilvusClient("./milvus_demo.db")  # Lite mode uses a local file path
COLLECTION = "kb_articles"
# 3) Example data: three policy or FAQ entries (in practice, you can load and chunk data from files)
DOCS = [
    {"doc_id": "POLICY-001", "title": "Refund Policy", "chunk": "Refunds are available within 30 days of purchase if the product is unused."},
    {"doc_id": "POLICY-002", "title": "Exchange Policy", "chunk": "Exchanges are permitted within 15 days; original packaging required."},
    {"doc_id": "FAQ-101", "title": "Shipping Time", "chunk": "Standard shipping usually takes 3–5 business days within the country."},
]
# 4) Generate embeddings using OpenAI (you can replace this with another embedding service)
# Here we use Parlant’s built-in OpenAI embedder for simplicity, but you could also call the OpenAI SDK directly.
class OpenAIEmbedder(p.Embedder):
    async def embed(self, texts: List[str], hints: Dict[str, Any] = {}) -> p.EmbeddingResult:
        # Generate text embeddings using the OpenAI API, with timeout and retry handling
        import openai
        try:
            client = openai.AsyncOpenAI(
                api_key=OPENAI_API_KEY,
                timeout=60.0,  # 60-second timeout
                max_retries=2  # Retry up to 2 times
            )
            print(f"Generating embeddings for {len(texts)} texts...")
            response = await client.embeddings.create(
                model="text-embedding-3-small",
                input=texts
            )
            vectors = [data.embedding for data in response.data]
            print(f"Successfully generated {len(vectors)} embeddings.")
            return p.EmbeddingResult(vectors=vectors)
        except Exception as e:
            print(f"OpenAI API call failed: {e}")
            # Return mock vectors for testing Milvus connectivity
            print("Using mock vectors for testing...")
            import random
            vectors = [[random.random() for _ in range(1536)] for _ in texts]
            return p.EmbeddingResult(vectors=vectors)
    @property
    def id(self) -> str:
        return "text-embedding-3-small"
    @property
    def max_tokens(self) -> int:
        return 8192
    @property
    def tokenizer(self) -> p.EstimatingTokenizer:
        from parlant.core.nlp.tokenization import ZeroEstimatingTokenizer
        return ZeroEstimatingTokenizer()
    @property
    def dimensions(self) -> int:
        return 1536
embedder = OpenAIEmbedder()
async def ensure_collection_and_load():
    # Create the collection (schema: primary key, vector field, additional fields)
    if not client.has_collection(COLLECTION):
        client.create_collection(
            collection_name=COLLECTION,
            dimension=len((await embedder.embed(["dimension_probe"])).vectors[0]),
            # Default metric: COSINE (can be changed with metric_type="COSINE")
            auto_id=True,
        )
        # Create an index to speed up retrieval (HNSW used here as an example)
        client.create_index(
            collection_name=COLLECTION,
            field_name="vector",
            index_type="HNSW",
            metric_type="COSINE",
            params={"M": 32, "efConstruction": 200}
        )
    # Insert data (skip if already exists; simple idempotent logic for the demo)
    # Generate embeddings
    chunks = [d["chunk"] for d in DOCS]
    embedding_result = await embedder.embed(chunks)
    vectors = embedding_result.vectors
    # Check if the same doc_id already exists; this is for demo purposes only — real applications should use stricter deduplication
    # Here we insert directly. In production, use an upsert operation or an explicit primary key
    client.insert(
        COLLECTION,
        data=[
            {"vector": vectors[i], "doc_id": DOCS[i]["doc_id"], "title": DOCS[i]["title"], "chunk": DOCS[i]["chunk"]}
            for i in range(len(DOCS))
        ],
    )
    # Load into memory
    client.load_collection(COLLECTION)
# 5) Define the vector search tool (Parlant Tool)
@p.tool
async def vector_search(context: p.ToolContext, query: str, top_k: int = 5, min_score: float = 0.35) -> p.ToolResult:
    # 5.1 Generate the query vector
    embed_res = await embedder.embed([query])
    qvec = embed_res.vectors[0]
    # 5.2 Search Milvus
    results = client.search(
        collection_name=COLLECTION,
        data=[qvec],
        limit=top_k,
        output_fields=["doc_id", "title", "chunk"],
        search_params={"metric_type": "COSINE", "params": {"ef": 128}},
    )
    # 5.3 Assemble structured evidence and filter by score threshold
    hits = []
    for hit in results[0]:
        score = hit["distance"] if "distance" in hit else hit.get("score", 0.0)
        if score >= min_score:
            hits.append({
                "doc_id": hit["entity"]["doc_id"],
                "title": hit["entity"]["title"],
                "chunk": hit["entity"]["chunk"],
                "score": float(score),
            })
    return p.ToolResult({"evidence": hits})
# 6) Run Parlant Server and create the Agent + Guidelines
async def main():
    await ensure_collection_and_load()
    async with p.Server() as server:
        agent = await server.create_agent(
            name="Policy Assistant",
            description="Rule-controlled RAG assistant with Milvus Lite",
        )
        # Example variable: current time (can be used in templates or logs)
        @p.tool
        async def get_datetime(context: p.ToolContext) -> p.ToolResult:
            from datetime import datetime
            return p.ToolResult({"now": datetime.now().isoformat()})
        await agent.create_variable(name="current-datetime", tool=get_datetime)
        # Core Guideline 1: Run vector search for factual or policy-related questions
        await agent.create_guideline(
            condition="User asks a factual question about policy, refund, exchange, or shipping",
            action=(
                "Call vector_search with the user's query. "
                "If evidence is found, synthesize an answer by quoting key sentences and cite doc_id/title. "
                "If evidence is insufficient, ask a clarifying question before answering."
            ),
            tools=[vector_search],
        )
        # Core Guideline 2: Use a standardized, structured response when evidence is available
        await agent.create_guideline(
            condition="Evidence is available",
            action=(
                "Answer with the following template:\\n"
                "Summary: provide a concise conclusion.\\n"
                "Key points: 2-3 bullets distilled from evidence.\\n"
                "Sources: list doc_id and title.\\n"
                "Note: if confidence is low, state limitations and ask for clarification."
            ),
            tools=[],
        )
        # Hint: Local Playground URL
        print("Playground: <http://localhost:8800>")
if __name__ == "__main__":
    asyncio.run(main())

Шаг 4: Запуск кода

# Run the main program
python main.py

• Посетите игровую площадку:

<http://localhost:8800>

Теперь вы успешно создали интеллектуальную систему вопросов и ответов с использованием Parlant и Milvus.

Parlant vs. LangChain/LlamaIndex: Чем они отличаются и как работают вместе

Чем Parlant отличается от существующих агентных фреймворков, таких как LangChain или LlamaIndex?

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

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

Более того, эти фреймворки могут работать вместе:

• Используйте LangChain для создания сложных конвейеров обработки данных или рабочих процессов извлечения.

• Используйте Parlant для управления финальным слоем взаимодействия, обеспечивая соответствие выходных данных бизнес-правилам и их интерпретацию.

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

Заключение

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

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

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

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