Einführung in LangChain.js: Praktische LLM-Anwendungen erstellen
Von Jake Morrison LangChain.js ist ein solches Werkzeug. Es bietet einen strukturierten Ansatz, um Anwendungen zu erstellen, die von großen Sprachmodellen (LLMs) angetrieben werden, unter Verwendung von JavaScript oder TypeScript. Wenn Sie mit LLMs im JavaScript-Ökosystem arbeiten, ist das Verständnis von LangChain.js ein Muss. Dieser Leitfaden führt Sie durch praktische, umsetzbare Schritte, um zu beginnen und echte Anwendungen zu erstellen.
Was ist LangChain.js und warum sollten Sie es verwenden?
LangChain.js ist eine Bibliothek, die Entwicklern hilft, LLM-gestützte Anwendungen zu erstellen. Es ersetzt die LLMs nicht selbst, sondern bietet eine Abstraktionsschicht und eine Reihe von Werkzeugen, um verschiedene LLM-Aufrufe zu verketten, mit anderen Datenquellen zu integrieren und komplexe Interaktionen zu verwalten.
Denken Sie so darüber nach: Ein direktes Aufrufen einer LLM-API ist wie die Verwendung einer rohen Datenbankabfrage. LangChain.js bietet ein ORM (Object-Relational Mapper) für LLMs. Es behandelt häufige Muster wie:
* **Ketten:** Mehrere LLM-Aufrufe oder andere Schritte zu einer Sequenz kombinieren.
* **Eingabeaufforderungen:** Eingaben für LLMs verwalten und formatieren.
* **Agenten:** LLMs Entscheidungen treffen und Werkzeuge verwenden lassen.
* **Abruf:** Externe Daten (Ihre Dokumente, Datenbanken) mit LLMs integrieren.
* **Speicher:** LLMs eine Möglichkeit geben, sich an vergangene Interaktionen zu erinnern.
Der Hauptvorteil von LangChain.js ist die erhöhte Produktivität und Wartbarkeit. Sie schreiben weniger Boilerplate-Code, Ihre Anwendungslogik wird klarer und es ist einfacher, LLM-Anbieter auszutauschen oder neue Funktionen hinzuzufügen. Für alle, die mit LLMs in JavaScript arbeiten, bietet LangChain.js erhebliche Vorteile.
Einrichtung Ihres LangChain.js-Projekts
Bevor wir mit dem Schreiben von Code beginnen, lassen Sie uns unsere Umgebung vorbereiten. Sie benötigen Node.js.
1. **Erstellen Sie ein neues Projektverzeichnis:**
„`bash
mkdir langchain-js-project
cd langchain-js-project
„`
2. **Initialisieren Sie ein Node.js-Projekt:**
„`bash
npm init -y
„`
3. **Installieren Sie LangChain.js und einen LLM-Anbieter:**
Wir beginnen mit OpenAI für unsere Beispiele, aber LangChain.js unterstützt viele weitere (Hugging Face, Google usw.).
„`bash
npm install langchain @openai/openai
„`
Wenn Sie TypeScript bevorzugen:
„`bash
npm install langchain @openai/openai typescript @types/node ts-node
npx tsc –init
„`
Dann aktualisieren Sie `tsconfig.json`, um `„moduleResolution“: „node“` und `„esModuleInterop“: true` einzuschließen.
4. **Richten Sie Ihren API-Schlüssel ein:**
Sie benötigen einen OpenAI-API-Schlüssel. Hardcoden Sie niemals API-Schlüssel in Ihrem Code. Verwenden Sie Umgebungsvariablen.
Erstellen Sie eine `.env`-Datei im Stammverzeichnis Ihres Projekts:
„`
OPENAI_API_KEY=YOUR_OPENAI_API_KEY
„`
Um Umgebungsvariablen zu laden, installieren Sie `dotenv`:
„`bash
npm install dotenv
„`
Dann, ganz oben in Ihrem Hauptskript (z.B. `index.js` oder `src/index.ts`):
„`javascript
require(‘dotenv’).config();
„`
oder für TypeScript/ESM:
„`typescript
import ‘dotenv/config’;
„`
Jetzt sind Sie bereit, mit LangChain.js zu arbeiten.
Ihr erster LLM-Aufruf mit LangChain.js
Lassen Sie uns einen einfachen Aufruf an ein LLM machen.
„`javascript
// index.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
async function simpleLLMCall() {
const model = new OpenAI({ temperature: 0.7 }); // temperature steuert die Zufälligkeit
const prompt = „Was ist die Hauptstadt von Frankreich?“;
const result = await model.call(prompt);
console.log(result);
}
simpleLLMCall();
„`
Um dies auszuführen: `node index.js`.
Sie sollten „Paris.“ oder eine ähnliche Ausgabe sehen. Dies ist die grundlegendste Interaktion. LangChain.js umschließt den OpenAI-API-Aufruf und macht ihn konsistent mit anderen LLM-Anbietern.
Arbeiten mit Eingabeaufforderungen: Vorlagen und Variablen
Direktes Einbetten von Eingabeaufforderungen in Ihren Code kann unordentlich werden. LangChain.js bietet `PromptTemplate`, um Eingabeaufforderungen effektiv zu verwalten.
„`javascript
// promptExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
async function templatedPrompt() {
const model = new OpenAI({ temperature: 0.7 });
const template = „Was ist ein guter Name für ein Unternehmen, das {product} herstellt?“;
const prompt = new PromptTemplate({
template: template,
inputVariables: [„product“],
});
const formattedPrompt = await prompt.format({ product: „bunte Socken“ });
console.log(„Formatierte Eingabeaufforderung:“, formattedPrompt);
const result = await model.call(formattedPrompt);
console.log(„LLM Ergebnis:“, result);
}
templatedPrompt();
„`
Führen Sie dies mit `node promptExample.js` aus.
Dies zeigt, wie `PromptTemplate` es Ihnen ermöglicht, Eingabeaufforderungen mit Platzhaltern (`{product}`) zu definieren, die Sie dynamisch ausfüllen können. Dies ist entscheidend für den Aufbau flexibler Anwendungen.
Ketten: LLM-Aufrufe und Logik verbinden
Ketten sind der Bereich, in dem LangChain.js wirklich glänzt. Sie ermöglichen es Ihnen, mehrere Schritte, einschließlich LLM-Aufrufen, in einen einzigen, kohärenten Workflow zu kombinieren.
Einfache LLM-Kette
Die `LLMChain` ist die einfachste Kette. Sie nimmt eine `PromptTemplate` und ein LLM, formatiert dann die Eingabeaufforderung und übergibt sie an das LLM.
„`javascript
// llmChainExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
const { LLMChain } = require(‘langchain/chains’);
async function simpleLLMChain() {
const model = new OpenAI({ temperature: 0.7 });
const template = „Was ist die beste {activity}, die man in {city} machen kann?“;
const prompt = new PromptTemplate({
template: template,
inputVariables: [„activity“, „city“],
});
const chain = new LLMChain({ llm: model, prompt: prompt });
const result = await chain.call({ activity: „Essen“, city: „Rom“ });
console.log(„Kettenergebnis:“, result);
// Das Ergebnisobjekt enthält eine ‘text’-Eigenschaft mit der Ausgabe des LLM.
}
simpleLLMChain();
„`
Führen Sie mit `node llmChainExample.js` aus.
Beachten Sie, wie `chain.call()` ein Objekt mit den Eingangsvariablen übernimmt und die Eingabeaufforderung formatiert und den LLM aufruft. Dies ist eine sauberere Methode, um mit Ihrem LLM zu interagieren.
Sequenzielle Ketten: Mehrschritt-Workflows
Manchmal müssen Sie mehrere LLM-Aufrufe in einer Reihenfolge durchführen, wobei die Ausgabe eines Aufrufs die Eingabe für den nächsten wird. Hier kommt `SimpleSequentialChain` ins Spiel.
„`javascript
// sequentialChainExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { PromptTemplate } = require(‘langchain/prompts’);
const { LLMChain, SimpleSequentialChain } = require(‘langchain/chains’);
async function multiStepChain() {
const model = new OpenAI({ temperature: 0.7 });
// Kette 1: Erzeuge einen Firmennamen
const nameTemplate = „Was ist ein guter Name für ein Unternehmen, das {product} herstellt?“;
const namePrompt = new PromptTemplate({
template: nameTemplate,
inputVariables: [„product“],
});
const nameChain = new LLMChain({ llm: model, prompt: namePrompt });
// Kette 2: Beschreibe das Unternehmen
const descriptionTemplate = „Schreibe einen kurzen, ansprechenden Werbeslogan für ein Unternehmen mit dem Namen {companyName}.“;
const descriptionPrompt = new PromptTemplate({
template: descriptionTemplate,
inputVariables: [„companyName“],
});
const descriptionChain = new LLMChain({ llm: model, prompt: descriptionPrompt });
// Kombiniere sie in einer sequentiellen Kette
const overallChain = new SimpleSequentialChain({
chains: [nameChain, descriptionChain],
verbose: true, // Setzen Sie auf true, um Zwischensteps zu sehen
});
const result = await overallChain.run(„umweltfreundliche Schuhe“);
console.log(„Gesamtergebnis:“, result);
}
multiStepChain();
„`
Führen Sie mit `node sequentialChainExample.js` aus.
Die `SimpleSequentialChain` übernimmt die Ausgabe von `nameChain` und verwendet sie automatisch als Eingabe (`companyName`) für `descriptionChain`. Dieses Muster ist äußerst leistungsfähig, um komplexe Aufgaben zu zerlegen. LangChain.js macht dies einfach.
Abrufunterstützte Generierung (RAG): Verwenden Sie Ihre eigenen Daten
LLMs sind leistungsfähig, aber ihr Wissen ist auf ihre Trainingsdaten beschränkt. Für Anwendungen, die aktuelle Informationen oder spezifisches Fachwissen benötigen (z. B. die Dokumente Ihres Unternehmens), müssen Sie das Wissen des LLM mit externen Daten erweitern. Dies nennt man abrufunterstützte Generierung (RAG).
Die Grundidee von RAG ist:
1. **Daten laden:** Holen Sie sich Ihre Dokumente (PDFs, Textdateien, Webseiten).
2. **Daten aufteilen:** Zerlegen Sie große Dokumente in kleinere, handhabbare Teile.
3. **Daten einbetten:** Konvertieren Sie diese Teile in numerische Darstellungen (Embeddings) mit einem Einbettungsmodell.
4. **Daten speichern:** Speichern Sie diese Embeddings in einer Vektordatenbank.
5. **Abrufen:** Wenn ein Benutzer eine Frage stellt, betten Sie die Frage ein und suchen Sie in der Vektordatenbank nach ähnlichen Dokumentteilen.
6. **Prompt erweitern:** Fügen Sie diese abgerufenen Teile zum LLM-Prompt hinzu.
7. **Generieren:** Das LLM verwendet diesen erweiterten Prompt, um eine informiertere Antwort zu generieren.
LangChain.js bietet Komponenten für jeden dieser Schritte.
Schritt 1: Dokumente laden
LangChain.js hat verschiedene Dokumentenlader. Lassen Sie uns einen `TextLoader` verwenden.
“`javascript
// ragExample.js – Teil 1: Dokumentenladen
require(‘dotenv’).config();
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
async function loadDocuments() {
// Erstellen Sie eine Dummy-Textdatei zur Demonstration
const fs = require(‘fs’);
fs.writeFileSync(‘my_document.txt’, `
Der schnelle braune Fuchs springt über den faulen Hund.
Dieses Dokument spricht über verschiedene Tiere und deren Verhaltensweisen.
Hunde sind bekannt für ihre Loyalität und Verspieltsein.
Füchse sind listige und einsame Kreaturen.
Katzen genießen es zu schlafen und Mäuse zu jagen.
`);
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
console.log(“Geladene Dokumente:”, docs);
// Jedes Dokument hat pageContent und Metadaten
}
loadDocuments();
“`
Schritt 2: Dokumente aufteilen
Große Dokumente müssen in kleinere Teile unterteilt werden, damit sie im Kontextfenster des LLMs passen und um die Relevanz des Abrufs zu verbessern.
“`javascript
// ragExample.js – Teil 2: Aufteilen
require(‘dotenv’).config();
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
const { RecursiveCharacterTextSplitter } = require(‘langchain/text_splitter’);
async function splitDocuments() {
// (Angenommen, my_document.txt wurde bereits in Teil 1 erstellt)
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
chunkSize: 100, // Maximalzeichen pro Teil
chunkOverlap: 20, // Überlappung zwischen den Teilen, um den Kontext zu erhalten
});
const splitDocs = await splitter.splitDocuments(docs);
console.log(“Geteilte Dokumente:”, splitDocs);
}
splitDocuments();
“`
Schritt 3 & 4: Einbetten und Speichern von Dokumenten (Vektorspeicher)
Hier kommen die Embeddings und Vektordatenbanken ins Spiel. Wir verwenden OpenAI-Embeddings und `HNSWLib` (einen lokalen, im Speicher befindlichen Vektorspeicher) zur Vereinfachung. In der Produktion würden Sie eine spezielle Vektordatenbank wie Pinecone, Chroma, Weaviate usw. verwenden.
“`javascript
// ragExample.js – Teil 3: Embeddings und Vektorspeicher
require(‘dotenv’).config();
const { OpenAIEmbeddings } = require(‘langchain/embeddings/openai’);
const { HNSWLib } = require(‘langchain/vectorstores/hnswlib’);
const { RecursiveCharacterTextSplitter } = require(‘langchain/text_splitter’);
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
const { OpenAI } = require(‘langchain/llms/openai’);
const { RetrievalQAChain } = require(‘langchain/chains’);
async function ragApplication() {
// 1. Dokumente laden und aufteilen
const fs = require(‘fs’);
fs.writeFileSync(‘my_document.txt’, `
Der schnelle braune Fuchs springt über den faulen Hund.
Dieses Dokument spricht über verschiedene Tiere und deren Verhaltensweisen.
Hunde sind bekannt für ihre Loyalität und Verspieltsein.
Füchse sind listige und einsame Kreaturen.
Katzen genießen es zu schlafen und Mäuse zu jagen.
Eine Gruppe von Katzen wird als Clowder bezeichnet.
`);
const loader = new TextLoader(“my_document.txt”);
const rawDocs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
chunkSize: 100,
chunkOverlap: 20,
});
const docs = await splitter.splitDocuments(rawDocs);
// 2. Embeddings erstellen und im Vektorspeicher speichern
const embeddings = new OpenAIEmbeddings();
const vectorStore = await HNSWLib.fromDocuments(docs, embeddings);
// 3. Einen Retriever erstellen
const retriever = vectorStore.asRetriever();
// 4. Die Retrieval QA Chain erstellen
const model = new OpenAI({ temperature: 0 });
const chain = RetrievalQAChain.fromLLM(model, retriever);
// 5. Eine Frage stellen
const question = “Wie nennt man eine Gruppe von Katzen?”;
const result = await chain.call({ query: question });
console.log(“RAG Antwort:”, result.text);
const anotherQuestion = “Erzählen Sie mir von Füchsen.”;
const anotherResult = await chain.call({ query: anotherQuestion });
console.log(“Eine andere RAG Antwort:”, anotherResult.text);
}
ragApplication();
“`
Führen Sie es mit `node ragExample.js` aus.
Dieses Beispiel bündelt alle RAG-Elemente. Die `RetrievalQAChain` abstrahiert den Prozess des Abrufs relevanter Dokumente und deren Verwendung zur Beantwortung einer Frage. Dies ist eine praktische Methode, um Chatbots oder Frage-Antwort-Systeme über Ihre spezifischen Daten mit LangChain.js zu erstellen.
Agenten: LLMs, die Werkzeuge verwenden
Agenten erlauben es LLMs, Entscheidungen darüber zu treffen, welche Werkzeuge verwendet werden sollen und in welcher Reihenfolge, basierend auf den Eingaben des Benutzers. Dies ermöglicht dynamischere und komplexere Interaktionen. Werkzeuge können alles sein: eine Suchmaschine, ein Rechner, ein API-Aufruf an Ihre internen Systeme oder sogar eine andere LLM-Kette.
Lassen Sie uns einen einfachen Agenten erstellen, der Berechnungen mit einem `Calculator`-Werkzeug ausführen kann.
“`javascript
// agentExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { initializeAgentExecutorWithOptions } = require(‘langchain/agents’);
const { Calculator } = require(‘langchain/tools/calculator’);
async function runAgent() {
const model = new OpenAI({ temperature: 0 });
const tools = [new Calculator()];
// Initialisieren Sie den Agenten-Executor
const executor = await initializeAgentExecutorWithOptions(tools, model, {
agentType: “openai-functions”, // Verwenden Sie die Funktionaufruf-Funktion von OpenAI
verbose: true, // Sehen Sie den Denkprozess des Agenten
});
console.log(“Agent mit einer einfachen Mathefrage aufrufen…”);
const result1 = await executor.call({ input: “Was ist 123 plus 456?” });
console.log(“Agent Ergebnis 1:”, result1.output);
console.log(“\nAgent mit einer komplexeren Frage aufrufen…”);
const result2 = await executor.call({ input: “Was ist die Quadratwurzel von 625 multipliziert mit 3?” });
console.log(“Agent Ergebnis 2:”, result2.output);
}
runAgent();
“`
Führen Sie es mit `node agentExample.js` aus.
Mit `verbose: true` sehen Sie die “Gedanken” des Agenten: Er erkennt, dass eine Berechnung erforderlich ist, verwendet das `Calculator`-Werkzeug und gibt dann die Antwort. Dies ist ein leistungsfähiges Muster zum Erstellen von Anwendungen, die über einfache Textgenerierung hinausgehen. LangChain.js vereinfacht die Einrichtung dieser Agenten.
Speicher: Aufrechterhaltung des Gesprächs-Kontexts
Standardmäßig sind LLMs zustandslos. Jeder API-Aufruf ist unabhängig. Für konversationelle Anwendungen muss das LLM sich an frühere Interaktionen erinnern. LangChain.js bietet verschiedene Speichermöglichkeiten, um dies zu erreichen.
`ConversationBufferMemory` ist eine gängige Wahl, die die Rohgeschichte des Gesprächs speichert.
“`javascript
// memoryExample.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
const { ConversationChain } = require(‘langchain/chains’);
const { ConversationBufferMemory } = require(‘langchain/memory’);
async function conversationalApp() {
const model = new OpenAI({ temperature: 0.7 });
const memory = new ConversationBufferMemory();
const chain = new ConversationChain({ llm: model, memory: memory });
console.log(“Gespräch beginnt…”);
let result1 = await chain.call({ input: “Hallo, mein Name ist Jake.” });
console.log(“Benutzer: Hallo, mein Name ist Jake.”);
console.log(“KI:”, result1.response);
let result2 = await chain.call({ input: “Wie heiße ich?” });
console.log(“Benutzer: Wie heiße ich?”);
console.log(“KI:”, result2.response);
let result3 = await chain.call({ input: “Erzähl mir einen interessanten Fakt über JavaScript.” });
console.log(“Benutzer: Erzähl mir einen interessanten Fakt über JavaScript.”);
console.log(“KI:”, result3.response);
}
conversationalApp();
“`
Führen Sie es mit `node memoryExample.js` aus.
Der `ConversationBufferMemory` speichert die Chat-Historie und ermöglicht es dem LLM, die Frage “Wie heiße ich?” basierend auf dem vorherigen Gespräch korrekt zu beantworten. LangChain.js bietet weitere Gedächtnisarten für fortgeschrittene Anwendungsfälle, wie das Zusammenfassen von Gesprächen oder das Speichern nur bestimmter Teile.
Praktische Tipps für die Entwicklung mit LangChain.js
1. **Einfach anfangen:** Versuche nicht, sofort einen komplexen Agenten mit mehreren Tools und Gedächtnis zu erstellen. Beginne mit einfachen LLM-Aufrufen und `LLMChain`.
2. **`verbose: true` verwenden:** Bei der Fehlersuche von Ketten oder Agenten ist das Setzen von `verbose: true` von unschätzbarem Wert. Es zeigt die Zwischensteps, die versendeten Eingabeaufforderungen und die erhaltenen Antworten, was dir hilft zu verstehen, warum deine Kette möglicherweise nicht wie erwartet funktioniert.
3. **API-Schlüssel sicher verwalten:** Verwende immer Umgebungsvariablen für deine API-Schlüssel. Niemals in die Versionskontrolle einpflegen.
4. **Kontextfenster verstehen:** Achte auf die Tokenlimits deines gewählten LLM. Lange Eingabeaufforderungen, umfangreiche Gesprächshistorien oder viele abgerufene Dokumente können diese Grenzen schnell überschreiten. LangChain.js bietet Werkzeuge zur Verwaltung dessen, aber es ist wichtig, sich dessen bewusst zu sein.
5. **Mit `temperature` experimentieren:** Der Parameter `temperature` steuert die Zufälligkeit der Ausgaben des LLM. Höhere Werte (z.B. 0.7-1.0) führen zu kreativeren, weniger deterministischen Antworten. Niedrigere Werte (z.B. 0.0-0.3) sind sachbezogener und konsistenter. Passe dies basierend auf den Bedürfnissen deiner Anwendung an.
6. **Dokumentation erkunden:** Die LangChain.js-Dokumentation ist umfassend. Wenn du nach einem speziellen Lader, einer Kette oder einem Tool suchst, ist die Wahrscheinlichkeit hoch, dass es dort behandelt wird.
7. **Produktions-Vektor-Datenbanken in Betracht ziehen:** Für reale RAG-Anwendungen ersetze `HNSWLib` durch eine persistente Vektor-Datenbank wie Pinecone, Chroma oder Weaviate. Damit kannst du skalieren und große Datenmengen speichern.
8. **Fehlerbehandlung:** Implementiere eine solide Fehlerbehandlung für API-Aufrufe, insbesondere in Produktionsumgebungen. Netzwerkprobleme, Ratenlimits oder ungültige Eingaben können zu Fehlern führen.
Häufig gestellte Fragen zu LangChain.js
Q1: Ist LangChain.js nur für OpenAI-Modelle?
Nein, LangChain.js unterstützt eine breite Palette von LLM-Anbietern, darunter OpenAI, Hugging Face-Modelle (über `HuggingFaceHub` oder `HuggingFaceInference`), Google (z.B. `GoogleGenerativeAI`), Anthropic und viele mehr. Die zentralen Abstraktionen von LangChain.js ermöglichen es dir, LLM-Anbieter mit minimalen Codeänderungen auszutauschen.
Q2: Was ist der Unterschied zwischen `model.call()` und `chain.call()` oder `chain.run()`?
`model.call()` ist der direkteste Weg, mit einer einzelnen LLM-Instanz zu interagieren, indem eine rohe Eingabeaufforderung übergeben wird. `chain.call()` wird für Ketten verwendet und nimmt ein Objekt mit Eingabevariablen an (die dann von einem `PromptTemplate` formatiert werden, wenn sie innerhalb der Kette verwendet werden). `chain.run()` ist eine praktische Methode für Ketten, die nur eine einzige Eingabevariable haben und direkt den Ausgabe-Text zurückgeben. Für komplexere Ketten mit mehreren Eingaben/Ausgaben wird `chain.call()` bevorzugt.
Q3: Wie kann ich LangChain.js mit meiner bestehenden Datenbank oder API integrieren?
Du kannst LangChain.js mit deinen bestehenden Systemen integrieren, indem du benutzerdefinierte Tools für Agenten erstellst. Ein Tool ist im Grunde eine Funktion, die einen Eingabestring annimmt und einen Ausgabestring zurückgibt. Du kannst ein Tool definieren, das deine Datenbank abfragt, eine interne API aufruft oder eine andere benutzerdefinierte Logik ausführt und dann dieses Tool deinem LangChain.js-Agenten zur Verfügung stellen. Für RAG kannst du benutzerdefinierte `DocumentLoader`-Implementierungen erstellen, um Daten aus deinen spezifischen Datenquellen zu laden.
Q4: Wann sollte ich LangChain.js verwenden, anstatt LLM-APIs direkt aufzurufen?
Verwende LangChain.js, wenn du Anwendungen erstellen möchtest, die mehr als nur einen einzelnen, isolierten LLM-Aufruf umfassen. Wenn deine Anwendung Folgendes erfordert:
* Mehrstufiges Denken (Ketten).
* Integration externer Daten (RAG).
* Zugang des LLM zu externen Tools (Agenten).
* Verwaltung der Gesprächshistorie (Gedächtnis).
* Einfachen Austausch von LLM-Anbietern.
* Strukturierten und wartbaren Code.
Wenn du nur eine einmalige Eingabe zur Testzwecken machst, könnten direkte API-Aufrufe einfacher sein, aber für jede praktische Anwendung wird LangChain.js schnell unverzichtbar.
Fazit
LangChain.js ist ein leistungsstarkes Framework zum Erstellen komplexer LLM-Anwendungen in JavaScript und TypeScript. Durch das Verständnis seiner Kernkomponenten—LLMs, Eingabeaufforderungen, Ketten, Retrieval, Agenten und Gedächtnis kannst du intelligente Systeme konstruieren, die über einfache Texterzeugung hinausgehen. Dieser Leitfaden bietet einen praktischen, umsetzbaren Einstiegspunkt. Von einfachen LLM-Aufrufen bis hin zu komplexen RAG-Pipelines und Agenten bietet LangChain.js die Werkzeuge, um deine Ideen zur KI-Automatisierung zum Leben zu erwecken. Beginne mit Experimenten, baue kleine Projekte, und du wirst schnell das Potenzial von LangChain.js in deinem Entwicklungsworkflow entdecken.
🕒 Published: