Elección entre LlamaIndex y LangChain: Una guía completa

Puntos clave

• LlamaIndex: Se especializa en la ingesta y estructuración de datos, y en el aprovechamiento de datos privados o específicos de un dominio para tareas como la respuesta avanzada a preguntas y la comprensión de documentos.
• LangChain: Ofrece un marco integral de código abierto para desarrollar, implementar y escalar aplicaciones con LLMs, compatible con diversos casos de uso, incluidos agentes conversacionales, traducción y flujos de trabajo complejos.
• Integración de LLM personalizado: Proporciona una guía de código completa y paso a paso para implementar LLMs personalizados con los marcos de LlamaIndex y LangChain, mostrando sus respectivos enfoques para integrar y aprovechar APIs externas como Novita AI.

Introducción

En el panorama en rápida evolución de la inteligencia artificial y el procesamiento del lenguaje natural, han surgido dos marcos como herramientas poderosas para desarrolladores que trabajan con Modelos de Lenguaje de Gran Escala (LLMs): LlamaIndex y LangChain. Esta publicación de blog tiene como objetivo proporcionar una comparación exhaustiva entre LlamaIndex y LangChain, explorando sus características clave, casos de uso y aplicaciones prácticas. Al profundizar en las funcionalidades principales, los modelos de precios y las capacidades de integración de cada marco, te equiparemos con el conocimiento para tomar una decisión informada sobre qué herramienta se adapta mejor a tus necesidades específicas.

¿Qué es LlamaIndex?

LlamaIndex es un sofisticado marco de datos diseñado para potenciar los Modelos de Lenguaje de Gran Escala (LLMs) proporcionándoles datos contextualmente relevantes y específicos del usuario. A diferencia de los LLMs de propósito general que se preentrenan con datos públicos, LlamaIndex permite que estos modelos accedan y aprovechen datos privados, específicos de un dominio o centrados en problemas, que a menudo están aislados detrás de APIs, en bases de datos o atrapados en formatos no estructurados como PDF.

Características y capacidades clave

• Ingesta de datos: LlamaIndex ofrece conectores de datos que ingieren datos sin problemas desde una variedad de fuentes, incluidas, entre otras, APIs, PDFs y bases de datos SQL, en sus formatos nativos.
• Estructuración de datos: Estructura los datos ingeridos en representaciones intermedias optimizadas para un consumo eficiente por parte de los LLMs, garantizando un alto rendimiento.
• Acceso en lenguaje natural: LlamaIndex proporciona motores que otorgan acceso en lenguaje natural a los datos, facilitando la respuesta a preguntas a través de motores de consulta y permitiendo interacciones conversacionales mediante motores de chat.
• Trabajadores del conocimiento: El marco incluye agentes que funcionan como trabajadores del conocimiento impulsados por LLM, aumentados con una variedad de herramientas que van desde ayudas simples hasta integraciones complejas de API.
• Observabilidad y evaluación: Incorpora integraciones para la experimentación, evaluación y monitoreo rigurosos, asegurando un ciclo de mejora continua para las aplicaciones.

Casos de uso

LlamaIndex admite una amplia gama de casos de uso, como:

• Generación aumentada por recuperación (RAG) para sistemas avanzados de respuesta a preguntas.
• Chatbots que pueden mantener conversaciones significativas y conscientes del contexto.
• Comprensión de documentos y extracción de datos de documentos no estructurados.
• Agentes autónomos capaces de realizar investigaciones y ejecutar acciones.
• Aplicaciones multimodales que integran texto con imágenes y otros tipos de datos.
• Fine-tuning de modelos en datos específicos para mejorar el rendimiento.

¿Qué es LangChain?

LangChain es un marco de vanguardia diseñado específicamente para optimizar el desarrollo, la producción y la implementación de aplicaciones impulsadas por Modelos de Lenguaje de Gran Escala (LLMs). Ofrece un conjunto completo de herramientas y bibliotecas que cubren cada etapa del ciclo de vida de las aplicaciones LLM, garantizando un proceso de desarrollo fluido y eficiente.

Características y capacidades clave

• Desarrollo: LangChain proporciona bloques de construcción de código abierto, componentes e integraciones de terceros que simplifican la creación de aplicaciones LLM. LangGraph, un componente clave, permite la construcción de agentes con estado con soporte robusto para transmisión de datos y flujos de trabajo con intervención humana.
• Producción: LangSmith es una herramienta poderosa para inspeccionar, monitorear y evaluar el rendimiento de tus cadenas LLM. Garantiza una optimización continua y una implementación segura al ofrecer información detallada sobre el rendimiento de la aplicación.
• Implementación: LangGraph Cloud facilita la transformación de aplicaciones LangGraph en APIs y Asistentes listos para producción, lo que facilita escalar e integrar aplicaciones LLM en varios sistemas.
• Organización jerárquica: El marco está organizado jerárquicamente, con partes interconectadas en múltiples capas, lo que garantiza modularidad y flexibilidad en el desarrollo de aplicaciones.

Bibliotecas de código abierto

• langchain-core: Ofrece abstracciones base y el Lenguaje de Expresión LangChain, sirviendo como base del marco.
• langchain-community: Integra servicios de terceros y amplía las capacidades de LangChain.
• Paquetes de socios: Paquetes ligeros como langchain-openai y langchain-anthropic que proporcionan integraciones específicas, mejorando la versatilidad del marco.
• langchain: Comprende cadenas, agentes y estrategias de recuperación que forman la arquitectura cognitiva de una aplicación.
• LangGraph: Una herramienta poderosa para construir aplicaciones multiagente con estado utilizando LLMs, mediante un modelo basado en grafos para los pasos, y puede integrarse con LangChain o usarse de forma independiente.
• LangServe: Despliega cadenas LangChain como APIs REST, facilitando la integración con servicios web.
• LangSmith: Una plataforma para desarrolladores que proporciona un conjunto completo de herramientas para depurar, probar, evaluar y monitorear aplicaciones LLM.

Audiencia y casos de uso

LangChain está diseñado para desarrolladores de todos los niveles, desde principiantes hasta expertos, que buscan aprovechar el poder de los LLMs en sus aplicaciones. Su arquitectura modular y extensible lo hace adecuado para una amplia gama de casos de uso, que incluyen, entre otros:

• Construcción de agentes conversacionales y chatbots.
• Desarrollo de herramientas de traducción y resumen de idiomas.
• Creación de sistemas de generación y clasificación de contenidos.
• Implementación de flujos de trabajo complejos con LLMs.

LlamaIndex vs LangChain: Diferencias clave

Funcionalidad principal:

• LangChain es un marco integral diseñado para simplificar la creación de aplicaciones conscientes de datos y agentes con Modelos de Lenguaje de Gran Escala (LLMs). Ofrece una amplia gama de herramientas para diversas aplicaciones impulsadas por LLM, centrándose en la flexibilidad y las capacidades avanzadas de IA.
• LlamaIndex (anteriormente conocido como GPT Index) es un marco de datos enfocado específicamente en la ingesta, estructuración y acceso a datos privados o específicos de un dominio para LLMs. Simplifica la indexación y recuperación de información, lo que lo hace perfecto para búsquedas basadas en texto y generación de respuestas precisas.

Casos de uso:

• LangChain es versátil y se puede utilizar para diversas aplicaciones como generación de texto, traducción de idiomas, resumen de texto y clasificación de texto. Es especialmente adecuado para mantener conversaciones largas y contextualmente relevantes debido a su excelente gestión de memoria y capacidades de cadena.
• LlamaIndex sobresale en escenarios donde la búsqueda de texto y las respuestas de alta calidad son las prioridades principales. Los casos de uso comunes incluyen generación de contenido, búsqueda y recuperación de documentos, y aumento de LLM para chatbots y asistentes virtuales.

Precios y disponibilidad:

• LangChain es una herramienta de código abierto y gratuita, con su código fuente disponible para descargar en plataformas como GitHub, lo que la hace accesible para cualquier persona.
• LlamaIndex es un producto comercial, y su precio se determina según el uso, lo que significa que puede implicar costos según el alcance de su uso en las aplicaciones.

Personalización y flexibilidad:

• LangChain ofrece opciones de personalización avanzadas, lo que lo hace adecuado para desarrolladores que necesitan ajustar sus aplicaciones con requisitos específicos.
• LlamaIndex proporciona características y herramientas fáciles de usar que facilitan la integración fluida de datos privados o específicos de un dominio en LLMs, centrándose en la facilidad de uso y la gestión sencilla de datos.

Manejo de datos:

• LangChain está diseñado para trabajar con varios tipos y fuentes de datos, ofreciendo componentes como Schema para la organización de datos e Indexes para la recuperación eficiente de información.
• LlamaIndex enfatiza la capacidad de componer un índice a partir de otros índices, lo que lo hace muy efectivo para consultas y flujos de trabajo complejos que involucran múltiples fuentes de datos.

Integración:

• LangChain proporciona integraciones con servicios de terceros y se puede ampliar con paquetes de socios para proveedores de LLM específicos.
• LlamaIndex ofrece conectores de datos para la integración fluida de diversas fuentes de datos, mejorando la calidad y el rendimiento de los datos.

LlamaIndex vs LangChain: Comparación de ejemplos prácticos

Haciendo referencia a Ming en Medium, aquí hay algunos ejemplos prácticos que comparan LlamaIndex con LangChain.

Creación de un chatbot con un LLM local

Los ejemplos de código muestran cómo inicializar el LLM con ambos marcos y cómo imprimir la salida de una interacción de chat.

Código de 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 de 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))

Construcción de un sistema RAG para archivos locales

Los fragmentos de código ilustran cómo cargar datos, crear un índice y realizar una consulta.

Código de 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 de 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 "\
\
".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?"))

De la comparación, parece que LlamaIndex, con un enfoque en sistemas RAG, proporciona un enfoque más simple mientras que LangChain ofrece un método más abstracto y de alto nivel.

LlamaIndex vs LangChain: ¿Cómo usar un LLM personalizado con LlamaIndex?

Para integrar la API LLM de Novita AI con LlamaIndex, deberás crear un adaptador personalizado que envuelva las llamadas a la API de Novita AI dentro del marco LlamaIndex. A continuación se muestra un ejemplo conceptual de cómo podrías lograrlo. Ten en cuenta que este ejemplo asume que tienes un conocimiento básico de cómo trabajar con APIs y el marco LlamaIndex.

Paso 1: Definir un adaptador personalizado para el LLM de Novita AI

Primero, definamos un adaptador personalizado para el LLM de 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

Paso 2: Integración en el contexto de servicio de LlamaIndex

A continuación, deberías integrar este adaptador en el contexto de servicio de LlamaIndex. Aquí hay un ejemplo conceptual de cómo podrías hacerlo:

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 ejemplo muestra cómo crear un adaptador personalizado para el LLM de Novita AI e integrarlo en el marco LlamaIndex. Deberás reemplazar con tu clave de API real de Novita AI.

Ten en cuenta que este es un ejemplo conceptual y puede requerir ajustes para adaptarse a las versiones específicas de las bibliotecas que estás utilizando y a los detalles exactos de la API del LLM de Novita AI. Siempre consulta la documentación oficial para obtener la información más precisa y actualizada.

LlamaIndex vs LangChain: ¿Cómo usar un LLM personalizado con LangChain?

Para integrar la API LLM de Novita AI con LangChain usando un LLM personalizado, deberás crear una clase personalizada que extienda la clase LLM de LangChain y utilice la API de Novita AI para su lógica.

Aquí tienes una guía paso a paso sobre cómo hacerlo:

Paso 1: Instalar la biblioteca Python de OpenAI

Primero, asegúrate de tener instalada la biblioteca OpenAI, que se usará para interactuar con la API de Novita AI.

pip install 'openai>=1.0.0'

Paso 2: Importar las bibliotecas necesarias

Importa los módulos necesarios de LangChain y la 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

Paso 3: Definir la clase LLM personalizada

Extiende la clase LLM para crear un LLM personalizado que use la API de 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"

Paso 4: Inicializar y usar el LLM personalizado

Crea una instancia de tu LLM personalizado con tu clave de API de Novita AI y úsalo para generar 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 un LLM personalizado que utiliza la API de Novita AI para generar texto basado en un prompt dado. El método _call se utiliza para respuestas no transmitidas, y el método _stream para respuestas transmitidas. Ajusta el model_name y otros parámetros según sea necesario según la documentación de la API de Novita AI y tus requisitos específicos.

Conclusión

En conclusión, LlamaIndex y LangChain son herramientas valiosas para trabajar con Modelos de Lenguaje de Gran Escala, cada una con fortalezas distintas. LlamaIndex sobresale en la ingesta y recuperación de datos, lo que lo hace ideal para proyectos que requieren un manejo eficiente de datos específicos y sistemas avanzados de respuesta a preguntas. LangChain ofrece un marco más completo para desarrollar e implementar aplicaciones LLM, con su arquitectura modular y amplias integraciones. La elección entre ambos depende de las necesidades específicas de tu proyecto.

Preguntas frecuentes

¿Se pueden usar LangChain y LlamaIndex juntos?

Sí. Depende de las necesidades específicas de tu proyecto LLM.

¿LangChain es bueno para producción?

Sí, LangChain 0.1 y versiones posteriores están listos para producción.

¿Cuál es mejor para RAG, LlamaIndex o LangChain?

Se recomienda LlamaIndex si tu enfoque principal es la recuperación y búsqueda de datos. LangChain es más adecuado para escenarios donde necesitas un marco flexible que pueda manejar flujos de trabajo complejos.

Novita AI es la plataforma integral en la nube que impulsa tus ambiciones de IA. APIs integradas, sin servidor, instancias de GPU: las herramientas rentables que necesitas. Elimina la infraestructura, comienza gratis y haz realidad tu visión de IA.

Lectura recomendada

Cómo crear tu propio LLM con LangChain: guía paso a paso

Domina Streaming LangChain: consejos para interactuar con LLMs