Milvus
Zilliz
  • Home
  • Blog

  • Más allá de la sobrecarga de contexto: Cómo Parlant × Milvus aporta control y claridad al comportamiento de los agentes LLM

Más allá de la sobrecarga de contexto: Cómo Parlant × Milvus aporta control y claridad al comportamiento de los agentes LLM

  • Tutorials
November 05, 2025
Min Yin

Imagínese que le dicen que complete una tarea que implica 200 reglas de negocio, 50 herramientas y 30 demostraciones, y sólo tiene una hora para hacerlo. Eso es sencillamente imposible. Sin embargo, a menudo esperamos que los grandes modelos lingüísticos hagan exactamente eso cuando los convertimos en "agentes" y los sobrecargamos de instrucciones.

En la práctica, este planteamiento se rompe rápidamente. Los marcos de agentes tradicionales, como LangChain o LlamaIndex, inyectan todas las reglas y herramientas en el contexto del modelo a la vez, lo que provoca conflictos entre reglas, sobrecarga del contexto y un comportamiento impredecible en la producción.

Para abordar este problema, un marco de agentes de código abierto llamado Parlant ha ido ganando terreno recientemente en GitHub. Introduce un nuevo enfoque llamado Alignment Modeling, junto con un mecanismo de supervisión y transiciones condicionales que hacen que el comportamiento del agente sea mucho más controlable y explicable.

Cuando se combina con Milvus, una base de datos vectorial de código abierto, Parlant es aún más capaz. Milvus añade inteligencia semántica, permitiendo a los agentes recuperar dinámicamente las reglas más relevantes y el contexto en tiempo real, manteniéndolos precisos, eficientes y listos para la producción.

En este artículo, exploraremos cómo funciona Parlant bajo el capó y cómo su integración con Milvus permite alcanzar el nivel de producción.

Por qué los marcos de agentes tradicionales fracasan

A los marcos de agentes tradicionales les encanta ir a lo grande: cientos de reglas, docenas de herramientas y un puñado de demos, todo ello metido en un único y sobrecargado prompt. Puede quedar muy bien en una demostración o en una pequeña prueba de caja de arena, pero una vez que se pone en producción, las grietas empiezan a aparecer rápidamente.

  • Las reglas contradictorias provocan el caos: Cuando se aplican dos o más reglas al mismo tiempo, estos marcos no tienen una forma integrada de decidir cuál gana. A veces elige una. A veces combina ambas. A veces hace algo totalmente imprevisible.

  • Los casos extremos dejan al descubierto las lagunas: No es posible predecir todo lo que un usuario puede decir. Y cuando su modelo se encuentra con algo fuera de sus datos de entrenamiento, recurre por defecto a respuestas genéricas y sin compromiso.

  • La depuración es dolorosa y costosa: Cuando un agente se comporta mal, es casi imposible determinar con precisión qué regla causó el problema. Dado que todo vive dentro de un prompt gigante del sistema, la única manera de solucionarlo es reescribir el prompt y volver a probar todo desde cero.

Qué es Parlant y cómo funciona

Parlant es un motor de alineación de código abierto para agentes LLM. Puedes controlar con precisión cómo se comporta un agente en diferentes escenarios modelando su proceso de toma de decisiones de una forma estructurada y basada en reglas.

Para hacer frente a los problemas encontrados en los marcos de agentes tradicionales, Parlant introduce un nuevo y potente enfoque: Modelado de alineación. Su idea central es separar la definición de reglas de su ejecución, garantizando que sólo se inyecten en el contexto del LLM las reglas más relevantes en cada momento.

Directrices granulares: El núcleo del modelado de alineación

En el corazón del modelo de alineación de Parlant está el concepto de Directrices Granulares. En lugar de escribir un sistema gigante lleno de reglas, se definen pequeñas directrices modulares, cada una describiendo cómo el agente debe manejar un tipo específico de situación.

Cada directriz consta de tres partes:

  • Condición - Una descripción en lenguaje natural de cuándo debe aplicarse la regla. Parlant convierte esta condición en un vector semántico y lo compara con la entrada del usuario para averiguar si es relevante.

  • Acción - Una instrucción clara que define cómo debe responder el agente una vez que se cumple la condición. Esta acción se inyecta en el contexto del LLM sólo cuando se activa.

  • Herramientas - Cualquier función externa o API vinculada a esa regla específica. Éstas se exponen al agente sólo cuando la directriz está activa, manteniendo el uso de herramientas controlado y consciente del 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]
)

