LangChain 1.0 e Milvus: Como construir agentes prontos para produção com memória de longo prazo real

A LangChain é uma estrutura popular de código aberto para o desenvolvimento de aplicações baseadas em grandes modelos de linguagem (LLM). Fornece um conjunto de ferramentas modulares para a construção de agentes de raciocínio e de utilização de ferramentas, ligando modelos a dados externos e gerindo fluxos de interação.

Com o lançamento do LangChain 1.0, a estrutura dá um passo em direção a uma arquitetura mais favorável à produção. A nova versão substitui a anterior conceção baseada em cadeias por um ciclo ReAct normalizado (Raciocínio → Chamada de ferramenta → Observar → Decidir) e introduz Middleware para gerir a execução, o controlo e a segurança.

No entanto, o raciocínio por si só não é suficiente. Os agentes também precisam da capacidade de armazenar, recuperar e reutilizar informações. É aí que o Milvus, uma base de dados vetorial de código aberto, pode desempenhar um papel essencial. O Milvus fornece uma camada de memória escalável e de alto desempenho que permite aos agentes armazenar, pesquisar e recuperar informações de forma eficiente através da semelhança semântica.

Neste post, vamos explorar como o LangChain 1.0 actualiza a arquitetura dos agentes e como a integração do Milvus ajuda os agentes a ir além do raciocínio - permitindo uma memória persistente e inteligente para casos de utilização no mundo real.

Porque é que o design baseado em cadeias é insuficiente

Nos seus primórdios (versão 0.x), a arquitetura da LangChain centrava-se em cadeias. Cada Chain definia uma sequência fixa e vinha com modelos pré-construídos que tornavam a orquestração do LLM simples e rápida. Este design era ótimo para construir protótipos rapidamente. Mas à medida que o ecossistema LLM evoluiu e os casos de uso do mundo real se tornaram mais complexos, as rachaduras nessa arquitetura começaram a aparecer.

1. Falta de flexibilidade

As primeiras versões do LangChain forneciam pipelines modulares como o SimpleSequentialChain ou o LLMChain, cada um seguindo um fluxo fixo e linear - criação do prompt → chamada de modelo → processamento de saída. Esta conceção funcionou bem para tarefas simples e previsíveis e facilitou a criação rápida de protótipos.

No entanto, à medida que as aplicações se tornaram mais dinâmicas, estes modelos rígidos começaram a parecer restritivos. Quando a lógica de negócio já não se encaixa perfeitamente numa sequência predefinida, restam-lhe duas opções insatisfatórias: forçar a sua lógica a estar em conformidade com a estrutura ou contorná-la completamente, chamando diretamente a API do LLM.

2. Falta de controlo de nível de produção

O que funcionava bem em demos muitas vezes quebrava em produção. As cadeias não incluíam as salvaguardas necessárias para aplicações de grande escala, persistentes ou sensíveis. Problemas comuns incluem:

• Estouro de contexto: Conversas longas podiam exceder os limites de token, causando falhas ou truncamento silencioso.

• Fugas de dados sensíveis: Informações de identificação pessoal (como e-mails ou IDs) podem ser enviadas inadvertidamente para modelos de terceiros.

• Operações não supervisionadas: Os agentes podem apagar dados ou enviar correio eletrónico sem aprovação humana.

3. Falta de compatibilidade entre modelos

Cada provedor de LLM - OpenAI, Anthropic e muitos modelos chineses - implementa seus próprios protocolos para raciocínio e chamada de ferramentas. Sempre que se trocava de fornecedor, era necessário reescrever a camada de integração: modelos de pedidos, adaptadores e analisadores de resposta. Este trabalho repetitivo atrasou o desenvolvimento e tornou a experimentação dolorosa.

LangChain 1.0: Agente ReAct completo

Quando a equipa da LangChain analisou centenas de implementações de agentes em produção, uma ideia sobressaiu: quase todos os agentes bem sucedidos convergiram naturalmente para o padrão ReAct ("Reasoning + Acting").

Quer se trate de um sistema multi-agente ou de um único agente que executa um raciocínio profundo, surge o mesmo ciclo de controlo: alternar entre breves passos de raciocínio com chamadas de ferramentas específicas e, em seguida, alimentar as observações resultantes em decisões subsequentes até que o agente possa dar uma resposta final.

Para se basear nesta estrutura comprovada, a LangChain 1.0 coloca o ciclo ReAct no centro da sua arquitetura, tornando-o na estrutura predefinida para a construção de agentes fiáveis, interpretáveis e prontos a produzir.

Para suportar tudo, desde agentes simples a orquestrações complexas, o LangChain 1.0 adopta um design em camadas que combina a facilidade de utilização com um controlo preciso:

• Cenários padrão: Comece com a função create_agent() - um loop ReAct limpo e padronizado que lida com raciocínio e chamadas de ferramentas prontas para uso.

• Cenários alargados: Adicione Middleware para obter um controlo refinado. O middleware permite inspecionar ou modificar o que acontece dentro do agente - por exemplo, adicionar deteção de PII, pontos de verificação de aprovação humana, novas tentativas automáticas ou ganchos de monitoramento.

