LangChain RAG ou LlamaIndex: qual escolher para seu projeto

LangChain RAG ou LlamaIndex: qual escolher?

Escolha LlamaIndex para uma aplicação centrada em documentos. Escolha LangChain para um agente que coordena tarefas entre ferramentas. Ambos permitem implementar geração aumentada por recuperação, ou RAG: buscar material de referência relevante antes de pedir uma resposta ao modelo.

Para quem está criando um assistente de suporte baseado em manuais de produto, LlamaIndex é o melhor ponto de partida. Suas abstrações de documentos, índices e mecanismos de consulta colocam o percurso da ingestão à resposta no centro do código. Comece por ele quando a próxima dúvida de engenharia envolver trechos que não aparecem na busca, a estrutura dos documentos ou as evidências que chegam ao modelo.

Para quem desenvolve um assistente que consulta uma política, verifica um pedido e solicita aprovação antes de emitir um reembolso, LangChain é o melhor ponto de partida. Sua API atual de agentes coloca as ferramentas e o ciclo de execução do modelo no centro, com LangGraph como framework de execução subjacente. Comece por ele quando a próxima dúvida envolver estado, aprovação ou qual ação deve acontecer em seguida.

Se a aplicação atual já atende aos requisitos de recuperação e de fluxo de trabalho, mantenha o que funciona. Trocar o nome do framework não corrige uma tabela mal interpretada nem uma operação de pagamento insegura. Adicione o componente que falta só depois de identificar a falha que ele precisa resolver.

Os critérios desta comparação são o tratamento de documentos, o controle da execução dos agentes, as interfaces entre componentes e os custos recorrentes. As avaliações se baseiam na documentação, não em medições comparativas de velocidade ou precisão.

Fontes: documentação do LlamaIndex, documentação do LangChain, pacote LlamaIndex, pacote LangChain e páginas de preços do LlamaParse e preços do LangSmith dos respectivos fornecedores. Os serviços hospedados na linha de preços têm funções diferentes; as assinaturas não são equivalentes.

Para que serve cada framework hoje?

LlamaIndex vai além de um índice, e LangChain vai além de uma coleção de chains. A documentação atual de ambos coloca agentes no centro dos respectivos ecossistemas. A diferença está na estrutura inicial que cada um oferece para o seu problema.

LlamaIndex: pipelines de dados e agentes de documentos

LlamaIndex é um framework de código aberto para agentes que usam seus dados. Seus componentes cobrem o carregamento de documentos, a criação de representações pesquisáveis, a recuperação de evidências e a geração de respostas. Os Workflows também permitem criar processos orientados a eventos, com ramificações, novas tentativas e revisão humana. A visão geral do framework descreve explicitamente esse escopo mais amplo.

Em um assistente de contratos, a unidade de trabalho mais útil costuma ser o trecho do documento: de onde veio, a qual versão pertence e se a seção ao redor altera seu significado. O Node do LlamaIndex, um fragmento do conteúdo de origem com metadados e relações, oferece uma estrutura para gerenciar essa evidência. O mecanismo de consulta combina a recuperação com a geração da resposta. Veja o guia do VectorStoreIndex.

O limite está na qualidade do material de entrada. Um carregador que transforma uma tabela em texto corrido pode separar um preço do cabeçalho da coluna; a indexação preservará esse erro fielmente. A própria documentação do LlamaIndex diferencia os leitores integrados para texto bem estruturado do serviço comercial LlamaParse, voltado a documentos mais difíceis. Escolha o framework pelas abstrações de dados e avalie a interpretação dos documentos separadamente.

A manutenção também merece atenção: a descrição atual do pacote informa que o foco principal passou a ser LlamaParse e as ferramentas relacionadas a documentos, enquanto o framework continua disponível como um conjunto de ferramentas aberto. Antes de adotar uma dependência de longo prazo, verifique a manutenção das integrações específicas de que você precisa.

LangChain: agentes com LangGraph na base

LangChain é um framework de código aberto cuja API atual create_agent fornece uma estrutura configurável para executar agentes: ferramentas, instruções e a lógica de execução que permite ao modelo realizar tarefas. Os middlewares permitem personalizar o comportamento ao redor desse ciclo. A visão geral apresenta LangGraph como a base de execução desses agentes.

Em um agente de suporte a pedidos, a recuperação pode ser apenas uma ferramenta entre várias. A aplicação também pode consultar o status da entrega e preparar uma proposta de reembolso. LangChain é o ponto de partida natural quando essas interações entre ferramentas definem o produto.

