Escolhendo entre LlamaIndex e LangChain: Um Guia Completo

Principais Destaques

• LlamaIndex: Especializado em ingestão, estruturação e aproveitamento de dados privados ou específicos de domínio para tarefas como questionamento avançado e compreensão de documentos.
• LangChain: Oferece um framework abrangente de código aberto para desenvolver, implantar e escalar aplicações com LLMs, suportando diversos casos de uso, incluindo agentes conversacionais, tradução e workflows complexos.
• Integração de LLM Personalizado: Fornece um guia de código abrangente e passo a passo para implementar LLMs personalizados com os frameworks LlamaIndex e LangChain, mostrando suas respectivas abordagens para integrar e aproveitar APIs externas como a Novita AI.

Introdução

No cenário em rápida evolução da inteligência artificial e do processamento de linguagem natural, dois frameworks emergiram como ferramentas poderosas para desenvolvedores que trabalham com Grandes Modelos de Linguagem (LLMs): LlamaIndex e LangChain. Este post tem como objetivo fornecer uma comparação abrangente entre LlamaIndex vs LangChain, explorando seus principais recursos, casos de uso e aplicações práticas. Ao mergulhar nas funcionalidades principais, modelos de preços e capacidades de integração de cada framework, forneceremos o conhecimento necessário para tomar uma decisão informada sobre qual ferramenta melhor atende às suas necessidades específicas.

O que é LlamaIndex?

LlamaIndex é um framework de dados sofisticado projetado para capacitar Grandes Modelos de Linguagem (LLMs), fornecendo a eles dados contextualmente relevantes e específicos do usuário. Diferentemente dos LLMs de uso geral que são pré-treinados em dados públicos, o LlamaIndex permite que esses modelos acessem e aproveitem dados privados, específicos de domínio ou centrados em problemas, que muitas vezes estão isolados atrás de APIs, em bancos de dados ou presos em formatos não estruturados como PDFs.

Principais Recursos e Capacidades

• Ingestão de Dados: O LlamaIndex oferece conectores de dados que ingerem perfeitamente dados de várias fontes, incluindo, mas não se limitando a APIs, PDFs e bancos de dados SQL, em seus formatos nativos.
• Estruturação de Dados: Estrutura os dados ingeridos em representações intermediárias otimizadas para consumo eficiente pelos LLMs, garantindo alto desempenho.
• Acesso em Linguagem Natural: O LlamaIndex fornece engines que concedem acesso em linguagem natural aos dados, facilitando o questionamento através de query engines e permitindo interações conversacionais via chat engines.
• Workers de Conhecimento: O framework inclui agentes que funcionam como workers de conhecimento alimentados por LLM, aumentados por uma variedade de ferramentas que vão desde ajudantes simples até integrações complexas de API.
• Observabilidade e Avaliação: Incorpora integrações para experimentação, avaliação e monitoramento rigorosos, garantindo um ciclo de melhoria contínua para as aplicações.

Casos de Uso

O LlamaIndex suporta uma gama diversificada de casos de uso, como:

• Geração Aumentada por Recuperação (RAG) para sistemas avançados de questionamento.
• Chatbots que podem participar de conversas significativas e conscientes do contexto.
• Compreensão de Documentos e extração de dados de documentos não estruturados.
• Agentes Autônomos capazes de conduzir pesquisas e executar ações.
• Aplicações Multimodais que integram texto com imagens e outros tipos de dados.
• Ajuste fino de modelos em dados específicos para melhorar o desempenho.

O que é LangChain?

LangChain é um framework de ponta projetado especificamente para simplificar o desenvolvimento, a produção e a implantação de aplicações alimentadas por Grandes Modelos de Linguagem (LLMs). Ele oferece um conjunto abrangente de ferramentas e bibliotecas que atendem a cada estágio do ciclo de vida da aplicação LLM, garantindo um processo de desenvolvimento contínuo e eficiente.

Principais Recursos e Capacidades

