Para além da sobrecarga de contexto: Como o Parlant × Milvus traz controlo e clareza ao comportamento do agente LLM

Imagine que lhe é pedido para completar uma tarefa que envolve 200 regras comerciais, 50 ferramentas e 30 demonstrações, e que só tem uma hora para o fazer. Isso é simplesmente impossível. No entanto, muitas vezes esperamos que grandes modelos de linguagem façam exatamente isso quando os transformamos em "agentes" e os sobrecarregamos com instruções.

Na prática, esta abordagem rapidamente se torna ineficaz. As estruturas de agentes tradicionais, como a LangChain ou a LlamaIndex, injectam todas as regras e ferramentas no contexto do modelo de uma só vez, o que leva a conflitos de regras, sobrecarga de contexto e comportamento imprevisível na produção.

Para resolver esse problema, uma estrutura de agente de código aberto chamada Parlant vem ganhando força no GitHub. Ele introduz uma nova abordagem chamada Modelagem de Alinhamento, juntamente com um mecanismo de supervisão e transições condicionais que tornam o comportamento do agente muito mais controlável e explicável.

Quando emparelhado com o Milvus, uma base de dados vetorial de código aberto, o Parlant torna-se ainda mais capaz. O Milvus acrescenta inteligência semântica, permitindo que os agentes recuperem dinamicamente as regras e o contexto mais relevantes em tempo real - mantendo-os precisos, eficientes e prontos para a produção.

Nesta postagem, exploraremos como o Parlant funciona secretamente e como a integração com o Milvus permite a produção.

Por que as estruturas tradicionais de agentes se desfazem

As estruturas de agentes tradicionais adoram ser grandes: centenas de regras, dezenas de ferramentas e um punhado de demonstrações - tudo amontoado em um único prompt superlotado. Pode parecer ótimo em uma demonstração ou em um pequeno teste de sandbox, mas quando você o coloca em produção, as rachaduras começam a aparecer rapidamente.

• Regras conflitantes trazem o caos: Quando duas ou mais regras se aplicam ao mesmo tempo, esses frameworks não têm uma maneira integrada de decidir qual delas vence. Às vezes, ele escolhe uma. Às vezes, mistura as duas. Por vezes, faz algo totalmente imprevisível.

• Casos extremos expõem as lacunas: Não é possível prever tudo o que um utilizador pode dizer. E quando o seu modelo se depara com algo fora dos dados de treino, o padrão são respostas genéricas e sem compromisso.

• A depuração é dolorosa e cara: Quando um agente se comporta mal, é quase impossível identificar qual regra causou o problema. Como tudo fica dentro de um prompt de sistema gigante, a única maneira de corrigir o problema é reescrever o prompt e testar tudo novamente do zero.

O que é o Parlant e como ele funciona

Parlant é um motor de alinhamento de código aberto para agentes LLM. É possível controlar com precisão como um agente se comporta em diferentes cenários, modelando o seu processo de tomada de decisão de uma forma estruturada e baseada em regras.

Para resolver os problemas encontrados nas estruturas tradicionais de agentes, a Parlant introduz uma nova e poderosa abordagem: A Modelagem de Alinhamento. Sua idéia central é separar a definição e a execução de regras, garantindo que apenas as regras mais relevantes sejam injetadas no contexto do LLM a qualquer momento.

Diretrizes Granulares: O núcleo da modelagem de alinhamento

No coração do modelo de alinhamento do Parlant está o conceito de Diretrizes Granulares. Em vez de escrever um prompt de sistema gigante cheio de regras, você define diretrizes pequenas e modulares - cada uma descrevendo como o agente deve lidar com um tipo específico de situação.

Cada diretriz é composta por três partes:

• Condição - Uma descrição em linguagem natural de quando a regra deve ser aplicada. O Parlant converte essa condição em um vetor semântico e a compara com a entrada do usuário para descobrir se ela é relevante.

• Ação - Uma instrução clara que define como o agente deve responder quando a condição for atendida. Esta ação é injectada no contexto do LLM apenas quando é activada.