• Cenários complexos: Para fluxos de trabalho com estado ou orquestração de vários agentes, utilize o LangGraph, um motor de execução baseado em gráficos que proporciona um controlo preciso do fluxo lógico, das dependências e dos estados de execução.

Agora vamos detalhar os três componentes principais que tornam o desenvolvimento de agentes mais simples, mais seguro e mais consistente em todos os modelos.

1. O create_agent(): Uma maneira mais simples de criar agentes

Um avanço importante no LangChain 1.0 é como ele reduz a complexidade da construção de agentes a uma única função - create_agent(). Não é mais necessário lidar manualmente com gerenciamento de estado, tratamento de erros ou saídas de streaming. Esses recursos de nível de produção agora são gerenciados automaticamente pelo tempo de execução do LangGraph.

Com apenas três parâmetros, você pode lançar um agente totalmente funcional:

• modelo - um identificador de modelo (string) ou um objeto de modelo instanciado.

• tools - uma lista de funções que dão ao agente as suas capacidades.

• system_prompt - a instrução que define a função, o tom e o comportamento do agente.

Por baixo do capô, create_agent() é executado no ciclo padrão do agente - chamando um modelo, deixando-o escolher ferramentas para executar, e completando quando não forem necessárias mais ferramentas:

Também herda as capacidades incorporadas do LangGraph para persistência de estado, recuperação de interrupções e streaming. As tarefas que antes exigiam centenas de linhas de código de orquestração são agora tratadas através de uma ú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. O Middleware: Uma camada compósita para controlo pronto a produzir

O middleware é a ponte fundamental que leva a LangChain do protótipo à produção. Expõe ganchos em pontos estratégicos do ciclo de execução do agente, permitindo-lhe adicionar lógica personalizada sem reescrever o processo ReAct principal.

O ciclo principal de um agente segue um processo de decisão em três etapas - Modelo → Ferramenta → Terminação:

O LangChain 1.0 fornece alguns middlewares pré-construídos para padrões comuns. Eis quatro exemplos.

• Deteção de PII: Qualquer aplicação que lide com dados sensíveis do utilizador

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

• Sumarização: Resume automaticamente o histórico de conversas quando se aproxima do limite 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
),
],
)

• Repetição de ferramenta: Tentativa automática de chamadas de ferramentas com falha com backoff exponencial configurável.

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

Além das opções oficiais e pré-construídas de middleware, também é possível criar middleware personalizado usando o modo baseado em decorador ou classe.

Por exemplo, o snippet abaixo mostra como registrar chamadas de modelo antes da execução:

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. Saída estruturada: Uma forma padronizada de lidar com dados

No desenvolvimento tradicional de agentes, a saída estruturada sempre foi difícil de gerenciar. Cada provedor de modelo lida com isso de forma diferente - por exemplo, o OpenAI oferece uma API de saída estruturada nativa, enquanto outros apenas suportam respostas estruturadas indiretamente por meio de chamadas de ferramentas. Isso geralmente significava escrever adaptadores personalizados para cada provedor, adicionando trabalho extra e tornando a manutenção mais dolorosa do que deveria ser.

No LangChain 1.0, a saída estruturada é tratada diretamente através do parâmetro response_format em create_agent(). Só precisa de definir o seu esquema de dados uma vez. O LangChain escolhe automaticamente a melhor estratégia de aplicação com base no modelo que você está usando - não é necessária nenhuma configuração extra ou código específico do fornecedor.

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}")

O LangChain suporta duas estratégias para saída estruturada:

1. Estratégia do provedor: Alguns provedores de modelos suportam nativamente a saída estruturada por meio de suas APIs (por exemplo, OpenAI e Grok). Quando esse suporte está disponível, a LangChain usa diretamente a imposição de esquema embutida do provedor. Esta abordagem oferece o mais alto nível de fiabilidade e consistência, uma vez que o próprio modelo garante o formato de saída.

2. Estratégia de chamada da ferramenta: Para modelos que não suportam saída estruturada nativa, o LangChain usa chamadas de ferramentas para obter o mesmo resultado.

Não precisa de se preocupar com a estratégia que está a ser utilizada - a estrutura detecta as capacidades do modelo e adapta-se automaticamente. Essa abstração permite alternar livremente entre diferentes provedores de modelos sem alterar sua lógica de negócios.

Como o Milvus melhora a memória do agente

Para agentes de nível de produção, o verdadeiro gargalo de desempenho muitas vezes não é o mecanismo de raciocínio - é o sistema de memória. No LangChain 1.0, as bases de dados vectoriais actuam como a memória externa de um agente, proporcionando uma recordação a longo prazo através da recuperação semântica.

A Milvus é uma das bases de dados vectoriais de código aberto mais maduras atualmente disponíveis, criada especificamente para pesquisa vetorial em larga escala em aplicações de IA. Integra-se nativamente com o LangChain, para que não tenha de lidar manualmente com a vectorização, a gestão de índices ou a pesquisa de semelhanças. O pacote langchain_milvus envolve o Milvus como uma interface VectorStore padrão, permitindo conectá-lo aos seus agentes com apenas algumas linhas de código.