• Desenvolvimento: O LangChain fornece blocos de construção de código aberto, componentes e integrações de terceiros que simplificam a criação de aplicações LLM. O LangGraph, um componente chave, permite a construção de agentes com estado com suporte robusto para streaming de dados e workflows human-in-the-loop.
• Produção: O LangSmith é uma ferramenta poderosa para inspecionar, monitorar e avaliar o desempenho de suas chains LLM. Ele garante otimização contínua e implantação confiável, oferecendo insights profundos sobre o desempenho da aplicação.
• Implantação: O LangGraph Cloud facilita a transformação de aplicações LangGraph em APIs e Assistentes prontos para produção, tornando fácil escalar e integrar aplicações LLM em vários sistemas.
• Organização Hierárquica: O framework é organizado hierarquicamente, com partes interconectadas em várias camadas, garantindo modularidade e flexibilidade no desenvolvimento de aplicações.

Bibliotecas de Código Aberto

• langchain-core: Oferece abstrações base e a Linguagem de Expressão LangChain, servindo como base para o framework.
• langchain-community: Integra serviços de terceiros e expande as capacidades do LangChain.
• Pacotes de Parceiros: Pacotes leves como langchain-openai e langchain-anthropic que fornecem integrações específicas, aumentando a versatilidade do framework.
• langchain: Compreende chains, agentes e estratégias de recuperação que formam a arquitetura cognitiva de uma aplicação.
• LangGraph: Uma ferramenta poderosa para construir aplicações multi-ator com estado usando LLMs, com um modelo baseado em grafo para etapas, e pode ser integrada ou usada independentemente do LangChain.
• LangServe: Implanta chains LangChain como APIs REST, facilitando a integração com serviços web.
• LangSmith: Uma plataforma de desenvolvedor que fornece um conjunto abrangente de ferramentas para depuração, teste, avaliação e monitoramento de aplicações LLM.

Público e Casos de Uso

O LangChain é projetado para desenvolvedores de todos os níveis, de iniciantes a especialistas, que desejam aproveitar o poder dos LLMs em suas aplicações. Sua arquitetura modular e extensível o torna adequado para uma ampla gama de casos de uso, incluindo, mas não se limitando a:

• Construção de agentes conversacionais e chatbots.
• Desenvolvimento de ferramentas de tradução e sumarização de idiomas.
• Criação de sistemas de geração e classificação de conteúdo.
• Implementação de workflows complexos com LLMs.

LlamaIndex vs LangChain: Principais Diferenças

Funcionalidades Principais:

• LangChain é um framework abrangente projetado para simplificar a criação de aplicações cientes de dados e agentes com Grandes Modelos de Linguagem (LLMs). Oferece uma ampla gama de ferramentas para várias aplicações alimentadas por LLM, focando em flexibilidade e capacidades avançadas de IA.
• LlamaIndex (anteriormente conhecido como GPT Index) é um framework de dados focado especificamente em ingerir, estruturar e acessar dados privados ou específicos de domínio para LLMs. Ele simplifica a indexação e recuperação de informações, tornando-o perfeito para pesquisa baseada em texto e geração de respostas precisas.

Casos de Uso:

• LangChain é versátil e pode ser usado para várias aplicações, como geração de texto, tradução de idiomas, sumarização de texto e classificação de texto. É particularmente adequado para manter conversas longas e contextualmente relevantes devido ao seu excelente gerenciamento de memória e capacidades de chain.
• LlamaIndex se destaca em cenários onde a pesquisa de texto e respostas de alta qualidade são as principais prioridades. Casos de uso comuns incluem geração de conteúdo, pesquisa e recuperação de documentos, e aumento de LLM para chatbots e assistentes virtuais.

Preços e Disponibilidade:

• LangChain é uma ferramenta gratuita e de código aberto, com seu código-fonte disponível para download em plataformas como GitHub, tornando-o acessível para qualquer pessoa usar.
• LlamaIndex é um produto comercial, e seu preço é determinado pelo uso, o que significa que pode envolver custos com base na extensão em que é usado dentro das aplicações.

Personalização e Flexibilidade:

• LangChain oferece opções avançadas de personalização, tornando-o adequado para desenvolvedores que precisam ajustar suas aplicações com requisitos específicos.
• LlamaIndex fornece recursos e ferramentas amigáveis que facilitam a integração perfeita de dados privados ou específicos de domínio em LLMs, focando na facilidade de uso e gerenciamento direto de dados.

Manipulação de Dados:

• LangChain é projetado para trabalhar com uma variedade de tipos e fontes de dados, oferecendo componentes como Schema para organização de dados e Indexes para recuperação eficiente de informações.
• LlamaIndex enfatiza a capacidade de compor um índice a partir de outros índices, tornando-o altamente eficaz para consultas e workflows complexos que envolvem múltiplas fontes de dados.

Integração:

• LangChain fornece integrações com serviços de terceiros e pode ser estendido com pacotes de parceiros para provedores de LLM específicos.
• LlamaIndex oferece conectores de dados para integração perfeita de várias fontes de dados, melhorando a qualidade e o desempenho dos dados.

LlamaIndex vs LangChain: Comparação de Exemplos Práticos

Referência de Ming no Medium, aqui estão alguns exemplos práticos comparando LlamaIndex com LangChain.

Criando um chatbot com um LLM local

Os exemplos de código mostram como inicializar o LLM com ambos os frameworks e como imprimir a saída de uma interação de chat.

Código LlamaIndex:

from llama_index.llms import ChatMessage, OpenAILike

llm = OpenAILike(
    api_base="http://localhost:1234/v1",
    timeout=600,
    api_key="loremIpsum",
    is_chat_model=True,
    context_window=32768,
)
chat_history = [
    ChatMessage(role="system", content="You are a bartender."),
    ChatMessage(role="user", content="What do I enjoy drinking?"),
]
output = llm.chat(chat_history)
print(output)

Código LangChain:

from langchain.schema import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    openai_api_base="http://localhost:1234/v1",
    request_timeout=600,
    openai_api_key="loremIpsum",
    max_tokens=32768,
)
chat_history = [
    SystemMessage(content="You are a bartender."),
    HumanMessage(content="What do I enjoy drinking?"),
]
print(llm(chat_history))

Construindo um sistema RAG para arquivos locais

Os trechos de código ilustram como carregar dados, criar um índice e realizar uma consulta.

Código LlamaIndex:

from llama_index import ServiceContext, SimpleDirectoryReader, VectorStoreIndex

service_context = ServiceContext.from_defaults(  
    embed_model="local",  
    llm=llm, # This should be the LLM initialized in the task above.
)  
documents = SimpleDirectoryReader(
    input_dir="mock_notebook/",
).load_data()  
index = VectorStoreIndex.from_documents(  
    documents=documents,
    service_context=service_context,
)
engine = index.as_query_engine(  
    service_context=service_context,  
)
output = engine.query("What do I like to drink?")  
print(output)

Código LangChain:

from langchain_community.document_loaders import DirectoryLoader  
  
# pip install "unstructured[md]"  
loader = DirectoryLoader("mock_notebook/", glob="*.md")  
docs = loader.load()  
  
from langchain.text_splitter import RecursiveCharacterTextSplitter  
  
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)  
splits = text_splitter.split_documents(docs)  
  
from langchain_community.embeddings.fastembed import FastEmbedEmbeddings  
from langchain_community.vectorstores import Chroma  
  
vectorstore = Chroma.from_documents(documents=splits, embedding=FastEmbedEmbeddings())  
retriever = vectorstore.as_retriever()  
  
from langchain import hub  
  
# pip install langchainhub  
prompt = hub.pull("rlm/rag-prompt")  
  
  
def format_docs(docs):  
    return "\n\n".join(doc.page_content for doc in docs)  
  
  
from langchain_core.runnables import RunnablePassthrough  
  
rag_chain = (  
    {"context": retriever | format_docs, "question": RunnablePassthrough()}  
    | prompt  
    | llm # This should be the LLM initialized in the task above.
)  
print(rag_chain.invoke("What do I like to drink?"))