• Ferramentas - Quaisquer funções externas ou APIs ligadas a essa regra específica. Estas são expostas ao agente apenas quando a diretriz está ativa, mantendo a utilização da ferramenta controlada e consciente do contexto.

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]
)

Sempre que um usuário interage com o agente, o Parlant executa uma etapa de correspondência leve para encontrar as três a cinco diretrizes mais relevantes. Somente essas regras são injetadas no contexto do modelo, mantendo os avisos concisos e focados e garantindo que o agente siga consistentemente as regras corretas.

Mecanismo de supervisão para precisão e consistência

Para manter a precisão e a consistência, o Parlant introduz um mecanismo de supervisão que atua como uma segunda camada de controlo de qualidade. O processo se desenvolve em três etapas:

1. Gerar uma resposta candidata - O agente cria uma resposta inicial com base nas diretrizes correspondentes e no contexto atual da conversa.

2. Verificar a conformidade - A resposta é comparada com as diretrizes activas para verificar se todas as instruções foram seguidas corretamente.

3. Rever ou confirmar - Se forem detectados problemas, o sistema corrige o resultado; se tudo estiver correto, a resposta é aprovada e enviada ao utilizador.

Este mecanismo de supervisão garante que o agente não só compreende as regras, como também as cumpre antes de responder - melhorando a fiabilidade e o controlo.

Transições condicionais para controlo e segurança

Nas estruturas tradicionais de agentes, todas as ferramentas disponíveis são expostas ao LLM em todos os momentos. Essa abordagem de "tudo na mesa" geralmente leva a prompts sobrecarregados e chamadas de ferramentas não intencionais. O Parlant resolve isso por meio de transições condicionais. Semelhante ao funcionamento das máquinas de estado, uma ação ou ferramenta é acionada apenas quando uma condição específica é atendida. Cada ferramenta está fortemente ligada à sua diretriz correspondente e só fica disponível quando a condição dessa diretriz é activada.

# 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]
)

Este mecanismo transforma a invocação de uma ferramenta numa transição condicional - as ferramentas passam de "inactivas" a "activas" apenas quando as suas condições de ativação são satisfeitas. Ao estruturar a execução desta forma, o Parlant garante que cada ação aconteça de forma deliberada e contextualizada, prevenindo o uso indevido e melhorando tanto a eficiência quanto a segurança do sistema.

Como Milvus alimenta a Parlant

Quando olhamos por baixo do capô do processo de correspondência de diretrizes da Parlant, um desafio técnico central torna-se claro: como o sistema pode encontrar as três ou cinco regras mais relevantes dentre centenas - ou até mesmo milhares - de opções em apenas alguns milissegundos? É exatamente aí que entra uma base de dados vetorial. A recuperação semântica é o que torna isso possível.

Como a Milvus apoia o processo de correspondência de diretrizes do Parlant

A correspondência de diretrizes funciona através da similaridade semântica. O campo Condição de cada diretriz é convertido em uma incorporação vetorial, capturando o seu significado e não apenas o seu texto literal. Quando um usuário envia uma mensagem, o Parlant compara a semântica dessa mensagem com todas as incorporações de diretrizes armazenadas para encontrar as mais relevantes.

Veja a seguir como o processo funciona passo a passo:

1. Codificar a consulta - A mensagem do utilizador e o histórico de conversas recentes são transformados num vetor de consulta.

2. Procura de semelhanças - O sistema efectua uma pesquisa de semelhanças no vetor de diretrizes para encontrar as correspondências mais próximas.

3. Obter resultados Top-K - São apresentadas as três a cinco diretrizes semanticamente mais relevantes.

4. Injetar no contexto - Estas diretrizes correspondentes são então inseridas dinamicamente no contexto do LLM para que o modelo possa agir de acordo com as regras corretas.

Para tornar este fluxo de trabalho possível, a base de dados de vectores tem de fornecer três capacidades críticas: pesquisa de alto desempenho no vizinho mais próximo (ANN), filtragem flexível de metadados e actualizações de vectores em tempo real. O Milvus, o banco de dados vetorial nativo da nuvem e de código aberto, oferece desempenho de nível de produção em todas as três áreas.

Para entender como o Milvus funciona em cenários reais, vamos analisar um agente de serviços financeiros como exemplo.