O limite é que uma abstração de agente não decide as regras que o negócio precisa garantir. Você ainda define quem pode receber um reembolso, qual aprovação é necessária e como impedir que uma execução repetida emita o mesmo reembolso duas vezes. O framework fornece os mecanismos de execução; as regras ficam por conta da aplicação.

LangChain vs LangGraph: quando usar cada um?

Use a abstração de agentes do LangChain quando o trabalho combinar com um modelo que escolhe ferramentas. Use LangGraph diretamente quando precisar definir com mais precisão o estado e as transições do fluxo. LangGraph já faz parte dos agentes atuais do LangChain, então adicionar memória ou revisão humana não exige automaticamente uma reescrita. A comparação entre LangChain e LangGraph aprofunda essa decisão.

Versões atuais dos pacotes Python e licenças

Verificado em 13 de outubro de 2026: as versões publicadas dos pacotes Python eram llama-index 0.14.25, llama-index-core 0.14.25, langchain 1.4.5 e langgraph 1.2.15. Essas versões são um retrato de cada pacote, não uma versão única compartilhada por todas as integrações de um ecossistema.

Os repositórios dos dois frameworks adotam a licença MIT: licença do LlamaIndex e licença do LangChain. Os produtos hospedados têm termos comerciais próprios. A licença gratuita do framework não inclui inferência do modelo, banco vetorial hospedado nem o servidor da aplicação.

O mesmo exemplo simples de RAG nos dois frameworks

Os dois exemplos carregam arquivos de texto locais, criam um índice em memória e respondem à mesma pergunta usando o material recuperado. Eles mostram como as APIs se organizam. Neste comparativo, os exemplos foram conferidos com a documentação, mas não executados com uma API paga de modelos.

Crie um diretório data com seus próprios arquivos de políticas em .txt, codificados em UTF-8. Configure OPENAI_API_KEY e defina RAG_MODEL com o mesmo modelo de chat da OpenAI disponível na sua conta para os dois scripts. Ambos selecionam explicitamente text-embedding-3-small para os embeddings, as representações numéricas usadas para buscar conteúdos semelhantes. O tutorial inicial do LlamaIndex recomenda explicitar essa escolha de embeddings.

Exemplo com LlamaIndex

Instale llama-index-core, llama-index-readers-file, llama-index-llms-openai e llama-index-embeddings-openai. Como alternativa, o pacote inicial llama-index inclui esses componentes; veja o guia de instalação.

import os
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI

docs = SimpleDirectoryReader("data", required_exts=[".txt"]).load_data()
embed = OpenAIEmbedding(model="text-embedding-3-small")
index = VectorStoreIndex.from_documents(docs, embed_model=embed)
llm = OpenAI(model=os.environ["RAG_MODEL"])
engine = index.as_query_engine(llm=llm, similarity_top_k=3)
print(engine.query("What is the refund window?"))

Aqui, from_documents cuida da transformação de documentos em nós e da indexação. O mecanismo de consulta cuida da recuperação e da síntese da resposta. Essa é a vantagem para um pequeno assistente de conhecimento: o código expressa diretamente o trabalho com documentos, e os componentes de nível mais baixo continuam disponíveis quando você precisa mudar o comportamento.

Exemplo com LangChain

Instale langchain-core, langchain-openai e langchain-text-splitters. Esse fluxo fixo de recuperação usa os pacotes de componentes do LangChain; o pacote principal de agentes, langchain, só é necessário quando você adiciona um agente. As APIs estão documentadas no guia de RAG, na referência do armazenamento em memória e na integração com OpenAI.

import os
from pathlib import Path
from langchain_core.documents import Document
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
files = Path("data").glob("*.txt")
docs = [Document(page_content=p.read_text(encoding="utf-8"), metadata={"source": str(p)}) for p in files]
chunks = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100).split_documents(docs)
index = InMemoryVectorStore.from_documents(chunks, OpenAIEmbeddings(model="text-embedding-3-small"))
question = "What is the refund window?"
context = "\n\n".join(d.page_content for d in index.similarity_search(question, k=3))
llm = ChatOpenAI(model=os.environ["RAG_MODEL"])
print(llm.invoke(f"Answer only from this context; if absent, say unknown.\n{context}\nQuestion: {question}").content)

Esta versão deixa cada etapa explícita: carregar o texto, dividi-lo, gerar e armazenar os embeddings, recuperar trechos e chamar o modelo de chat. Essa montagem adicional passa a ser útil quando a recuperação é só uma parte de uma aplicação maior.