Pela comparação, parece que o LlamaIndex, com foco em sistemas RAG, oferece uma abordagem mais simples, enquanto o LangChain oferece um método mais abstrato e de alto nível.

LlamaIndex vs LangChain: Como Usar LLM Personalizado com LlamaIndex?

Para integrar a API LLM da Novita AI com o LlamaIndex, você precisará criar um adaptador personalizado que envolva as chamadas da API da Novita AI dentro do framework LlamaIndex. Abaixo está um exemplo conceitual de como você pode fazer isso. Observe que este exemplo pressupõe que você tenha uma compreensão básica de como trabalhar com APIs e o framework LlamaIndex.

Passo 1: Defina um adaptador personalizado para o LLM da Novita AI

Primeiro, vamos definir um adaptador personalizado para o LLM da Novita AI:

class NovitaAILLM:
    def __init__(self, api_key):
        from openai import OpenAI
        self.client = OpenAI(api_key=api_key, base_url="https://api.novita.ai/v3/openai")

    def complete_chat(self, messages, stream=False, max_tokens=512):
        response = self.client.chat.completions.create(
            model="Nous-Hermes-2-Mixtral-8x7B-DPO",
            messages=messages,
            stream=stream,
            max_tokens=max_tokens
        )
        return response

Passo 2: Integração ao contexto de serviço do LlamaIndex

Em seguida, você precisaria integrar este adaptador ao contexto de serviço do LlamaIndex. Aqui está um exemplo conceitual de como você pode fazer isso:

from llama_index import (
    KeywordTableIndex,
    SimpleDirectoryReader,
    ServiceContext,
)
from llama_index.llms import LLM

class NovitaAILLMAdapter(LLM):
    def __init__(self, api_key):
        self.novitailm = NovitaAILLM(api_key)

    def generate_text(self, prompt, stop_sequences=None, **kwargs):
        # Prepare the messages for the chat completion
        messages = [
            {"role": "system", "content": prompt}
        ]
        # Call the Novita AI LLM to complete the chat
        response = self.novitailm.complete_chat(messages)
        if isinstance(response, list):  # If streaming, collect all chunks
            return "".join([chunk.choices[0].delta.content for chunk in response])
        else:
            return response.choices[0].message.content

# Initialize the Novita AI LLM adapter with your API key
novitailm_adapter = NovitaAILLMAdapter(api_key="<YOUR Novita AI API Key>")

# Create the service context with the custom LLM adapter
service_context = ServiceContext.from_defaults(llm=novitailm_adapter)

# Load documents and build the index as before
documents = SimpleDirectoryReader("data").load_data()
index = KeywordTableIndex.from_documents(documents, service_context=service_context)

# Now you can use the index with the custom LLM for queries
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do after his time at Y Combinator?")
print(response)

Este exemplo mostra como criar um adaptador personalizado para o LLM da Novita AI e integrá-lo ao framework LlamaIndex. Você precisará substituir pela sua chave de API real da Novita AI.

Observe que este é um exemplo conceitual e pode exigir ajustes para se adequar às versões específicas das bibliotecas que você está usando e aos detalhes exatos da API do LLM da Novita AI. Sempre consulte a documentação oficial para obter as informações mais precisas e atualizadas.

LlamaIndex vs LangChain: Como Usar LLM Personalizado com LangChain?

Para integrar a API LLM da Novita AI com o LangChain usando LLM personalizado, você precisará criar uma classe personalizada que estenda a classe LLM do LangChain e use a API da Novita AI para sua lógica.

Aqui está um guia passo a passo sobre como fazer isso:

Passo 1: Instale a Biblioteca Python OpenAI

Primeiro, certifique-se de ter a biblioteca OpenAI instalada, que será usada para interagir com a API da Novita AI.

pip install 'openai>=1.0.0'

Passo 2: Importe as Bibliotecas Necessárias

Importe os módulos necessários do LangChain e da biblioteca OpenAI.

from typing import Any, Dict, Iterator, List, Optional
from langchain_core.callbacks.manager import CallbackManagerForLLMRun
from langchain_core.language_models.llms import LLM
from langchain_core.outputs import GenerationChunk
from openai import OpenAI