Ao fazer isso, o Milvus aborda três desafios-chave na construção de sistemas de memória de agentes escaláveis e confiáveis:

1. Recuperação rápida de bases de conhecimento massivas

Quando um agente precisa de processar milhares de documentos, conversas passadas ou manuais de produtos, a simples pesquisa por palavras-chave não é suficiente. O Milvus utiliza a pesquisa por semelhança de vectores para encontrar informações semanticamente relevantes em milissegundos - mesmo que a consulta utilize uma redação diferente. Isto permite que o seu agente recupere conhecimentos com base no significado e não apenas em correspondências de texto exactas.

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. Memória de longo prazo persistente

O SummarizationMiddleware da LangChain pode condensar o histórico de conversas quando este se torna demasiado longo, mas o que acontece a todos os detalhes que são resumidos? O Milvus guarda-os. Cada conversa, chamada de ferramenta e passo de raciocínio pode ser vectorizado e armazenado para referência a longo prazo. Quando necessário, o agente pode recuperar rapidamente memórias relevantes através da pesquisa semântica, permitindo uma verdadeira continuidade entre sessões.

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. Gestão unificada de conteúdo multimodal

Os agentes modernos lidam com mais do que texto - eles interagem com imagens, áudio e vídeo. O Milvus suporta o armazenamento multi-vetorial e o esquema dinâmico, o que lhe permite gerir os embeddings de várias modalidades num único sistema. Isto proporciona uma base de memória unificada para agentes multimodais, permitindo a recuperação consistente de diferentes tipos de dados.

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

LangChain vs. LangGraph: Como escolher o que melhor se adapta aos seus agentes

A atualização para o LangChain 1.0 é uma etapa essencial para a criação de agentes de nível de produção, mas isso não significa que seja sempre a única ou a melhor opção para todos os casos de uso. A escolha do framework correto determina a rapidez com que você pode combinar esses recursos em um sistema funcional e de fácil manutenção.

Na verdade, o LangChain 1.0 e o LangGraph 1.0 podem ser vistos como parte da mesma pilha em camadas, projetados para trabalhar juntos em vez de substituir um ao outro: O LangChain ajuda-o a construir agentes padrão rapidamente, enquanto o LangGraph lhe dá um controlo refinado para fluxos de trabalho complexos. Por outras palavras, o LangChain ajuda-o a avançar rapidamente, enquanto o LangGraph o ajuda a aprofundar.

Abaixo está uma rápida comparação de como eles diferem em termos de posicionamento técnico:

Dimensão	LangChain 1.0	LangChain 1.0
Nível de abstração	Abstração de alto nível, concebida para cenários de agentes padrão	Estrutura de orquestração de baixo nível, concebida para fluxos de trabalho complexos
Capacidade principal	Ciclo ReAct padrão (Motivo → Chamada de ferramenta → Observação → Resposta)	Máquinas de estado personalizadas e lógica de ramificação complexa (StateGraph + Conditional Routing)
Mecanismo de extensão	Middleware para capacidades de nível de produção	Gestão manual de nós, arestas e transições de estado
Implementação subjacente	Gestão manual de nós, arestas e transições de estado	Tempo de execução nativo com persistência e recuperação incorporadas
Casos de uso típicos	80% dos cenários de agentes padrão	Colaboração entre vários agentes e orquestração de fluxos de trabalho de longa duração
Curva de aprendizado	Construir um agente em cerca de 10 linhas de código	Requer conhecimento de gráficos de estado e orquestração de nós

Se você é novo na construção de agentes ou deseja colocar um projeto em funcionamento rapidamente, comece com o LangChain. Se já sabe que o seu caso de utilização requer orquestração complexa, colaboração multi-agente ou fluxos de trabalho de longa duração, vá diretamente para o LangGraph.

Ambas as estruturas podem coexistir no mesmo projeto - pode começar de forma simples com o LangChain e utilizar o LangGraph quando o seu sistema precisar de mais controlo e flexibilidade. A chave é escolher a ferramenta certa para cada parte do seu fluxo de trabalho.

Conclusão

Há três anos, a LangChain começou como um wrapper leve para chamar LLMs. Atualmente, transformou-se numa estrutura completa, de nível de produção.

No núcleo, as camadas de middleware fornecem segurança, conformidade e observabilidade. O LangGraph acrescenta execução persistente, fluxo de controlo e gestão de estado. E na camada de memória, o Milvus preenche uma lacuna crítica - fornecendo memória de longo prazo escalável e confiável que permite aos agentes recuperar o contexto, raciocinar sobre o histórico e melhorar com o tempo.

Juntos, LangChain, LangGraph e Milvus formam uma cadeia de ferramentas prática para a era moderna dos agentes - unindo prototipagem rápida com implantação em escala empresarial, sem sacrificar a confiabilidade ou o desempenho.

Pronto para dar ao seu agente uma memória fiável e de longo prazo? Explore o Milvus e veja como ele fornece memória inteligente e de longo prazo para agentes LangChain em produção.

Tem dúvidas 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.