Recuperação e controle de agentes: quem leva vantagem em cada tarefa?

LlamaIndex oferece a melhor abstração inicial para recuperar documentos. LangChain oferece a melhor abstração inicial para um agente que coordena ações. São avaliações de adequação ao projeto, não afirmações de que um framework seja incapaz de fazer o trabalho do outro.

Ingestão e recuperação de documentos: vantagem para LlamaIndex

Escolha LlamaIndex quando a maior parte das mudanças acontecer entre o documento bruto e as evidências devolvidas ao modelo. Sua estrutura de indexação e consulta mantém esse trabalho concentrado. Um assistente de compras que responde a perguntas sobre aditivos contratuais, por exemplo, precisa preservar as relações entre as fontes antes de precisar de mais um ciclo de chamadas de ferramentas.

LangChain permite construir o mesmo fluxo de recuperação. Sua documentação de RAG separa a indexação da recuperação e da geração, e o exemplo acima mostra o caso simples. Se você já tem um bom serviço de busca, chamá-lo pelo LangChain pode dar menos trabalho do que introduzir outro framework.

A escolha muda quando a recuperação deixa de ser o subsistema mais difícil. Com uma base de conhecimento bem estruturada e várias ferramentas de negócio, faz mais sentido investir no fluxo de execução do agente.

Agentes que usam ferramentas e controle de fluxos: vantagem para LangChain

Escolha LangChain quando a aplicação alternar entre evidências e ações: consultar uma política, buscar o cadastro de um cliente, pedir informações que faltam e preparar uma ação para aprovação. Seu ciclo configurável de agentes e a base em LangGraph se encaixam nessa estrutura.

LlamaIndex também oferece agentes. O guia de agentes documenta agentes que usam ferramentas, e o tutorial inicial adiciona a recuperação como ferramenta que o agente pode chamar. Um assistente de documentos que pesquisa, calcula e devolve uma resposta pode ficar inteiramente no LlamaIndex.

Se o fluxo centrado em documentos já foi construído ali, não é necessário migrar só porque o produto agora tem um “agente”. Mude apenas quando o novo controle de fluxo de que você precisa justificar a troca da camada de execução.

LlamaIndex vs LangGraph: como dividir as responsabilidades?

LlamaIndex e LangGraph costumam atuar em camadas diferentes. LlamaIndex pode preparar e recuperar evidências; LangGraph pode controlar como um fluxo com estado avança depois de recebê-las. Os próprios Workflows do LlamaIndex são outra opção para essa camada de execução. Usar ambos, portanto, é uma escolha de arquitetura, não uma forma de contornar a ausência de um recurso.

O critério é a responsabilidade: um componente deve cuidar da recuperação de documentos, e outro, do estado de execução da aplicação. Se ambos decidirem de forma independente sobre novas tentativas e o estado da conversa, diagnosticar uma ação repetida fica mais difícil.

Qualidade da recuperação: avalie a falha, não a marca

Nenhum framework vence em precisão só pela lista de recursos. Use a mesma coleção de fontes e as mesmas perguntas; antes de julgar a redação da resposta, confira se o sistema recuperou as evidências corretas.

Para um assistente de políticas, inclua uma pergunta comum sobre reembolso, uma cuja resposta apareça apenas em um aditivo, uma sem resposta no material e outra sobre um documento ao qual o usuário não tem acesso. Uma resposta fluente não basta: verifique a versão da fonte, as restrições de permissão e se há evidências que sustentem a resposta.

Comece com uma recuperação fixa. Adicione buscas adaptativas só quando uma resposta incorreta puder ser corrigida por mais uma etapa de coleta de evidências. O guia de RAG com agentes explica quando esse ciclo adicional de decisão compensa o custo.

O que é gratuito e o que é pago?

Os frameworks são gratuitos; processamento de documentos, observabilidade e implantação em serviços hospedados são contratados à parte. Os preços abaixo foram verificados nas páginas dos fornecedores para os Estados Unidos em 13 de outubro de 2026.

LlamaCloud e LlamaParse

LlamaParse é o nome que aparece hoje na página pública de preços do LlamaIndex para sua plataforma hospedada de documentos, acessada pelo painel do LlamaCloud. Ela cobre interpretação, extração e indexação. É um serviço comercial oferecido ao lado do framework de código aberto, não uma assinatura obrigatória para importar llama_index.

Os planos públicos são Free, por $0/mês com 10,000 créditos; Starter, por $50/mês com 40,000 créditos; e Pro, por $500/mês com 400,000 créditos. O Enterprise tem preço sob consulta. A tarifa padrão de uso é de $1.25 por 1,000 créditos.

