LangChain 1.0 y Milvus: cómo crear agentes listos para la producción con memoria a largo plazo real

LangChain es un popular marco de código abierto para el desarrollo de aplicaciones basadas en grandes modelos lingüísticos (LLM). Proporciona un conjunto de herramientas modulares para crear agentes que razonen y utilicen herramientas, conectar modelos a datos externos y gestionar flujos de interacción.

Con el lanzamiento de LangChain 1.0, el marco da un paso hacia una arquitectura más fácil de producir. La nueva versión sustituye el diseño anterior basado en cadenas por un bucle ReAct estandarizado (Razonar → Llamar a la herramienta → Observar → Decidir) e introduce middleware para gestionar la ejecución, el control y la seguridad.

Sin embargo, el razonamiento por sí solo no es suficiente. Los agentes también necesitan la capacidad de almacenar, recuperar y reutilizar información. Ahí es donde Milvus, una base de datos vectorial de código abierto, puede desempeñar un papel esencial. Milvus proporciona una capa de memoria escalable y de alto rendimiento que permite a los agentes almacenar, buscar y recuperar información de forma eficiente a través de la similitud semántica.

En este post, exploraremos cómo LangChain 1.0 actualiza la arquitectura de agentes y cómo la integración de Milvus ayuda a los agentes a ir más allá del razonamiento, permitiendo una memoria persistente e inteligente para casos de uso del mundo real.

Por qué el diseño basado en cadenas se queda corto

En sus primeros días (versión 0.x), la arquitectura de LangChain se centraba en Cadenas. Cada Cadena definía una secuencia fija y venía con plantillas pre-construidas que hacían la orquestación LLM simple y rápida. Este diseño era genial para construir prototipos rápidamente. Pero a medida que el ecosistema LLM evolucionaba y los casos de uso en el mundo real se hacían más complejos, empezaron a aparecer grietas en esta arquitectura.

1. 1. Falta de flexibilidad

Las primeras versiones de LangChain proporcionaban pipelines modulares como SimpleSequentialChain o LLMChain, cada uno de los cuales seguía un flujo fijo y lineal: creación de la solicitud → llamada al modelo → procesamiento de la salida. Este diseño funcionaba bien para tareas sencillas y predecibles y facilitaba la creación rápida de prototipos.

Sin embargo, a medida que las aplicaciones se volvían más dinámicas, estas plantillas rígidas empezaron a resultar restrictivas. Cuando la lógica de negocio ya no encaja perfectamente en una secuencia predefinida, te quedas con dos opciones insatisfactorias: forzar tu lógica para que se ajuste al framework o eludirlo por completo llamando directamente a la API de LLM.

2. Falta de control de producción

Lo que funcionaba bien en las demos a menudo no funcionaba en producción. Las cadenas no incluían las salvaguardas necesarias para aplicaciones a gran escala, persistentes o sensibles. Algunos de los problemas más comunes son

• Desbordamiento de contexto: Las conversaciones largas podían superar los límites de tokens, provocando bloqueos o truncamientos silenciosos.

• Fugas de datos sensibles: La información personal identificable (como correos electrónicos o identificaciones) podría enviarse inadvertidamente a modelos de terceros.

• Operaciones no supervisadas: Los agentes podrían borrar datos o enviar correos electrónicos sin la aprobación humana.

3. Falta de compatibilidad entre modelos

Cada proveedor de LLM -OpenAI, Anthropic y muchos modelos chinos- implementa sus propios protocolos de razonamiento y llamada a herramientas. Cada vez que se cambiaba de proveedor, había que reescribir la capa de integración: plantillas de solicitud, adaptadores y analizadores de respuestas. Este trabajo repetitivo ralentizaba el desarrollo y dificultaba la experimentación.

LangChain 1.0: Agente ReAct todo en uno

Cuando el equipo de LangChain analizó cientos de implementaciones de agentes en producción, hubo una idea que saltó a la vista: casi todos los agentes de éxito convergían de forma natural en el patrón ReAct ("Razonamiento + Actuación").

Tanto si se trata de un sistema multiagente como de un único agente que realiza un razonamiento profundo, surge el mismo bucle de control: alternar breves pasos de razonamiento con llamadas a herramientas específicas y, a continuación, alimentar las decisiones posteriores con las observaciones resultantes hasta que el agente pueda ofrecer una respuesta final.

Para basarse en esta estructura probada, LangChain 1.0 sitúa el bucle ReAct en el núcleo de su arquitectura, convirtiéndolo en la estructura por defecto para construir agentes fiables, interpretables y listos para la producción.

Para soportar desde agentes sencillos hasta orquestaciones complejas, LangChain 1.0 adopta un diseño en capas que combina la facilidad de uso con un control preciso:

• Escenarios estándar: Comience con la función create_agent() - un bucle ReAct limpio y estandarizado que maneja el razonamiento y las llamadas a herramientas fuera de la caja.

• Escenarios ampliados: Añada middleware para obtener un control más preciso. El middleware le permite inspeccionar o modificar lo que ocurre dentro del agente, por ejemplo, añadiendo detección PII, puntos de control de aprobación humana, reintentos automáticos o ganchos de supervisión.

