Wichtige Highlights
- LlamaIndex: Spezialisiert auf Datenaufnahme, -strukturierung und Nutzung privater oder domänenspezifischer Daten für Aufgaben wie erweiterte Frage-Antwort-Systeme und Dokumentverständnis.
- LangChain: Bietet ein umfassendes Open-Source-Framework zur Entwicklung, Bereitstellung und Skalierung von Anwendungen mit LLMs und unterstützt verschiedene Anwendungsfälle, darunter Konversationsagenten, Übersetzung und komplexe Workflows.
- Benutzerdefinierte LLM-Integration: Bietet eine umfassende, schrittweise Code-Anleitung zur Implementierung benutzerdefinierter LLMs mit LlamaIndex- und LangChain-Frameworks und zeigt die jeweiligen Ansätze zur Integration und Nutzung externer APIs wie Novita AI.
Einleitung
In der sich schnell entwickelnden Landschaft der künstlichen Intelligenz und der natürlichen Sprachverarbeitung haben sich zwei Frameworks als leistungsstarke Werkzeuge für Entwickler herauskristallisiert, die mit Large Language Models (LLMs) arbeiten: LlamaIndex und LangChain. Dieser Blogbeitrag bietet einen umfassenden Vergleich von LlamaIndex vs. LangChain und erkundet deren Hauptmerkmale, Anwendungsfälle und praktische Anwendungen. Durch die Untersuchung der Kernfunktionen, Preismodelle und Integrationsmöglichkeiten jedes Frameworks vermitteln wir Ihnen das Wissen, um eine fundierte Entscheidung darüber zu treffen, welches Tool am besten zu Ihren spezifischen Anforderungen passt.
Was ist LlamaIndex?
LlamaIndex ist ein ausgeklügeltes Daten-Framework, das Large Language Models (LLMs) mit kontextuell relevanten, benutzerspezifischen Daten versorgt. Im Gegensatz zu universellen LLMs, die auf öffentlichen Daten vortrainiert sind, ermöglicht LlamaIndex diesen Modellen den Zugriff auf und die Nutzung privater, domänenspezifischer oder problemorientierter Daten, die oft hinter APIs, in Datenbanken oder in unstrukturierten Formaten wie PDFs verborgen sind.
Hauptmerkmale und Fähigkeiten
- Datenaufnahme: LlamaIndex bietet Datenkonnektoren, die Daten aus verschiedenen Quellen, einschließlich APIs, PDFs und SQL-Datenbanken, in ihrem nativen Format nahtlos aufnehmen.
- Datenstrukturierung: Es strukturiert aufgenommene Daten in Zwischenrepräsentationen um, die für eine effiziente Verarbeitung durch LLMs optimiert sind, und gewährleistet so hohe Leistung.
- Natürlicher Sprachzugriff: LlamaIndex bietet Engines, die einen natürlichen Sprachzugriff auf Daten ermöglichen, Frage-Antwort-Funktionen über Abfrage-Engines unterstützen und konversationelle Interaktionen über Chat-Engines ermöglichen.
- Wissensarbeiter: Das Framework enthält Agenten, die als LLM-gestützte Wissensarbeiter fungieren, erweitert durch eine Reihe von Werkzeugen, von einfachen Helfern bis hin zu komplexen API-Integrationen.
- Beobachtbarkeit und Bewertung: Es integriert Schnittstellen für rigorose Experimente, Bewertung und Überwachung, um einen kontinuierlichen Verbesserungszyklus für Anwendungen zu gewährleisten.
Anwendungsfälle
LlamaIndex unterstützt eine Vielzahl von Anwendungsfällen, wie z. B.:
- Retrieval-Augmented Generation (RAG) für fortschrittliche Frage-Antwort-Systeme.
- Chatbots, die sinnvolle, kontextbewusste Gespräche führen können.
- Dokumentverständnis und Datenextraktion aus unstrukturierten Dokumenten.
- Autonome Agenten, die in der Lage sind, Recherchen durchzuführen und Aktionen auszuführen.
- Multimodale Anwendungen, die Text mit Bildern und anderen Datentypen integrieren.
- Feinabstimmung von Modellen auf spezifische Daten zur Leistungssteigerung.
Was ist LangChain?
LangChain ist ein hochmodernes Framework, das speziell dafür entwickelt wurde, die Entwicklung, Produktionalisierung und Bereitstellung von Anwendungen zu optimieren, die von Large Language Models (LLMs) angetrieben werden. Es bietet eine umfassende Suite von Tools und Bibliotheken, die jede Phase des LLM-Anwendungslebenszyklus abdeckt und einen nahtlosen und effizienten Entwicklungsprozess gewährleistet.
Hauptmerkmale und Fähigkeiten
- Entwicklung: LangChain bietet Open-Source-Bausteine, Komponenten und Integrationen von Drittanbietern, die die Erstellung von LLM-Anwendungen vereinfachen. LangGraph, eine Schlüsselkomponente, ermöglicht die Erstellung zustandsbehafteter Agenten mit robuster Unterstützung für Streaming-Daten und Human-in-the-Loop-Workflows.
- Produktionalisierung: LangSmith ist ein leistungsstarkes Tool zur Inspektion, Überwachung und Bewertung der Leistung Ihrer LLM-Ketten. Es gewährleistet kontinuierliche Optimierung und vertrauensvolle Bereitstellung, indem es tiefe Einblicke in die Anwendungsleistung bietet.
- Bereitstellung: LangGraph Cloud ermöglicht die Umwandlung von LangGraph-Anwendungen in produktionsreife APIs und Assistenten, was die Skalierung und Integration von LLM-Anwendungen in verschiedene Systeme erleichtert.
- Hierarchische Organisation: Das Framework ist hierarchisch organisiert, mit miteinander verbundenen Teilen auf mehreren Ebenen, was Modularität und Flexibilität bei der Anwendungsentwicklung gewährleistet.
Open-Source-Bibliotheken
- langchain-core: Bietet grundlegende Abstraktionen und die LangChain Expression Language und dient als Fundament des Frameworks.
- langchain-community: Integriert Dienste von Drittanbietern und erweitert die Fähigkeiten von LangChain.
- Partnerpakete: Leichte Pakete wie langchain-openai und langchain-anthropic, die spezifische Integrationen bieten und die Vielseitigkeit des Frameworks erhöhen.
- langchain: Enthält Ketten, Agenten und Retrieval-Strategien, die die kognitive Architektur einer Anwendung bilden.
- LangGraph: Ein leistungsstarkes Tool zur Erstellung zustandsbehafteter Multi-Actor-Anwendungen mit LLMs, das ein grafenbasiertes Modell für Schritte verwendet und in LangChain integriert oder unabhängig davon verwendet werden kann.
- LangServe: Stellt LangChain-Ketten als REST-APIs bereit und erleichtert die Integration mit Webservices.
- LangSmith: Eine Entwicklerplattform, die eine umfassende Suite von Tools zum Debuggen, Testen, Bewerten und Überwachen von LLM-Anwendungen bereitstellt.
Zielgruppe und Anwendungsfälle
LangChain ist für Entwickler aller Erfahrungsstufen konzipiert, von Anfängern bis zu Experten, die die Leistungsfähigkeit von LLMs in ihren Anwendungen nutzen möchten. Seine modulare und erweiterbare Architektur macht es für eine breite Palette von Anwendungsfällen geeignet, darunter unter anderem:
- Erstellung von Konversationsagenten und Chatbots.
- Entwicklung von Sprachübersetzungs- und Zusammenfassungstools.
- Erstellung von Systemen zur Inhaltsgenerierung und -klassifizierung.
- Implementierung komplexer Workflows mit LLMs.
LlamaIndex vs. LangChain: Wichtige Unterschiede
Kernfunktionalität:
- LangChain ist ein umfassendes Framework, das die Erstellung datenbewusster und agentischer Anwendungen mit Large Language Models (LLMs) vereinfachen soll. Es bietet eine breite Palette von Werkzeugen für verschiedene LLM-gestützte Anwendungen, mit Fokus auf Flexibilität und erweiterte KI-Funktionen.
- LlamaIndex (früher bekannt als GPT Index) ist ein Daten-Framework, das sich speziell auf die Aufnahme, Strukturierung und den Zugriff auf private oder domänenspezifische Daten für LLMs konzentriert. Es vereinfacht die Indizierung und den Abruf von Informationen und ist daher perfekt für textbasierte Suche und die Generierung genauer Antworten geeignet.
Anwendungsfälle:
- LangChain ist vielseitig und kann für verschiedene Anwendungen wie Textgenerierung, Sprachübersetzung, Textzusammenfassung und Textklassifizierung verwendet werden. Es eignet sich besonders gut für die Aufrechterhaltung langer und kontextuell relevanter Gespräche aufgrund seiner hervorragenden Speicherverwaltung und Kettenfähigkeiten.
- LlamaIndex zeichnet sich in Szenarien aus, in denen Textsuche und qualitativ hochwertige Antworten oberste Priorität haben. Häufige Anwendungsfälle umfassen Inhaltsgenerierung, Dokumentsuche und -abruf, LLM-Erweiterung für Chatbots und virtuelle Assistenten.
Preisgestaltung und Verfügbarkeit:
- LangChain ist ein Open-Source- und kostenloses Tool, dessen Quellcode auf Plattformen wie GitHub heruntergeladen werden kann, sodass es für jedermann zugänglich ist.
- LlamaIndex ist ein kommerzielles Produkt, dessen Preis sich nach der Nutzung richtet, was bedeutet, dass Kosten basierend auf dem Umfang der Nutzung in Anwendungen anfallen können.
Anpassung und Flexibilität:
- LangChain bietet erweiterte Anpassungsoptionen und eignet sich daher für Entwickler, die ihre Anwendungen mit spezifischen Anforderungen feinabstimmen müssen.
- LlamaIndex bietet benutzerfreundliche Funktionen und Tools, die die nahtlose Integration privater oder domänenspezifischer Daten in LLMs erleichtern, mit Fokus auf Benutzerfreundlichkeit und unkompliziertes Datenmanagement.
Datenhandhabung:
- LangChain ist darauf ausgelegt, mit verschiedenen Datentypen und -quellen zu arbeiten, und bietet Komponenten wie Schema zur Datenorganisation und Indizes für effizienten Informationsabruf.
- LlamaIndex betont die Fähigkeit, einen Index aus anderen Indizes zu erstellen, was es besonders effektiv für komplexe Abfragen und Workflows mit mehreren Datenquellen macht.
Integration:
- LangChain bietet Integrationen mit Drittanbieterdiensten und kann mit Partnerpaketen für spezifische LLM-Anbieter erweitert werden.
- LlamaIndex bietet Datenkonnektoren für die nahtlose Integration verschiedener Datenquellen, wodurch Datenqualität und Leistung verbessert werden.
LlamaIndex vs. LangChain: Vergleich praktischer Beispiele
In Anlehnung an Ming on Medium finden Sie hier einige praktische Beispiele, die LlamaIndex mit LangChain vergleichen.
Erstellen eines Chatbots mit einem lokalen LLM
Die Codebeispiele zeigen, wie das LLM mit beiden Frameworks initialisiert wird und wie die Ausgabe einer Chat-Interaktion ausgegeben wird.
LlamaIndex-Code:
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)
LangChain-Code:
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))
Aufbau eines RAG-Systems für lokale Dateien
Die Codeausschnitte veranschaulichen das Laden von Daten, das Erstellen eines Index und das Durchführen einer Abfrage.
LlamaIndex-Code:
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)
LangChain-Code:
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?"))
Aus dem Vergleich wird deutlich, dass LlamaIndex mit seinem Fokus auf RAG-Systeme einen einfacheren Ansatz bietet, während LangChain eine abstraktere, übergeordnete Methode bereitstellt.
LlamaIndex vs. LangChain: Wie verwende ich ein benutzerdefiniertes LLM mit LlamaIndex?
Um die Novita AI LLM API in LlamaIndex zu integrieren, müssen Sie einen benutzerdefinierten Adapter erstellen, der die Novita AI API-Aufrufe innerhalb des LlamaIndex-Frameworks kapselt. Nachfolgend finden Sie ein konzeptionelles Beispiel, wie Sie dies erreichen können. Beachten Sie, dass dieses Beispiel Grundkenntnisse im Umgang mit APIs und dem LlamaIndex-Framework voraussetzt.
Schritt 1: Definieren Sie einen benutzerdefinierten Adapter für das Novita AI LLM
Definieren wir zunächst einen benutzerdefinierten Adapter für das Novita AI LLM:
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
Schritt 2: Integration in den LlamaIndex-Servicekontext
Als nächstes müssten Sie diesen Adapter in den LlamaIndex-Servicekontext integrieren. Hier ist ein konzeptionelles Beispiel, wie Sie das tun könnten:
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)
Dieses Beispiel zeigt, wie Sie einen benutzerdefinierten Adapter für das LLM von Novita AI erstellen und in das LlamaIndex-Framework integrieren. Sie müssen
Bitte beachten Sie, dass es sich um ein konzeptionelles Beispiel handelt, das möglicherweise Anpassungen erfordert, um den spezifischen Versionen der von Ihnen verwendeten Bibliotheken und den genauen API-Details des Novita AI LLM zu entsprechen. Konsultieren Sie stets die offizielle Dokumentation für die genauesten und aktuellsten Informationen.
LlamaIndex vs. LangChain: Wie verwende ich ein benutzerdefiniertes LLM mit LangChain?
Um die Novita AI LLM API mit LangChain unter Verwendung eines benutzerdefinierten LLM zu integrieren, müssen Sie eine benutzerdefinierte Klasse erstellen, die die LLM-Klasse von LangChain erweitert und die API von Novita AI für ihre Logik verwendet.
Hier ist eine Schritt-für-Schritt-Anleitung, wie das geht:
Schritt 1: Installieren Sie die OpenAI Python-Bibliothek
Stellen Sie zunächst sicher, dass die OpenAI-Bibliothek installiert ist, die für die Interaktion mit der Novita AI API verwendet wird.
pip install 'openai>=1.0.0'
Schritt 2: Erforderliche Bibliotheken importieren
Importieren Sie die erforderlichen Module aus LangChain und der OpenAI-Bibliothek.
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
Schritt 3: Definieren Sie die benutzerdefinierte LLM-Klasse
Erweitern Sie die LLM-Klasse, um ein benutzerdefiniertes LLM zu erstellen, das die Novita AI API verwendet.
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"
Schritt 4: Benutzerdefiniertes LLM initialisieren und verwenden
Erstellen Sie eine Instanz Ihres benutzerdefinierten LLM mit Ihrem Novita AI API-Schlüssel und verwenden Sie es zur Textgenerierung.
# 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="")
Dieser Code richtet ein benutzerdefiniertes LLM ein, das die Novita AI API zur Textgenerierung basierend auf einer gegebenen Eingabeaufforderung verwendet. Die Methode _call wird für nicht-streaming-Antworten verwendet, und die Methode _stream für streaming-Antworten. Passen Sie model_name und andere Parameter nach Bedarf basierend auf der API-Dokumentation von Novita AI und Ihren spezifischen Anforderungen an.
Fazit
Zusammenfassend sind LlamaIndex und LangChain beide wertvolle Werkzeuge für die Arbeit mit Large Language Models, jedes mit seinen eigenen Stärken. LlamaIndex zeichnet sich durch Datenaufnahme und -abruf aus und ist ideal für Projekte, die eine effiziente Handhabung spezifischer Daten und erweiterte Frage-Antwort-Systeme erfordern. LangChain bietet ein umfassenderes Framework für die Entwicklung und Bereitstellung von LLM-Anwendungen mit seiner modularen Architektur und umfangreichen Integrationen. Die Wahl zwischen den beiden hängt von den spezifischen Anforderungen Ihres Projekts ab.
FAQs
Können LangChain und LlamaIndex zusammen verwendet werden?
Ja. Das hängt von den spezifischen Anforderungen Ihres LLM-Projekts ab.
Ist LangChain für die Produktion geeignet?
Ja, LangChain 0.1 und spätere Versionen sind produktionsreif.
Welches ist besser für RAG: LlamaIndex oder LangChain?
LlamaIndex wird empfohlen, wenn Ihr Hauptaugenmerk auf Datenabruf- und Suchfunktionen liegt. LangChain eignet sich besser für Szenarien, in denen Sie ein flexibles Framework benötigen, das komplexe Workflows verarbeiten kann.
Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen unterstützt. Integrierte APIs, Serverless, GPU-Instanzen – die kostengünstigen Tools, die Sie brauchen. Vermeiden Sie Infrastrukturaufwand, starten Sie kostenlos und verwirklichen Sie Ihre KI-Vision.
Empfohlene Lektüre
So erstellen Sie Ihr LLM mit LangChain: Eine Schritt-für-Schritt-Anleitung
Master Streaming LangChain: Tipps für die Interaktion mit LLMs
