LangChain vs. LangGraph: os funcionários dizem o que você deve escolher

Atualmente, o campo da IA generativa está evoluindo rapidamente, com o surgimento de novas estruturas e tecnologias. Portanto, os leitores devem estar cientes de que o conteúdo apresentado neste artigo pode ser atual. Neste artigo, examinaremos mais de perto as duas estruturas dominantes para a criação de aplicativos LLM, LangChain e LangGraph, e analisaremos seus pontos fortes e fracos para ajudá-lo a escolher a ferramenta mais adequada.

Componentes de base LangChain e LangGraph

A compreensão dos elementos fundamentais de ambas as estruturas pode ajudar os desenvolvedores a entender melhor as principais diferenças na forma como lidam com a funcionalidade principal. As descrições a seguir não listam todos os componentes de cada estrutura, mas têm o objetivo de fornecer uma compreensão clara de seu design geral.

LangChain

O LangChain pode ser usado de duas maneiras principais: como uma cadeia sequencial de comandos predefinidos (Chain) e como um LangChain Agent, que difere em termos de ferramentas e organização. O Chain usa um fluxo de trabalho linear predefinido, enquanto o Agent atua como coordenador e pode tomar decisões mais dinâmicas (não lineares).

• CadeiaCadeia de processos: uma combinação de etapas que podem incluir chamadas para LLMs, agentes, ferramentas, fontes de dados externas e código de procedimento. As cadeias podem dividir um único processo em vários caminhos com base na ramificação condicional lógica.
• Agente ou LLMO agente combina o LLM com recursos adicionais que lhe permitem raciocinar, invocar a ferramenta e tentar invocá-la se ela falhar.
• FerramentaFunções de código: são funções de código que podem ser chamadas em uma cadeia ou acionadas por um Agente para interagir com um sistema externo.
• PromptInclui avisos do sistema (para indicar como o modelo deve concluir a tarefa e as ferramentas disponíveis), informações injetadas de fontes de dados externas (para fornecer mais contexto para o modelo) e tarefas de entrada do usuário.

LangGraph

LangGraph adota uma abordagem diferente para criar fluxos de trabalho de IA. Como o nome sugere, ele orquestra fluxos de trabalho como um gráfico. Devido à sua capacidade de flexibilizar entre agentes de IA, código procedural e outras ferramentas, ele é mais adequado para cenários de aplicativos complexos em que cadeias lineares, cadeias de ramificação ou sistemas de agentes simples não são suficientes. O LangGraph foi projetado para lidar com lógica condicional e loops de feedback mais complexos e é mais avançado que o LangChain.

• GráficoO LangGraph também oferece suporte a gráficos cíclicos, que criam loops e mecanismos de feedback que permitem que determinados nós sejam acessados várias vezes.
• NóIndicação: Indica uma etapa em um fluxo de trabalho, como uma consulta LLM, chamada de API ou execução de ferramenta.
• Borda e borda condicionalBordas: As bordas são usadas para conectar nós e definir o fluxo de informações, de modo que a saída de um nó seja usada como entrada para o próximo. As bordas condicionais permitem que as informações fluam de um nó para outro quando condições específicas são atendidas. O desenvolvedor pode personalizar essas condições.
• EstadoO estado é um objeto TypedDict variável definido pelo desenvolvedor que contém todas as informações relevantes necessárias para a execução atual do gráfico. O estado é um objeto TypedDict variável definido pelo desenvolvedor que contém todas as informações relevantes necessárias para a execução atual do gráfico.
• Agente ou LLMO LLM no gráfico é responsável apenas pela geração de respostas textuais às entradas. O recurso Agente, por outro lado, permite que o gráfico contenha vários nós que representam diferentes componentes do Agente (por exemplo, raciocínio, seleção de ferramentas e execução de ferramentas). O Agente pode decidir quais caminhos tomar no gráfico, atualizar o estado do gráfico e executar mais tarefas do que apenas a geração de texto.

Em resumo, o LangChain é mais adequado para invocações lineares e baseadas em ferramentas, enquanto o LangGraph é mais adequado para fluxos de trabalho complexos, de vários caminhos e de IA com mecanismos de feedback.

Diferenças entre LangChain e LangGraph na forma como a funcionalidade principal é tratada