• Escenarios complejos: Para flujos de trabajo con estados u orquestación multiagente, utilice LangGraph, un motor de ejecución basado en gráficos que proporciona un control preciso sobre el flujo lógico, las dependencias y los estados de ejecución.

Ahora vamos a desglosar los tres componentes clave que hacen que el desarrollo de agentes sea más sencillo, seguro y coherente en todos los modelos.

1. La función create_agent(): Una forma más sencilla de crear agentes

Un avance clave en LangChain 1.0 es cómo reduce la complejidad de construir agentes a una única función - create_agent(). Ya no es necesario manejar manualmente la gestión de estados, la gestión de errores o la transmisión de salidas. Estas características de nivel de producción son ahora gestionadas automáticamente por el tiempo de ejecución LangGraph subyacente.

Con sólo tres parámetros, puedes lanzar un agente completamente funcional:

• model - un identificador de modelo (cadena) o un objeto modelo instanciado.

• tools - una lista de funciones que dan al agente sus habilidades.

• system_prompt - la instrucción que define el rol, tono y comportamiento del agente.

Bajo el capó, create_agent() se ejecuta en el bucle de agente estándar - llamando a un modelo, dejándole elegir las herramientas a ejecutar, y completando una vez que no se necesitan más herramientas:

También hereda las capacidades incorporadas de LangGraph para la persistencia del estado, la recuperación de interrupciones y el streaming. Las tareas que antes requerían cientos de líneas de código de orquestación ahora se gestionan a través de una única API declarativa.

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. El middleware: Una capa componible para un control listo para la producción

El middleware es el puente clave que lleva a LangChain del prototipo a la producción. Expone ganchos en puntos estratégicos del bucle de ejecución del agente, lo que permite añadir lógica personalizada sin reescribir el proceso central de ReAct.

El bucle principal de un agente sigue un proceso de decisión de tres pasos - Modelo → Herramienta → Terminación:

LangChain 1.0 proporciona algunos middlewares preconstruidos para patrones comunes. He aquí cuatro ejemplos.

• Detección de PII: Cualquier aplicación que maneje datos sensibles del usuario.

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

• Resumir: Resume automáticamente el historial de conversaciones cuando se acerca al límite de tokens.

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

• Reintento de herramientas: Reintento automático de llamadas a herramientas fallidas con un backoff exponencial configurable.

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

)

• Middleware personalizado

Además de las opciones de middleware oficiales y predefinidas, también puedes crear middleware personalizado mediante decoradores o clases.

Por ejemplo, el siguiente fragmento muestra cómo registrar las llamadas al modelo antes de la ejecución:

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. Salida estructurada: Una forma estandarizada de manejar datos

En el desarrollo tradicional de agentes, la salida estructurada siempre ha sido difícil de gestionar. Por ejemplo, OpenAI ofrece una API nativa de salida estructurada, mientras que otros sólo soportan respuestas estructuradas indirectamente a través de llamadas a herramientas. Esto a menudo significaba escribir adaptadores personalizados para cada proveedor, añadiendo trabajo extra y haciendo el mantenimiento más doloroso de lo que debería ser.

En LangChain 1.0, la salida estructurada se gestiona directamente a través del parámetro response_format de create_agent(). Sólo es necesario definir el esquema de datos una vez. LangChain elige automáticamente la mejor estrategia de aplicación en función del modelo que esté utilizando, sin necesidad de configuración adicional ni de código específico del proveedor.

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 admite dos estrategias para la salida estructurada:

1. Estrategia del proveedor: Algunos proveedores de modelos soportan de forma nativa la salida estructurada a través de sus API (por ejemplo, OpenAI y Grok). Cuando este soporte está disponible, LangChain utiliza directamente la aplicación de esquemas incorporada en el proveedor. Este enfoque ofrece el máximo nivel de fiabilidad y coherencia, ya que el propio modelo garantiza el formato de salida.

2. Estrategia de llamada a la herramienta: Para los modelos que no soportan la salida estructurada nativa, LangChain utiliza la llamada a herramientas para lograr el mismo resultado.

No tiene que preocuparse de qué estrategia se está utilizando: el marco de trabajo detecta las capacidades del modelo y se adapta automáticamente. Esta abstracción le permite cambiar libremente entre diferentes proveedores de modelos sin cambiar su lógica empresarial.

Cómo Milvus mejora la memoria del agente

Para los agentes de producción, el verdadero cuello de botella del rendimiento no suele ser el motor de razonamiento, sino el sistema de memoria. En LangChain 1.0, las bases de datos vectoriales actúan como memoria externa del agente, proporcionando memoria a largo plazo a través de la recuperación semántica.

Milvus es una de las bases de datos vectoriales de código abierto más maduras disponibles en la actualidad, creada específicamente para la búsqueda vectorial a gran escala en aplicaciones de IA. Se integra de forma nativa con LangChain, por lo que no es necesario gestionar manualmente la vectorización, la gestión de índices o la búsqueda de similitudes. El paquete langchain_milvus envuelve Milvus como una interfaz VectorStore estándar, lo que le permite conectarlo a sus agentes con sólo unas pocas líneas de código.

