Choisir entre LlamaIndex et LangChain : Un guide complet

Points clés

• LlamaIndex : Spécialisé dans l’ingestion, la structuration et l’exploitation de données privées ou spécifiques à un domaine pour des tâches comme le question-réponse avancé et la compréhension de documents.
• LangChain : Propose un framework open source complet pour développer, déployer et faire évoluer des applications avec les LLM, prenant en charge divers cas d’usage : agents conversationnels, traduction, workflows complexes.
• Intégration personnalisée de LLM : Fournit un guide de code complet, étape par étape, pour implémenter des LLM personnalisés avec les frameworks LlamaIndex et LangChain, montrant leurs approches respectives pour intégrer et exploiter des API externes comme Novita AI.

Introduction

Dans le paysage en évolution rapide de l’intelligence artificielle et du traitement du langage naturel, deux frameworks sont devenus des outils puissants pour les développeurs travaillant avec les grands modèles de langage (LLM) : LlamaIndex et LangChain. Cet article de blog vise à fournir une comparaison complète entre LlamaIndex et LangChain, en explorant leurs fonctionnalités clés, leurs cas d’usage et leurs applications pratiques. En examinant les fonctionnalités principales, les modèles de tarification et les capacités d’intégration de chaque framework, nous vous donnerons les connaissances nécessaires pour choisir en toute connaissance de cause l’outil le mieux adapté à vos besoins spécifiques.

Qu’est-ce que LlamaIndex ?

LlamaIndex est un framework de données sophistiqué conçu pour doter les grands modèles de langage (LLM) de données contextuelles et spécifiques à l’utilisateur. Contrairement aux LLM généralistes pré-entraînés sur des données publiques, LlamaIndex permet à ces modèles d’accéder et d’exploiter des données privées, spécifiques à un domaine ou centrées sur un problème, souvent cloisonnées derrière des API, dans des bases de données ou piégées dans des formats non structurés comme les PDF.

Fonctionnalités et capacités clés

• Ingestion de données : LlamaIndex offre des connecteurs de données qui ingèrent facilement des données provenant de diverses sources, y compris mais sans s’y limiter les API, les PDF et les bases de données SQL, dans leurs formats natifs.
• Structuration des données : Il structure les données ingérées en représentations intermédiaires optimisées pour une consommation efficace par les LLM, garantissant des performances élevées.
• Accès en langage naturel : LlamaIndex fournit des moteurs qui donnent un accès en langage naturel aux données, facilitant le question-réponse via des moteurs de requête et permettant des interactions conversationnelles via des moteurs de chat.
• Agents de connaissance : Le framework inclut des agents qui fonctionnent comme des travailleurs du savoir alimentés par LLM, enrichis par une gamme d’outils allant de simples assistants à des intégrations API complexes.
• Observabilité et évaluation : Il intègre des fonctionnalités d’expérimentation rigoureuse, d’évaluation et de monitoring, garantissant un cycle d’amélioration continue des applications.

Cas d’usage

LlamaIndex prend en charge une variété de cas d’usage, notamment :

• Génération augmentée par récupération (RAG) pour des systèmes de question-réponse avancés.
• Chatbots capables de conversations pertinentes et contextuelles.
• Compréhension de documents et extraction de données à partir de documents non structurés.
• Agents autonomes capables de mener des recherches et d’exécuter des actions.
• Applications multimodales qui intègrent du texte avec des images et d’autres types de données.
• Ajustement fin de modèles sur des données spécifiques pour améliorer les performances.

Qu’est-ce que LangChain ?

LangChain est un framework de pointe spécialement conçu pour rationaliser le développement, la mise en production et le déploiement d’applications alimentées par les grands modèles de langage (LLM). Il offre un ensemble complet d’outils et de bibliothèques qui couvrent chaque étape du cycle de vie des applications LLM, garantissant un processus de développement fluide et efficace.

Fonctionnalités et capacités clés

• Développement : LangChain fournit des blocs de construction open source, des composants et des intégrations tierces qui simplifient la création d’applications LLM. LangGraph, un composant clé, permet la construction d’agents avec état, avec un support robuste pour le streaming de données et les workflows avec intervention humaine.
• Mise en production : LangSmith est un outil puissant pour inspecter, surveiller et évaluer les performances de vos chaînes LLM. Il garantit une optimisation continue et un déploiement en confiance en offrant des informations approfondies sur les performances de l’application.
• Déploiement : LangGraph Cloud facilite la transformation des applications LangGraph en API et assistants prêts pour la production, facilitant ainsi leur mise à l’échelle et leur intégration dans divers systèmes.
• Organisation hiérarchique : Le framework est organisé hiérarchiquement, avec des parties interconnectées à plusieurs niveaux, garantissant modularité et flexibilité dans le développement d’applications.