Cada vez que un usuario interactúa con el agente, Parlant ejecuta un paso de correspondencia ligero para encontrar las tres a cinco directrices más relevantes. Sólo esas reglas se inyectan en el contexto del modelo, manteniendo las indicaciones concisas y centradas, y garantizando al mismo tiempo que el agente siga sistemáticamente las reglas correctas.

Mecanismo de supervisión de la precisión y la coherencia

Para mantener la precisión y la coherencia, Parlant introduce un mecanismo de supervisión que actúa como una segunda capa de control de calidad. El proceso se desarrolla en tres pasos:

1. 1.Generación de una respuesta candidata: el agente crea una respuesta inicial basada en las directrices coincidentes y el contexto actual de la conversación.

2. 2.Comprobación de laconformidad - La respuesta se compara con las directrices activas para verificar que se han seguido correctamente todas las instrucciones.

3. 3.Revisar o confirmar: si se detecta algún problema, el sistema corrige el resultado; si todo es correcto, la respuesta se aprueba y se envía al usuario.

Este mecanismo de supervisión garantiza que el agente no sólo entiende las normas, sino que las cumple antes de responder, lo que mejora tanto la fiabilidad como el control.

Transiciones condicionales para el control y la seguridad

En los marcos de agentes tradicionales, todas las herramientas disponibles están expuestas al LLM en todo momento. Este enfoque de "todo sobre la mesa" a menudo conduce a peticiones sobrecargadas y llamadas a herramientas no intencionadas. Parlant resuelve esto a través de transiciones condicionales. De forma similar al funcionamiento de las máquinas de estado, una acción o herramienta se activa sólo cuando se cumple una condición específica. Cada herramienta está estrechamente vinculada a su directriz correspondiente, y sólo está disponible cuando se activa la condición de esa directriz.

# 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 convierte la invocación de herramientas en una transición condicional: las herramientas pasan de "inactivas" a "activas" sólo cuando se cumplen sus condiciones de activación. Al estructurar la ejecución de este modo, Parlant garantiza que cada acción se realice de forma deliberada y contextual, lo que evita el uso indebido y mejora la eficacia y la seguridad del sistema.

Cómo Milvus potencia Parlant

Cuando miramos bajo el capó del proceso de correspondencia de pautas de Parlant, queda claro un reto técnico fundamental: ¿cómo puede el sistema encontrar las tres o cinco reglas más relevantes de entre cientos (o incluso miles) de opciones en tan solo unos milisegundos? Ahí es exactamente donde entra en juego una base de datos vectorial. La recuperación semántica es lo que lo hace posible.

Cómo Milvus apoya el proceso de correspondencia de directrices de Parlant

La correspondencia de directrices funciona a través de la similitud semántica. El campo Condición de cada directriz se convierte en una incrustación vectorial, capturando su significado en lugar de sólo su texto literal. Cuando un usuario envía un mensaje, Parlant compara la semántica de ese mensaje con todas las incrustaciones de directrices almacenadas para encontrar las más relevantes.

Así funciona el proceso paso a paso:

1. Codificar la consulta - El mensaje del usuario y el historial de conversaciones recientes se transforman en un vector de consulta.

2. 2. Búsquedade similitudes - El sistema realiza una búsqueda de similitudes dentro del almacén de vectores de pautas para encontrar las coincidencias más cercanas.

3. 3.Obtención de los resultados Top-K: se muestran las tres a cinco directrices semánticamente más relevantes.

4. 4.Inyectar en el contexto - Estas directrices coincidentes se insertan dinámicamente en el contexto del LLM para que el modelo pueda actuar de acuerdo con las reglas correctas.

Para que este flujo de trabajo sea posible, la base de datos vectorial debe ofrecer tres capacidades críticas: búsqueda de alto rendimiento por vecino más próximo aproximado (RNA), filtrado flexible de metadatos y actualizaciones de vectores en tiempo real. Milvus, la base de datos vectorial de código abierto y nativa de la nube, proporciona un rendimiento de nivel de producción en las tres áreas.