Passo 3: Defina a Classe LLM Personalizada

Estenda a classe LLM para criar um LLM personalizado que use a API da Novita AI.

class NovitaAILLM(LLM):
    def __init__(self, api_key: str, model_name: str = "Nous-Hermes-2-Mixtral-8x7B-DPO"):
        self.api_key = api_key
        self.model_name = model_name
        self.client = OpenAI(api_key=api_key, base_url="https://api.novita.ai/v3/openai")

    def _call(
        self,
        prompt: str,
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        **kwargs: Any,
    ) -> str:
        """Run the LLM on the given input."""
        response = self.client.chat.completions.create(
            model=self.model_name,
            messages=[{"role": "user", "content": prompt}],
            stream=False,
            max_tokens=512,
        )
        return response.choices[0].message.content

    def _stream(
        self,
        prompt: str,
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        **kwargs: Any,
    ) -> Iterator[GenerationChunk]:
        """Stream the LLM on the given prompt."""
        response = self.client.chat.completions.create(
            model=self.model_name,
            messages=[{"role": "user", "content": prompt}],
            stream=True,
            max_tokens=512,
        )
        for chunk in response:
            chunk_text = chunk.choices[0].delta.content or ""
            yield GenerationChunk(text=chunk_text)

    @property
    def _identifying_params(self) -> Dict[str, Any]:
        """Return a dictionary of identifying parameters."""
        return {
            "model_name": self.model_name,
        }

    @property
    def _llm_type(self) -> str:
        """Get the type of language model used by this chat model. Used for logging purposes only."""
        return "NovitaAILLM"

Passo 4: Inicialize e Use o LLM Personalizado

Crie uma instância do seu LLM personalizado com sua chave de API da Novita AI e use-a para gerar texto.

# Replace with your actual Novita AI API key
novita_api_key = "<YOUR Novita AI API Key>"

# Initialize the custom LLM
novita_llm = NovitaAILLM(api_key=novita_api_key)

# Generate text
prompt = "Hi there!"
response = novita_llm._call(prompt=prompt)
print(response)

# Or stream the response
for chunk in novita_llm._stream(prompt=prompt):
    print(chunk.text, end="")

Este código configura um LLM personalizado que usa a API da Novita AI para gerar texto com base em um prompt fornecido. O método _call é usado para respostas não streaming, e o método _stream é usado para respostas streaming. Ajuste o model_name e outros parâmetros conforme necessário com base na documentação da API da Novita AI e seus requisitos específicos.

Conclusão

Em conclusão, LlamaIndex e LangChain são ambas ferramentas valiosas para trabalhar com Grandes Modelos de Linguagem, cada uma com pontos fortes distintos. O LlamaIndex se destaca na ingestão e recuperação de dados, sendo ideal para projetos que exigem tratamento eficiente de dados específicos e sistemas avançados de questionamento. O LangChain oferece um framework mais abrangente para desenvolver e implantar aplicações LLM, com sua arquitetura modular e extensas integrações. A escolha entre os dois depende das necessidades específicas do seu projeto.

Perguntas Frequentes

LangChain e LlamaIndex podem ser usados juntos?

Sim. Depende das necessidades específicas do seu projeto LLM.

O LangChain é bom para produção?

Sim, o LangChain 0.1 e versões posteriores estão prontos para produção.

Qual é melhor para RAG: LlamaIndex ou LangChain?

LlamaIndex é recomendado se seu foco principal for capacidades de recuperação e pesquisa de dados. LangChain é mais adequado para cenários onde você precisa de um framework flexível que possa lidar com workflows complexos.

Novita AI é a plataforma all-in-one na nuvem que impulsiona suas ambições de IA. APIs integradas, serverless, GPU Instance — as ferramentas econômicas que você precisa. Elimine a infraestrutura, comece gratuitamente e torne sua visão de IA realidade.

Leitura Recomendada

How to Create Your LLM With LangChain: a Step-by-Step Guide

Master Streaming Langchain: Tips for Interacting with LLMs