Bibliothèques open source

• langchain-core : Fournit les abstractions de base et le langage d’expression LangChain, servant de fondation au framework.
• langchain-community : Intègre des services tiers et étend les capacités de LangChain.
• Paquets partenaires : Des paquets légers comme langchain-openai et langchain-anthropic qui fournissent des intégrations spécifiques, améliorant la polyvalence du framework.
• langchain : Comprend des chaînes, des agents et des stratégies de récupération qui forment l’architecture cognitive d’une application.
• LangGraph : Un outil puissant pour construire des applications multi-acteurs avec état avec des LLM, utilisant un modèle basé sur un graphe pour les étapes, et pouvant être intégré ou utilisé indépendamment de LangChain.
• LangServe : Déploie les chaînes LangChain sous forme d’API REST, facilitant l’intégration avec des services web.
• LangSmith : Une plateforme de développement qui fournit une suite complète d’outils pour déboguer, tester, évaluer et surveiller les applications LLM.

Public et cas d’usage

LangChain est conçu pour les développeurs de tous niveaux, des débutants aux experts, qui souhaitent exploiter la puissance des LLM dans leurs applications. Son architecture modulaire et extensible le rend adapté à une large gamme de cas d’usage, notamment mais sans s’y limiter :

• Construction d’agents conversationnels et de chatbots.
• Développement d’outils de traduction et de résumé linguistique.
• Création de systèmes de génération et de classification de contenu.
• Implémentation de workflows complexes avec des LLM.

LlamaIndex vs LangChain : principales différences

Fonctionnalité principale :

• LangChain est un framework complet conçu pour simplifier la création d’applications conscientes des données et agentives avec les grands modèles de langage (LLM). Il offre une large gamme d’outils pour diverses applications basées sur les LLM, en mettant l’accent sur la flexibilité et les capacités avancées d’IA.
• LlamaIndex (anciennement GPT Index) est un framework de données spécifiquement axé sur l’ingestion, la structuration et l’accès aux données privées ou spécifiques à un domaine pour les LLM. Il simplifie l’indexation et la récupération d’informations, ce qui le rend parfait pour la recherche textuelle et la génération de réponses précises.

Cas d’usage :

• LangChain est polyvalent et peut être utilisé pour diverses applications telles que la génération de texte, la traduction linguistique, le résumé de texte et la classification de texte. Il est particulièrement adapté au maintien de conversations longues et contextuelles grâce à son excellente gestion de la mémoire et à ses capacités de chaînage.
• LlamaIndex excelle dans les scénarios où la recherche textuelle et des réponses de haute qualité sont les priorités absolues. Les cas d’usage courants incluent la génération de contenu, la recherche et la récupération de documents, l’augmentation des LLM pour les chatbots et les assistants virtuels.

Tarification et disponibilité :

• LangChain est un outil open source et gratuit, dont le code source est disponible en téléchargement sur des plateformes comme GitHub, ce qui le rend accessible à tous.
• LlamaIndex est un produit commercial, et son prix est déterminé par l’utilisation, ce qui signifie qu’il peut entraîner des coûts en fonction de l’ampleur de son utilisation dans les applications.

Personnalisation et flexibilité :

• LangChain offre des options de personnalisation avancées, ce qui le rend adapté aux développeurs qui ont besoin d’affiner leurs applications avec des exigences spécifiques.
• LlamaIndex fournit des fonctionnalités et des outils conviviaux qui facilitent l’intégration transparente de données privées ou spécifiques à un domaine dans les LLM, en mettant l’accent sur la simplicité d’utilisation et la gestion directe des données.

Gestion des données :

• LangChain est conçu pour fonctionner avec une variété de types et de sources de données, offrant des composants comme Schema pour l’organisation des données et Indexes pour une récupération efficace des informations.
• LlamaIndex met l’accent sur la capacité à composer un index à partir d’autres index, ce qui le rend très efficace pour les requêtes complexes et les workflows impliquant plusieurs sources de données.

Intégration :

• LangChain propose des intégrations avec des services tiers et peut être étendu avec des paquets partenaires pour des fournisseurs de LLM spécifiques.
• LlamaIndex offre des connecteurs de données pour une intégration transparente de diverses sources de données, améliorant la qualité et les performances des données.

LlamaIndex vs LangChain : Comparaison d’exemples pratiques

En référence à Ming sur Medium, voici quelques exemples pratiques comparant LlamaIndex à LangChain.

Créer un chatbot avec un LLM local

Les exemples de code montrent comment initialiser le LLM avec les deux frameworks et comment afficher le résultat d’une interaction de chat.

Code 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)

Code 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))

Construire un système RAG pour des fichiers locaux

Les extraits de code illustrent comment charger des données, créer un index et effectuer une requête.