De este modo, Milvus aborda tres retos clave en la construcción de sistemas de memoria de agentes escalables y fiables:

1. Recuperación rápida de bases de conocimiento masivas

Cuando un agente necesita procesar miles de documentos, conversaciones pasadas o manuales de productos, la simple búsqueda por palabras clave no es suficiente. Milvus utiliza la búsqueda por similitud vectorial para encontrar información semánticamente relevante en milisegundos, incluso si la consulta utiliza una redacción diferente. Esto permite a su agente recuperar conocimientos basándose en el significado, no sólo en coincidencias exactas de texto.

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. Memoria persistente a largo plazo

El SummarizationMiddleware de LangChain puede condensar el historial de la conversación cuando se hace demasiado largo, pero ¿qué ocurre con todos los detalles que se resumen? Milvus los conserva. Cada conversación, llamada a herramientas y paso de razonamiento puede vectorizarse y almacenarse para su consulta a largo plazo. Cuando es necesario, el agente puede recuperar rápidamente los recuerdos relevantes mediante la búsqueda semántica, lo que permite una verdadera continuidad entre sesiones.

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. Gestión unificada de contenidos multimodales

Los agentes modernos manejan más que texto: interactúan con imágenes, audio y vídeo. Milvus admite el almacenamiento multivectorial y el esquema dinámico, lo que le permite gestionar incrustaciones de múltiples modalidades en un único sistema. Esto proporciona una base de memoria unificada para agentes multimodales, permitiendo una recuperación consistente a través de diferentes tipos de datos.

# 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 frente a LangGraph: Cómo elegir el más adecuado para sus agentes

Actualizarse a LangChain 1.0 es un paso esencial hacia la creación de agentes de producción, pero eso no significa que sea siempre la única o la mejor opción para cada caso de uso. Elegir el marco de trabajo adecuado determina la rapidez con la que se pueden combinar estas capacidades en un sistema funcional y fácil de mantener.

En realidad, LangChain 1.0 y LangGraph 1.0 pueden considerarse parte de la misma pila de capas, diseñadas para trabajar juntas en lugar de sustituirse mutuamente: LangChain te ayuda a construir agentes estándar rápidamente, mientras que LangGraph te da un control detallado para flujos de trabajo complejos. En otras palabras, LangChain le ayuda a moverse rápido, mientras que LangGraph le ayuda a profundizar.

A continuación se muestra una rápida comparación de cómo se diferencian en el posicionamiento técnico:

Dimensión	LangChain 1.0	LangChain 1.0
Nivel de abstracción	Abstracción de alto nivel, diseñada para escenarios de agentes estándar	Marco de orquestación de bajo nivel, diseñado para flujos de trabajo complejos
Capacidad básica	Bucle ReAct estándar (Razón → Llamada a herramienta → Observación → Respuesta)	Máquinas de estado personalizadas y lógica de bifurcación compleja (StateGraph + enrutamiento condicional)
Mecanismo de extensión	Middleware para capacidades de nivel de producción	Gestión manual de nodos, aristas y transiciones de estado
Implementación subyacente	Gestión manual de nodos, aristas y transiciones de estado	Tiempo de ejecución nativo con persistencia y recuperación integradas
Casos de uso típicos	80% de los escenarios de agentes estándar	Colaboración multiagente y orquestación de flujos de trabajo de larga duración
Curva de aprendizaje	Construir un agente en ~10 líneas de código	Requiere conocimientos de gráficos de estado y orquestación de nodos

Si es la primera vez que construye agentes o quiere poner en marcha un proyecto rápidamente, empiece con LangChain. Si ya sabes que tu caso de uso requiere una orquestación compleja, colaboración multi-agente, o flujos de trabajo de larga duración, ve directamente a LangGraph.

Ambos frameworks pueden coexistir en el mismo proyecto: puedes empezar de forma sencilla con LangChain e incorporar LangGraph cuando tu sistema necesite más control y flexibilidad. La clave está en elegir la herramienta adecuada para cada parte de tu flujo de trabajo.

Conclusión

Hace tres años, LangChain comenzó como una envoltura ligera para llamar a LLMs. Hoy en día, se ha convertido en un completo marco de producción.

En el núcleo, las capas de middleware proporcionan seguridad, conformidad y observabilidad. LangGraph añade ejecución persistente, flujo de control y gestión de estados. Y en la capa de memoria, Milvus llena un vacío crítico: proporciona una memoria a largo plazo escalable y fiable que permite a los agentes recuperar el contexto, razonar sobre el historial y mejorar con el tiempo.

Juntos, LangChain, LangGraph y Milvus forman una práctica cadena de herramientas para la era moderna de los agentes, que une la creación rápida de prototipos con el despliegue a escala empresarial, sin sacrificar la fiabilidad ni el rendimiento.

🚀 ¿Listo para dotar a su agente de una memoria fiable a largo plazo? Explore Milvus y vea cómo potencia la memoria inteligente a largo plazo para los agentes LangChain en producción.

Tienes preguntas o quieres una inmersión profunda en cualquier característica? Únase a nuestro canal Discord o presente incidencias en 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.