Para entender cómo funciona Milvus en escenarios reales, veamos el ejemplo de un agente de servicios financieros.

Supongamos que el sistema define 800 directrices empresariales que abarcan tareas como consultas de cuentas, transferencias de fondos y consultas de productos de gestión de patrimonios. En esta configuración, Milvus actúa como capa de almacenamiento y recuperación de todos los datos de las directrices.

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)

Ahora, cuando un usuario dice "Quiero transferir 100.000 RMB a la cuenta de mi madre", el flujo en tiempo de ejecución es:

1. Rectorizar la consulta - Convertir la entrada del usuario en un vector de 768 dimensiones.

2. 2.Recuperación híbrida - Ejecutar una búsqueda de similitud vectorial en Milvus con filtrado de metadatos (por ejemplo, business_domain="transfer").

3. Clasificación delos resultados - Clasificar las directrices candidatas en función de las puntuaciones de similitud combinadas con sus valores de prioridad.

4. Inyección de contexto - Inyectar las tres directrices más parecidas action_text en el contexto del agente Parlant.

Con esta configuración, Milvus ofrece una latencia P99 inferior a 15 ms, incluso cuando la biblioteca de directrices alcanza las 100.000 entradas. En comparación, el uso de una base de datos relacional tradicional con concordancia de palabras clave suele dar como resultado una latencia superior a 200 ms y una precisión de concordancia significativamente inferior.

Cómo Milvus permite la memoria a largo plazo y la personalización

Milvus hace algo más que la concordancia de pautas. En escenarios en los que los agentes necesitan memoria a largo plazo y respuestas personalizadas, Milvus puede servir como la capa de memoria que almacena y recupera las interacciones pasadas de los usuarios como incrustaciones vectoriales, ayudando al agente a recordar lo que se discutió 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))

Cuando vuelve el mismo usuario, el agente puede recuperar las interacciones históricas más relevantes de Milvus y utilizarlas para generar una experiencia más conectada y similar a la humana. Por ejemplo, si un usuario preguntó sobre un fondo de inversión la semana pasada, el agente puede recordar ese contexto y responder de forma proactiva: "¡Bienvenido de nuevo! ¿Todavía tiene preguntas sobre el fondo del que hablamos la última vez?".

Cómo optimizar el rendimiento de los sistemas de agentes basados en Milvus

Cuando se despliega un sistema de agentes alimentado por Milvus en un entorno de producción, el ajuste del rendimiento se convierte en algo crítico. Para lograr una baja latencia y un alto rendimiento, es necesario prestar atención a varios parámetros clave:

1. Elección del tipo de índice adecuado

Es importante seleccionar la estructura de índice adecuada. Por ejemplo, HNSW (Hierarchical Navigable Small World) es ideal para escenarios de alta recuperación como las finanzas o la sanidad, donde la precisión es crítica. IVF_FLAT funciona mejor para aplicaciones a gran escala, como las recomendaciones de comercio electrónico, en las que una recuperación ligeramente inferior es aceptable a cambio de un rendimiento más rápido y un menor uso de memoria.

2. Estrategia de fragmentación

Cuando el número de pautas almacenadas supera el millón de entradas, se recomienda utilizar Partition para dividir los datos por dominio de negocio o caso de uso. La partición reduce el espacio de búsqueda por consulta, mejorando la velocidad de recuperación y manteniendo la latencia estable incluso a medida que crece el conjunto de datos.

3. Configuración de la caché

Para las directrices a las que se accede con frecuencia, como las consultas estándar de clientes o los flujos de trabajo de alto tráfico, puede utilizar la caché de resultados de consulta de Milvus. Esto permite al sistema reutilizar resultados anteriores, reduciendo la latencia a menos de 5 milisegundos para búsquedas repetidas.

Demostración práctica: Cómo construir un sistema inteligente de preguntas y respuestas con Parlant y Milvus Lite

Milvus Lite es una versión ligera de Milvus, una biblioteca Python que puede integrarse fácilmente en sus aplicaciones. Es ideal para la creación rápida de prototipos en entornos como Jupyter Notebooks o para ejecutarse en dispositivos edge e inteligentes con recursos informáticos limitados. A pesar de su pequeño tamaño, Milvus Lite es compatible con las mismas API que otras implementaciones de Milvus. Esto significa que el código del lado del cliente que escriba para Milvus Lite puede conectarse sin problemas a una instancia completa de Milvus o Zilliz Cloud más adelante, sin necesidad de refactorización.