O consumo por página de PDF depende do nível de processamento: Fast usa 1 crédito; Cost-effective, 3; Agentic, 10; e Agentic Plus, 45. O gráfico a seguir converte essas tarifas publicadas no valor dos créditos consumidos pelo mesmo lote. O cálculo exclui franquias, valores mínimos de assinatura e adicionais, portanto não representa uma fatura mensal.

Fast produz texto com informações de disposição espacial, em vez de Markdown. Escolha esse nível apenas se a saída servir ao seu fluxo de ingestão. Os créditos também não eliminam os limites de cada plano: Free e Starter permitem 5 tarefas simultâneas de processamento, contra 20 no Pro. Mude de plano pela capacidade ou pelos recursos de que precisa, não por supor que um pacote maior automaticamente reduz o custo de cada crédito. Fontes: preços por uso e comparação dos planos.

LangSmith

LangSmith é a plataforma comercial de observabilidade, avaliação e implantação do ecossistema LangChain. Ela pode rastrear aplicações construídas com outros frameworks, inclusive LlamaIndex, então a escolha é independente da decisão sobre o framework. O fornecedor explica esse suporte a diferentes frameworks.

A página de preços do LangSmith apresenta o Developer por $0/mês para um usuário, com 5,000 traces básicos, e o Plus por $39 por usuário por mês, com 10,000 traces básicos no total. O uso adicional é cobrado. O Enterprise tem preço sob consulta.

Um trace registra uma execução da aplicação e pode conter várias chamadas de modelo e eventos de ferramentas. Não é a mesma coisa que um token ou um trecho individual recuperado. O Plus inclui uma pequena implantação serverless, mas o uso adicional de implantação deve entrar separadamente no orçamento; o fornecedor recomenda implantação dedicada para agentes que atendem clientes.

Quanto custa a mesma carga mensal em cada opção?

Com o mesmo uso dos mesmos serviços, trocar de framework não reduz o custo das assinaturas. Considere este cenário mensal, de escopo deliberadamente limitado, com aplicação e índice hospedados separadamente:

• Três desenvolvedores precisam de licenças de usuário do LangSmith Plus.
• A aplicação gera 20,000 traces básicos.
• Você processa 1,000 novas páginas de PDF no nível Agentic do LlamaParse.
• As duas implementações usam o mesmo modelo de chat, o mesmo modelo de embeddings e a mesma carga de tokens.
• O cenário não inclui o Index hospedado, armazenamento de arquivos retidos nem outras operações de documentos que consomem créditos.

O processamento consome 1,000 × 10 = 10,000 créditos, dentro da franquia mensal do Free se ela não tiver sido usada para mais nada. O valor efetivamente cobrado é $0, embora os créditos consumidos tenham um valor de tabela de $12.50. São valores distintos: o valor dos créditos não gera uma fatura no plano Free. Dados usados: planos do LlamaParse e tarifas de uso.

A calculadora atual de preços do LangSmith informa 0.005 LSU por trace adicional, a $1 por LSU. Três usuários custam 3 × $39 = $117. O uso de traces acima da franquia compartilhada custa (20,000 − 10,000) × $0.005 = $50. O subtotal dos serviços selecionados é de $167/mês com LlamaIndex e $167/mês com LangChain.

Esse subtotal exclui inferência do modelo, embeddings e hospedagem própria. O orçamento total da aplicação soma esses custos aos serviços selecionados. Ao comparar a mesma carga de trabalho do modelo, esses fatores ficam iguais; se um framework provocar buscas ou chamadas de modelo extras, a carga muda e precisa ser medida separadamente.

Não há um ponto de consumo em que um framework passe a ser mais barato que o outro neste cenário: a licença de ambos continua gratuita, e os dois podem usar os mesmos serviços pagos. Comparar $50 de processamento de documentos com $39 de observabilidade seria comparar trabalhos diferentes. A decisão de gasto depende do serviço de que a aplicação precisa e do quanto consome.

Atenção à cobrança: consulta de recuperação não é interação de chat

O Index v2 hospedado do LlamaParse cobra 1 crédito por consulta de recuperação e 100 créditos por interação de chat, além dos custos aplicáveis de processamento e armazenamento. Pela tarifa padrão, 1,000 operações correspondem a $1.25 em créditos para recuperação ou $125 para chat hospedado, antes das franquias. São operações diferentes, não dois preços para uma resposta idêntica. Fonte: preços do Index.