O LangGraph e o LangChain se sobrepõem em alguns de seus recursos, mas abordam o problema de forma diferente; o LangChain se concentra em fluxos de trabalho lineares (por meio de cadeias) ou em diferentes padrões de AI Agent, enquanto o LangGraph se concentra na criação de fluxos de trabalho mais flexíveis, refinados e baseados em processos, que podem incorporar AI Agents, chamadas de ferramentas, código procedural, etc.

Em geral, o LangChain tem uma curva de aprendizado relativamente baixa porque oferece mais encapsulamento de abstração e configurações predefinidas, o que torna o LangChain mais fácil de aplicar a cenários de uso simples. O LangGraph, por outro lado, permite uma personalização mais refinada do design do fluxo de trabalho, o que significa que é menos abstrato e que os desenvolvedores precisam aprender mais para usá-lo com eficiência.

Chamada de ferramenta

LangChain

No LangChain, a maneira como uma ferramenta é chamada depende do fato de uma série de etapas ser executada sequencialmente na cadeia ou de apenas os recursos do agente serem usados (não definidos explicitamente na cadeia).

• As ferramentas são incluídas como etapas predefinidas na cadeia, o que significa que elas não são necessariamente invocadas dinamicamente pelo agente, mas sim que é decidido quais ferramentas serão invocadas no momento em que a cadeia for projetada.
• Quando o agente não está definido em uma cadeia, ele tem mais autonomia e pode decidir qual ferramenta chamar e quando, com base na lista de ferramentas a que tem acesso.

Exemplo de um processo para a abordagem em cadeia:

Este é um exemplo do fluxo do método Agent:

LangGraph

No LangGraph, uma ferramenta é geralmente representada como um nó no gráfico. Se o gráfico contiver um agente, o agente será responsável por decidir qual ferramenta invocar, com base em sua capacidade de raciocínio. Quando o agente seleciona uma ferramenta, o fluxo de trabalho salta para o nó de ferramenta correspondente para executar a operação da ferramenta. A borda entre o agente e o nó de ferramenta pode conter lógica condicional, que acrescenta lógica de julgamento adicional para decidir se uma ferramenta deve ser executada ou não. Dessa forma, o desenvolvedor pode ter um controle mais refinado. Se não houver nenhum agente no gráfico, a ferramenta será invocada de forma semelhante a uma cadeia LangChain, ou seja, a ferramenta é executada no fluxo de trabalho com base na lógica condicional predefinida.

Contém um exemplo do fluxo de diagramas para o Agente:

Exemplo de um fluxo de um diagrama sem um agente:

Diálogo sobre história e memória

LangChain

O LangChain oferece uma camada de abstração integrada para lidar com o histórico de conversas e memórias. Ele oferece suporte ao gerenciamento de memória em diferentes níveis de granularidade, controlando assim a quantidade de token quantidade, principalmente das seguintes maneiras:

• Full session conversation history (Histórico completo de conversas da sessão)
• Versão resumida do histórico da conversa
• Memória definida personalizada (CDM)

Além disso, os desenvolvedores podem personalizar o sistema de memória de longo prazo para armazenar o histórico de diálogos em um banco de dados externo e recuperar memórias relevantes quando necessário.

LangGraph

No LangGraph, o State é responsável pelo gerenciamento da memória, que mantém o controle das informações de estado registrando as variáveis definidas em cada momento:

• Diálogo com a história
• Etapas da implementação do mandato
• A última saída do modelo de linguagem
• Outras informações importantes

O estado pode ser transmitido entre os nós para que cada nó tenha acesso ao estado atual do sistema. Se os desenvolvedores precisarem armazenar a memória de forma persistente, poderão introduzir nós específicos para armazenar memórias e variáveis em um banco de dados externo para recuperação posterior.

Capacidade de RAG pronta para uso

LangChain

O LangChain oferece suporte nativo a RAG e fornece um conjunto sofisticado de ferramentas para facilitar a integração do RAG aos aplicativos dos desenvolvedores. Por exemplo, ele fornece:

• Carregamento de documentos
• Análise de texto
• Criação de incorporação
• Armazenamento vetorial
• Recursos de recuperação (Recursos de recuperação)