Suponhamos que o sistema define 800 diretrizes comerciais que abrangem tarefas como pedidos de informação sobre contas, transferências de fundos e consultas sobre produtos de gestão de património. Nesta configuração, o Milvus actua como camada de armazenamento e recuperação de todos os dados das diretrizes.

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)

Agora, quando um utilizador diz "Quero transferir 100.000 RMB para a conta da minha mãe", o fluxo em tempo de execução é

1. Rectorizar a consulta - Converter a entrada do utilizador num vetor de 768 dimensões.

2. Recuperação híbrida - Executar uma pesquisa de semelhança vetorial em Milvus com filtragem de metadados (por exemplo, business_domain="transfer").

3. Classificação dos resultados - Classificar as diretrizes candidatas com base nas pontuações de semelhança combinadas com os seus valores de prioridade.

4. Injeção de contexto - Injete as três melhores diretrizes correspondentes action_text no contexto do agente Parlant.

Nesta configuração, o Milvus fornece latência P99 abaixo de 15 ms, mesmo quando a biblioteca de diretrizes é dimensionada para 100.000 entradas. Em comparação, o uso de um banco de dados relacional tradicional com correspondência de palavras-chave normalmente resulta em latência acima de 200 ms e precisão de correspondência significativamente menor.

Como o Milvus permite a memória a longo prazo e a personalização

O Milvus faz mais do que a correspondência de diretrizes. Em cenários em que os agentes necessitam de memória de longo prazo e de respostas personalizadas, o Milvus pode servir como camada de memória que armazena e recupera as interações passadas dos utilizadores como embeddings vectoriais, ajudando o agente a lembrar-se do que foi discutido anteriormente.

# 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))

Quando o mesmo utilizador regressa, o agente pode recuperar as interações históricas mais relevantes do Milvus e utilizá-las para gerar uma experiência mais conectada e semelhante à humana. Por exemplo, se um utilizador fez uma pergunta sobre um fundo de investimento na semana passada, o agente pode recordar esse contexto e responder de forma proactiva: "Bem-vindo de volta! Ainda tem dúvidas sobre o fundo que falámos da última vez?"

Como otimizar o desempenho dos sistemas de agentes com tecnologia Milvus

Quando se implementa um sistema de agentes alimentado por Milvus num ambiente de produção, a afinação do desempenho torna-se crítica. Para alcançar baixa latência e alta taxa de transferência, vários parâmetros-chave precisam de atenção:

1. Escolher o tipo de índice correto

É importante selecionar a estrutura de índice adequada. Por exemplo, o HNSW (Hierarchical Navigable Small World) é ideal para cenários de alta recuperação, como finanças ou saúde, em que a precisão é fundamental. O IVF_FLAT funciona melhor para aplicações de grande escala, como recomendações de comércio eletrónico, em que é aceitável uma recuperação ligeiramente inferior em troca de um desempenho mais rápido e de uma menor utilização de memória.

2. Estratégia de fragmentação

Quando o número de diretrizes armazenadas excede um milhão de entradas, é recomendável usar Partição para dividir os dados por domínio de negócios ou caso de uso. O particionamento reduz o espaço de pesquisa por consulta, melhorando a velocidade de recuperação e mantendo a latência estável mesmo com o crescimento do conjunto de dados.

3. Configuração da cache

Para diretrizes frequentemente acedidas, tais como consultas padrão de clientes ou fluxos de trabalho de elevado tráfego, pode utilizar a cache de resultados de consultas Milvus. Isto permite que o sistema reutilize resultados anteriores, reduzindo a latência para menos de 5 milissegundos em pesquisas repetidas.

Demonstração prática: Como construir um sistema inteligente de perguntas e respostas com Parlant e Milvus Lite

O Milvus Lite é uma versão leve do Milvus - uma biblioteca Python que pode ser facilmente incorporada nas suas aplicações. É ideal para prototipagem rápida em ambientes como Jupyter Notebooks ou para execução em dispositivos inteligentes e de ponta com recursos computacionais limitados. Apesar de sua pequena pegada, o Milvus Lite suporta as mesmas APIs que outras implantações do Milvus. Isto significa que o código do lado do cliente que escrever para o Milvus Lite pode ligar-se sem problemas a uma instância completa do Milvus ou do Zilliz Cloud mais tarde - sem necessidade de refactoring.