Code 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)

Code 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?"))

De la comparaison, il semble que LlamaIndex, avec un accent sur les systèmes RAG, offre une approche plus simple tandis que LangChain propose une méthode plus abstraite et de haut niveau.

LlamaIndex vs LangChain : Comment utiliser un LLM personnalisé avec LlamaIndex ?

Pour intégrer l’API LLM de Novita AI avec LlamaIndex, vous devrez créer un adaptateur personnalisé qui encapsule les appels API de Novita AI dans le framework LlamaIndex. Voici un exemple conceptuel de la façon dont vous pourriez y parvenir. Veuillez noter que cet exemple suppose que vous avez une compréhension de base du fonctionnement des API et du framework LlamaIndex.

Étape 1 : Définir un adaptateur personnalisé pour le LLM Novita AI

Tout d’abord, définissons un adaptateur personnalisé pour le LLM 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

Étape 2 : Intégration au contexte de service LlamaIndex

Ensuite, vous devrez intégrer cet adaptateur dans le contexte de service LlamaIndex. Voici un exemple conceptuel de la façon dont vous pourriez procéder :

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)

Cet exemple montre comment créer un adaptateur personnalisé pour le LLM de Novita AI et l’intégrer dans le framework LlamaIndex. Vous devrez remplacer <YOUR Novita AI API Key> par votre vraie clé API provenant de Novita AI.

Veuillez noter qu’il s’agit d’un exemple conceptuel et qu’il peut nécessiter des ajustements pour correspondre aux versions spécifiques des bibliothèques que vous utilisez et aux détails exacts de l’API du LLM de Novita AI. Référez-vous toujours à la documentation officielle pour les informations les plus précises et à jour.

LlamaIndex vs LangChain : Comment utiliser un LLM personnalisé avec LangChain ?

Pour intégrer l’API LLM de Novita AI avec LangChain en utilisant un LLM personnalisé, vous devrez créer une classe personnalisée qui étend la classe LLM de LangChain et utilise l’API de Novita AI pour sa logique.

Voici un guide étape par étape pour y parvenir :

Étape 1 : Installer la bibliothèque Python OpenAI

Tout d’abord, assurez-vous d’avoir installé la bibliothèque OpenAI, qui sera utilisée pour interagir avec l’API de Novita AI.

pip install 'openai>=1.0.0'

Étape 2 : Importer les bibliothèques nécessaires

Importez les modules nécessaires de LangChain et de la bibliothèque 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

Étape 3 : Définir la classe LLM personnalisée

Étendez la classe LLM pour créer un LLM personnalisé qui utilise l’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"

Étape 4 : Initialiser et utiliser le LLM personnalisé

Créez une instance de votre LLM personnalisé avec votre clé API Novita AI et utilisez-la pour générer du texte.

# 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="")

Ce code configure un LLM personnalisé qui utilise l’API de Novita AI pour générer du texte à partir d’une invite donnée. La méthode _call est utilisée pour les réponses non streamées, et la méthode _stream pour les réponses streamées. Ajustez le model_name et les autres paramètres selon les besoins, en fonction de la documentation de l’API de Novita AI et de vos exigences spécifiques.

Conclusion

En conclusion, LlamaIndex et LangChain sont tous deux des outils précieux pour travailler avec les grands modèles de langage, chacun ayant ses propres forces. LlamaIndex excelle dans l’ingestion et la récupération de données, ce qui le rend idéal pour les projets nécessitant un traitement efficace de données spécifiques et des systèmes de question-réponse avancés. LangChain offre un framework plus complet pour développer et déployer des applications LLM, grâce à son architecture modulaire et ses nombreuses intégrations. Le choix entre les deux dépend des besoins spécifiques de votre projet.

FAQ

Peut-on utiliser LangChain et LlamaIndex ensemble ?

Oui. Cela dépend des besoins spécifiques de votre projet LLM.

LangChain est-il adapté à la production ?

Oui, LangChain 0.1 et les versions ultérieures sont prêts pour la production.

Lequel est le meilleur pour le RAG, LlamaIndex ou LangChain ?

LlamaIndex est recommandé si votre objectif principal est la récupération et les capacités de recherche de données. LangChain est mieux adapté aux scénarios où vous avez besoin d’un framework flexible capable de gérer des workflows complexes.

Novita AI est la plateforme cloud tout-en-un qui propulse vos ambitions en IA. API intégrées, serverless, GPU Instance — les outils rentables dont vous avez besoin. Éliminez l’infrastructure, commencez gratuitement et faites de votre vision IA une réalité.

Lectures recommandées

Comment créer votre LLM avec LangChain : un guide pas à pas

Maîtrisez le streaming avec LangChain : conseils pour interagir avec les LLM