Os desenvolvedores podem usar diretamente as APIs fornecidas pela LangChain (como a langchain.document_loaderselangchain.embeddings responder cantando langchain.vectorstores) para implementar fluxos de trabalho RAG.

LangGraph

No LangGraph, os RAGs precisam ser projetados pelo desenvolvedor e implementados como parte da estrutura do gráfico. Por exemplo, os desenvolvedores podem criar nós separados para cada um deles:

• Análise de documentos
• Embedding Computation (Computação de Incorporação)
• Pesquisa semântica (recuperação)

Esses nós podem ser conectados uns aos outros por meio de bordas normais ou condicionais, e o estado de nós individuais pode ser usado para passar informações a fim de compartilhar dados entre diferentes etapas do pipeline RAG.

Paralelismo

LangChain

O LangChain permite a execução paralela de várias cadeias ou agentes, que podem ser executados usando a função RunnableParallel para implementar o processamento paralelo básico.

No entanto, se for necessária uma computação paralela mais avançada ou chamadas de ferramentas assíncronas, os desenvolvedores precisarão usar bibliotecas Python, como asyncio) Autoimplementação.

LangGraph

O LangGraph suporta naturalmente a execução paralela de nós, desde que não haja dependências entre esses nós (por exemplo, a saída de um LLM não pode ser usada como entrada para o próximo). Isso significa que vários agentes podem ser executados simultaneamente, desde que não sejam nós interdependentes.

Também suportado pelo LangGraph:

• fazer uso de RunnableParallel Execução de vários gráficos
• Com a função asyncio Ferramenta de chamada paralela da biblioteca

Lógica de repetição e tratamento de erros

LangChain

O tratamento de erros do LangChain precisa ser explicitamente definido pelo desenvolvedor, o que pode ser feito por meio de:

• Apresentando a lógica de repetição na cadeia (Retry Logic)
• Tratamento de falhas de chamadas de ferramentas no agente

LangGraph

O LangGraph pode incorporar a lógica de tratamento de erros diretamente no fluxo de trabalho, tornando o tratamento de erros um nó separado.

• Quando uma tarefa falha, você pode pular para outro nó de tratamento de erros ou tentar novamente no nó atual.
• Os nós com falha são repetidos individualmente, em vez de todo o fluxo de trabalho ser reexecutado.
• Dessa forma, o diagrama pode continuar a execução a partir do ponto em que falhou, sem ter que começar do zero.

Se sua tarefa envolver várias etapas e chamadas de ferramentas, esse mecanismo de tratamento de erros pode ser muito importante.

Como escolher entre LangChain e LangGraph?

Os desenvolvedores podem:

• Usar somente LangChain
• Use somente o LangGraph
• Uso conjunto de LangChain e LangGraph

Também é possível combinar os recursos de estruturação de gráficos do LangGraph com outras estruturas de agente, como o AutoGen da Microsoft, por exemplo, combinando o AutoGen Agente como um nó do LangGraph.

O LangChain e o LangGraph têm suas vantagens, e escolher a ferramenta certa pode ser confuso.

Quando escolher a LangChain?

Se os desenvolvedores precisarem criar fluxos de trabalho de IA rapidamente, aqui estão alguns cenários para considerar a escolha do LangChain:

• tarefa linearFluxos de trabalho predefinidos para recuperação de documentos, geração de texto, resumo, etc.
• O AI Agent requer uma tomada de decisão dinâmicamas não exige controle refinado de processos complexos.

Quando escolher o LangGraph?

Se o cenário do aplicativo exigir um fluxo de trabalho não linear (não linear), considere o LangGraph para as seguintes situações:

• A tarefa envolve a interação dinâmica de vários componentes.
• Requer julgamento condicional, lógica de ramificação complexa, tratamento de erros ou execução paralela.
• Os desenvolvedores estão dispostos a implementar alguns dos recursos não fornecidos pela LangChain por conta própria.

Quando devo usar o LangChain e o LangGraph juntos?

Se alguém quiser aproveitar os recursos de abstração prontamente disponíveis do LangChain (por exemplo, componentes RAG, memórias de diálogo etc.) e os recursos de orquestração não linear do LangGraph, pode considerar o uso de ambos.

Combinados, os dois podem tirar o máximo proveito de seus respectivos pontos fortes para criar fluxos de trabalho de IA mais flexíveis e avançados.