Nesta demonstração, usaremos o Milvus Lite em conjunto com o Parlant para demonstrar como criar um sistema inteligente de perguntas e respostas que fornece respostas rápidas e contextualizadas com configuração mínima.

Pré-requisitos：

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

2. documentação do Parlant: https://parlant.io/docs

3. python3.10+

4.OpenAI_key

5.MlivusLite

Passo 1: Instalar as dependências

# 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

Passo 2: Configurar as variáveis de ambiente

# 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

Passo 3: Implementar o código principal

• Criar um OpenAI Embedder personalizado

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

• Inicializar a base de conhecimento

1. criar uma coleção Milvus chamada kb_articles.

2. inserir dados de amostra (por exemplo, política de reembolso, política de troca, tempo de envio).

3. construir um índice HNSW para acelerar a recuperação.

• Construir a ferramenta de pesquisa vetorial

@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

• Configurar o agente Parlant

Diretriz 1: Para perguntas factuais ou relacionadas com políticas, o agente deve primeiro efetuar uma pesquisa vetorial.

Diretriz 2: Quando são encontradas provas, o agente deve responder utilizando um modelo estruturado (resumo + pontos-chave + fontes).

# 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=[],

)

• Escreva o código completo

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())

Etapa 4: Executar o código

# Run the main program
python main.py

• Visite o Playground:

<http://localhost:8800>

Agora já construiu com sucesso um sistema inteligente de perguntas e respostas usando Parlant e Milvus.

Parlant vs. LangChain/LlamaIndex: Como eles se diferenciam e como trabalham juntos

Em comparação com as estruturas de agentes existentes, como LangChain ou LlamaIndex, como a Parlant se diferencia?

LangChain e LlamaIndex são frameworks de uso geral. Eles fornecem uma ampla gama de componentes e integrações, tornando-os ideais para prototipagem rápida e experiências de pesquisa. No entanto, quando se trata de implantação em produção, os desenvolvedores geralmente precisam construir camadas extras eles mesmos - como gerenciamento de regras, verificações de conformidade e mecanismos de confiabilidade - para manter os agentes consistentes e confiáveis.

Parlant oferece Gerenciamento de Diretrizes integrado, mecanismos de auto-crítica e ferramentas de explicabilidade que ajudam os desenvolvedores a gerenciar como um agente se comporta, responde e raciocina. Isso torna a Parlant especialmente adequada para casos de uso de alto risco e voltados para o cliente, nos quais a precisão e a responsabilidade são importantes, como finanças, saúde e serviços jurídicos.

Na verdade, esses frameworks podem trabalhar juntos:

• Use o LangChain para criar pipelines complexos de processamento de dados ou fluxos de trabalho de recuperação.

• Utilize o Parlant para gerir a camada de interação final, garantindo que os resultados seguem as regras comerciais e permanecem interpretáveis.

• Utilizar o Milvus como base de dados vetorial para fornecer pesquisa semântica em tempo real, memória e recuperação de conhecimentos em todo o sistema.

Conclusão

À medida que os agentes de LLM passam da experimentação para a produção, a questão-chave não é mais o que eles podem fazer, mas com que confiabilidade e segurança eles podem fazer isso. O Parlant fornece a estrutura e o controlo para essa fiabilidade, enquanto o Milvus fornece a infraestrutura vetorial escalável que mantém tudo rápido e consciente do contexto.

Juntos, eles permitem que os desenvolvedores criem agentes de IA que não são apenas capazes, mas confiáveis, explicáveis e prontos para a produção.

Confira o Parlant no GitHub e integre-o ao Milvus para criar seu próprio sistema de agente inteligente e orientado por regras.

Tem perguntas ou quer um mergulho profundo em qualquer recurso? Junte-se ao nosso canal Discord ou registre problemas no GitHub. Também pode reservar uma sessão individual de 20 minutos para obter informações, orientação e respostas às suas perguntas através do Milvus Office Hours.