Essa diferença importa ao desenhar uma arquitetura que combina os frameworks. Se o agente externo já gera a resposta final, decida se a ferramenta de recuperação precisa devolver evidências ou uma resposta sintetizada por outro serviço. A escolha afeta tanto a interface quanto a cobrança. Uma chamada local a query_engine.query() não gera automaticamente a tarifa de interação de chat do Index hospedado; o serviço gerenciado precisa de fato participar do caminho da requisição.

Quando vale usar LlamaIndex e LangChain juntos?

Use os dois quando a recuperação de documentos e a orquestração de ações forem desafios complexos por si só. Um agente de suporte que precisa interpretar aditivos às políticas e coordenar um fluxo de aprovação é um bom candidato. Uma interface de perguntas e respostas sobre texto bem estruturado geralmente não é.

Deixe a ingestão e a recuperação de documentos sob a responsabilidade do LlamaIndex. Exponha uma função ou um serviço de escopo restrito que devolva trechos relevantes com identificadores de fonte e metadados. O agente do LangChain chama essa função como ferramenta, com LangGraph na base da execução. A orientação do fornecedor sobre o uso combinado descreve essa divisão.

No exemplo de suporte, devolva o trecho da política, o ID do documento e os metadados da revisão. O agente pode comparar essas informações com o registro do pedido e propor uma ação. Preserve as referências às fontes até a resposta final, para que a aplicação possa verificar o que a sustenta.

Evite colocar, sem querer, uma resposta já sintetizada dentro de outro ciclo que gera respostas. Uma string devolvida por um mecanismo de consulta pode ser prática, mas também pode ocultar do agente externo os trechos usados como base. Quando for importante inspecionar as fontes, prefira um resultado de recuperação com evidências explícitas. Use respostas parciais sintetizadas apenas quando essa divisão de tarefas for intencional.

O custo adicional de usar dois frameworks está na manutenção: duas interfaces de integração, mais atualizações de dependências e mais uma interface para instrumentar. Os dois só se justificam quando você consegue descrever a responsabilidade de cada um sem dizer que ambos “cuidam do agente”.

Migração de framework: o que pode ser aproveitado e o que pode quebrar?

O custo da migração está nas convenções de dados e no estado do fluxo, não na troca dos imports. Migrar de LlamaIndex para LangChain, ou usar LlamaIndex como alternativa aos componentes de recuperação do LangChain, deve começar pelo contrato exposto pela aplicação atual.

Mantenha os documentos de origem e os metadados em formato exportável. Preserve IDs dos documentos, rótulos de acesso, revisões das fontes e referências de citações. Esses são ativos da aplicação. Os objetos de documento e de nó específicos de cada framework são adaptadores em torno deles.

Os embeddings existentes podem continuar úteis se o modelo de embeddings, as dimensões, o texto armazenado e o esquema do banco permanecerem compatíveis. Não presuma que um novo adaptador consiga ler todos os campos sem alterações. Se você mudar os limites dos fragmentos ou o modelo de embeddings, planeje reconstruir o índice afetado e reavaliar os resultados da recuperação. O guia de bancos vetoriais do LlamaIndex diferencia o armazenamento padrão em memória das integrações persistentes.

Nos fluxos de trabalho, trate o estado da conversa, as aprovações pendentes e as ações não concluídas como uma migração separada. Não execute novamente chamadas antigas de ferramentas apenas para reconstruir o estado: uma ação externa repetida pode ter consequências mesmo quando a conversa parece correta. Defina como as sessões antigas serão concluídas e como as novas começarão antes de redirecionar o tráfego.

Não troque um agente de documentos estável em LlamaIndex só para adotar o rótulo de agente. Não substitua um fluxo de recuperação que funciona em LangChain porque outro exemplo tem menos linhas. Mude quando a abstração atual dificultar a implementação ou a manutenção de um requisito específico e recorrente.

Perguntas frequentes

Como decidir o próximo passo do projeto?

Comece pela falha que o protótipo precisa resolver. Se o desafio for encontrar o trecho certo na fonte, implemente primeiro um fluxo pequeno de recuperação com LlamaIndex. Se for coordenar ferramentas e ações aprovadas, comece com LangChain e defina o estado que precisa persistir entre as etapas. Mantenha a primeira versão funcional com um escopo que permita inspecionar cada fonte recuperada e cada ação proposta.

Use o Checklist de Auditoria de Fluxos de Trabalho com IA para Negócios para definir a tarefa, os requisitos de evidência e quais ações exigem aprovação antes de escolher o framework.