En esta demostración, utilizaremos Milvus Lite junto con Parlant para demostrar cómo crear un sistema inteligente de preguntas y respuestas que ofrezca respuestas rápidas y contextualizadas con una configuración mínima.

Requisitos previos：

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

2.Documentación de Parlant: https://parlant.io/docs

3.python3.10+

4.OpenAI_key

5.MlivusLite

Paso 1: Instalar dependencias

# 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

Paso 2: Configurar las variables de entorno

# 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

Paso 3: Implementar el código base

  • Crear un 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 la base de conocimientos

1.Cree una colección Milvus llamada kb_articles.

2.Inserte datos de ejemplo (por ejemplo, política de reembolso, política de cambio, tiempo de envío).

3.Construir un índice HNSW para acelerar la recuperación.

  • 4.Construir la herramienta de búsqueda vectorial
@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 el agente Parlant

Directriz 1: Para preguntas relacionadas con hechos o políticas, el agente debe realizar primero una búsqueda vectorial.

Directriz 2: Cuando se encuentran pruebas, el agente debe responder utilizando una plantilla estructurada (resumen + puntos clave + fuentes).

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



)
  • Escribir el 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())

Paso 4: Ejecutar el código

# Run the main program
python main.py

  • Visite el Playground:
<http://localhost:8800>

Ahora has construido con éxito un sistema inteligente de preguntas y respuestas utilizando Parlant y Milvus.

Parlant vs. LangChain/LlamaIndex: En qué se diferencian y cómo trabajan juntos

¿En qué se diferencia Parlant de otros marcos de agentes como LangChain o LlamaIndex?

LangChain y LlamaIndex son marcos de propósito general. Ofrecen una amplia gama de componentes e integraciones, lo que los hace ideales para la creación rápida de prototipos y experimentos de investigación. Sin embargo, cuando se trata de desplegar en producción, los desarrolladores a menudo necesitan construir ellos mismos capas adicionales -como gestión de reglas, comprobaciones de cumplimiento y mecanismos de fiabilidad- para mantener la coherencia y la fiabilidad de los agentes.

Parlant ofrece gestión de directrices integrada, mecanismos de autocrítica y herramientas de explicabilidad que ayudan a los desarrolladores a gestionar cómo se comporta, responde y razona un agente. Esto hace que Parlant sea especialmente adecuado para casos de uso de alto riesgo y de cara al cliente en los que la precisión y la responsabilidad son importantes, como las finanzas, la sanidad y los servicios jurídicos.

De hecho, estos marcos pueden funcionar juntos:

  • Utiliza LangChain para crear complejos canales de procesamiento de datos o flujos de trabajo de recuperación.

  • Utilice Parlant para gestionar la capa de interacción final, garantizando que los resultados sigan las normas empresariales y sean interpretables.

  • Utilizar Milvus como base de datos vectorial para ofrecer búsqueda semántica en tiempo real, memoria y recuperación de conocimientos en todo el sistema.

Conclusión

A medida que los agentes LLM pasan de la experimentación a la producción, la pregunta clave ya no es qué pueden hacer, sino cómo de fiables y seguros pueden hacerlo. Parlant proporciona la estructura y el control para esa fiabilidad, mientras que Milvus proporciona la infraestructura vectorial escalable que mantiene todo rápido y consciente del contexto.

Juntos, permiten a los desarrolladores crear agentes de IA que no solo son capaces, sino fiables, explicables y listos para la producción.

🚀 Echa un vistazo a Parlant en GitHub e intégralo con Milvus para construir tu propio sistema de agente inteligente basado en reglas.

Tienes preguntas o quieres una inmersión profunda en alguna característica? Únase a nuestro canal de Discord o envíe incidencias a GitHub. También puede reservar una sesión individual de 20 minutos para obtener información, orientación y respuestas a sus preguntas a través de Milvus Office Hours.

    Try Managed Milvus for Free

    Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

    Get Started

    Like the article? Spread the word

    Sigue Leyendo