Mit LangChain.js anfangen: Praktische LLM-Anwendungen erstellen
Von Jake Morrison LangChain.js ist eines dieser Werkzeuge. Es bietet eine strukturierte Möglichkeit, Anwendungen zu erstellen, die von großen Sprachmodellen (LLMs) angetrieben werden, indem es JavaScript oder TypeScript verwendet. Wenn Sie mit LLMs im JavaScript-Ökosystem arbeiten, ist es wichtig, LangChain.js zu verstehen. Dieser Leitfaden wird Sie durch praktische und konkrete Schritte führen, um zu beginnen und echte Anwendungen zu erstellen.
Was ist LangChain.js und warum sollte man es verwenden?
LangChain.js ist eine Bibliothek, die entwickelt wurde, um Entwicklern zu helfen, Anwendungen zu erstellen, die von LLMs angetrieben werden. Sie ersetzt nicht die LLMs selbst, sondern bietet eine Abstraktionsschicht und eine Reihe von Werkzeugen, um verschiedene LLM-Aufrufe zu verknüpfen, andere Datenquellen zu integrieren und komplexe Interaktionen zu verwalten.
Denken Sie daran, dass das direkte Aufrufen einer LLM-API wie die Verwendung einer rohen Datenbankabfrage ist. LangChain.js bietet ein ORM (Object-Relational Mapper) für LLMs. Es verwaltet gängige Modelle wie:
* **Ketten:** Kombination mehrerer LLM-Aufrufe oder anderer Schritte in einer Sequenz.
* **Prompts:** Verwaltung und Formatierung der Eingaben für die LLMs.
* **Agenten:** Ermöglichen es den LLMs, Entscheidungen zu treffen und Werkzeuge zu verwenden.
* **Abruf:** Integration externer Daten (Ihre Dokumente, Datenbanken) mit den LLMs.
* **Gedächtnis:** Den LLMs einen Weg geben, sich an vergangene Interaktionen zu erinnern.
Der Hauptvorteil der Verwendung von LangChain.js ist die Steigerung der Produktivität und Wartbarkeit. Sie schreiben weniger wiederholten Code, die Logik Ihrer Anwendung wird klarer, und es ist einfacher, den LLM-Anbieter zu wechseln oder neue Funktionen hinzuzufügen. Für jeden, der mit LLMs in JavaScript entwickelt, bietet LangChain.js erhebliche Vorteile.
Einrichtung Ihres LangChain.js-Projekts
Bevor wir Code schreiben, bereiten wir unsere Umgebung vor. Sie benötigen Node.js installiert.
1. **Erstellen Sie ein neues Projektverzeichnis:**
`
mkdir langchain-js-project
cd langchain-js-project
`
2. **Initialisieren Sie ein Node.js-Projekt:**
`
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 andere (Hugging Face, Google usw.).
`
npm install langchain @openai/openai
`
Wenn Sie TypeScript bevorzugen:
`
npm install langchain @openai/openai typescript @types/node ts-node
npx tsc –init
`
Aktualisieren Sie anschließend die `tsconfig.json`, um `“moduleResolution”: “node”` und `“esModuleInterop”: true` hinzuzufügen.
4. **Konfigurieren Sie Ihren API-Schlüssel:**
Sie benötigen einen OpenAI API-Schlüssel. Codieren Sie API-Schlüssel niemals direkt in Ihrem Code. Verwenden Sie Umgebungsvariablen.
Erstellen Sie eine Datei `.env` im Stammverzeichnis Ihres Projekts:
`
OPENAI_API_KEY=YOUR_OPENAI_API_KEY
`
Um die Umgebungsvariablen zu laden, installieren Sie `dotenv` :
`
npm install dotenv
`
Dann, ganz oben in Ihrer Hauptskriptdatei (z. B. `index.js` oder `src/index.ts`):
`
require(‘dotenv’).config();
`
oder für TypeScript/ESM:
`
import ‘dotenv/config’;
`
Jetzt sind Sie bereit, mit LangChain.js zu beginnen.
Ihr erster LLM-Aufruf mit LangChain.js
Führen wir einen einfachen Aufruf an ein LLM durch.
`
// index.js
require(‘dotenv’).config();
const { OpenAI } = require(‘langchain/llms/openai’);
async function simpleLLMCall() {
const model = new OpenAI({ temperature: 0.7 }); // die Temperatur steuert den Zufallsfaktor
const prompt = “Was ist die Hauptstadt von Frankreich?”;
const result = await model.call(prompt);
console.log(result);
}
simpleLLMCall();
`
Führen Sie dies aus: `node index.js`.
Sie sollten “Paris.” oder eine ähnliche Ausgabe sehen. Dies ist die grundlegendste Interaktion. LangChain.js wickelt den API-Aufruf von OpenAI ab und sorgt dafür, dass er konsistent mit anderen LLM-Anbietern funktioniert.
Mit Prompts arbeiten: Vorlagen und Variablen
Direkte Eingabe von Prompts in Ihren Code kann unübersichtlich werden. LangChain.js bietet `PromptTemplate`, um Prompts effizient zu verwalten.
`
// 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(“Formatierter Prompt:”, 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, Prompts mit Platzhaltern (`{product}`) zu definieren, die Sie dynamisch ausfüllen können. Dies ist entscheidend für den Bau 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 einem einzigen konsistenten Arbeitsablauf zu kombinieren.
Einfache LLM-Kette
Die `LLMChain` ist die grundlegendste Kette. Sie nimmt ein `PromptTemplate` und ein LLM, formatiert dann den Prompt und gibt ihn an das LLM weiter.
`
// 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 Eigenschaft ‘text’ mit der Ausgabe des LLM.
}
simpleLLMChain();
`
Führen Sie dies mit `node llmChainExample.js` aus.
Beachten Sie, wie `chain.call()` ein Objekt mit den Eingangsvariablen annimmt und das Formatieren des Prompts und den Aufruf des LLM verwaltet. Dies ist eine sauberere Art, mit Ihrem LLM zu interagieren.
Sequenzielle Ketten: Mehrstufige Arbeitsabläufe
Manchmal müssen Sie mehrere LLM-Aufrufe in einer Sequenz durchführen, bei denen die Ausgabe eines Aufrufs die Eingabe für den nächsten wird. Hier ist `SimpleSequentialChain` nützlich.
`
// 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: Unternehmensnamen generieren
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: Das Unternehmen beschreiben
const descriptionTemplate = “Schreiben Sie einen kurzen, ansprechenden Marketing-Slogan für ein Unternehmen namens {companyName}.”;
const descriptionPrompt = new PromptTemplate({
template: descriptionTemplate,
inputVariables: [“companyName”],
});
const descriptionChain = new LLMChain({ llm: model, prompt: descriptionPrompt });
// Kombinieren Sie die beiden in einer sequenziellen Kette
const overallChain = new SimpleSequentialChain({
chains: [nameChain, descriptionChain],
verbose: true, // Auf true setzen, um die Zwischenschritte zu sehen
});
const result = await overallChain.run(“umweltfreundliche Schuhe”);
console.log(“Gesamtergebnis:”, result);
}
multiStepChain();
`
Führen Sie dies mit `node sequentialChainExample.js` aus.
Die `SimpleSequentialChain` nimmt die Ausgabe von `nameChain` und verwendet sie automatisch als Eingabe (`companyName`) für `descriptionChain`. Dieses Modell ist äußerst leistungsfähig, um komplexe Aufgaben zu zerlegen. LangChain.js erleichtert dies.
Augmentierte Rückgewinnung durch Generierung (RAG): Ihre eigenen Daten nutzen
Die LLMs sind leistungsstark, aber ihr Wissen ist auf ihre Trainingsdaten beschränkt. Für Anwendungen, die aktuelle Informationen oder fachspezifisches Wissen benötigen (zum Beispiel die Dokumente Ihres Unternehmens), müssen Sie das Wissen des LLM mit externen Daten erweitern. Dies wird als Augmentierte Rückgewinnung durch Generierung (RAG) bezeichnet.
Die Hauptidee von RAG ist:
1. **Daten laden:** Besorgen Sie sich Ihre Dokumente (PDFs, Textdateien, Webseiten).
2. **Daten aufteilen:** Teilen Sie große Dokumente in kleinere, handhabbare Teile.
3. **Daten integrieren:** Wandeln Sie diese Teile in digitale Repräsentationen (Einbettungen) um, indem Sie ein Integrationsmodell verwenden.
4. **Daten speichern:** Speichern Sie diese Einbettungen in einer Vektordatenbank.
5. **Wiederherstellen:** Wenn ein Benutzer eine Frage stellt, integrieren Sie die Frage und durchsuchen Sie die Vektordatenbank nach ähnlichen Dokumententeilen.
6. **Prompt erweitern:** Fügen Sie diese wiederhergestellten Teile dem Prompt des LLM 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 verfügt über mehrere Dokumentenloader. Lassen Sie uns einen `TextLoader` verwenden.
“`javascript
// ragExample.js – Teil 1: Dokumente laden
require(‘dotenv’).config();
const { TextLoader } = require(‘langchain/document_loaders/fs/text’);
async function loadDocuments() {
// Erstellen Sie eine Beispiel-Textdatei für die Demonstration
const fs = require(‘fs’);
fs.writeFileSync(‘my_document.txt’, `
Der schnelle braune Fuchs springt über den faulen Hund.
Dieses Dokument handelt von verschiedenen Tieren und deren Verhalten.
Hunde sind bekannt für ihre Loyalität und Verspieltheit.
Füchse sind listige und einsame Kreaturen.
Katzen schlafen gerne und jagen Mäuse.
`);
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
console.log(“Laden von Dokumenten:”, docs);
// Jedes Dokument hat pageContent und Metadaten
}
loadDocuments();
“`
Schritt 2: Dokumente aufteilen
Große Dokumente müssen in kleinere Teile aufgeteilt werden, damit sie in das Kontextfenster des LLM passen und die Relevanz der Wiederherstellungen verbessern.
“`javascript
// ragExample.js – Teil 2: Aufteilung
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 aus Teil 1 erstellt)
const loader = new TextLoader(“my_document.txt”);
const docs = await loader.load();
const splitter = new RecursiveCharacterTextSplitter({
chunkSize: 100, // Max Zeichen pro Teil
chunkOverlap: 20, // Überschneidung zwischen den Teilen zur Beibehaltung des Kontexts
});
const splitDocs = await splitter.splitDocuments(docs);
console.log(“Geteilte Dokumente:”, splitDocs);
}
splitDocuments();
“`
Schritt 3 & 4: Integration und Speicherung der Dokumente (vektorielle Speicherung)
Hier kommen die Einbettungen und die Vektordatenbanken ins Spiel. Wir werden OpenAI-Einbettungen und `HNSWLib` (ein lokaler Speicher für vektorielle Daten im Arbeitsspeicher) zur Einfachheit verwenden. In der Produktion sollten Sie eine dedizierte Vektordatenbank wie Pinecone, Chroma, Weaviate usw. verwenden.
“`javascript
// ragExample.js – Teil 3: Einbettungen und vektorielle Speicherung
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 handelt von verschiedenen Tieren und deren Verhalten.
Hunde sind bekannt für ihre Loyalität und Verspieltheit.
Füchse sind listige und einsame Kreaturen.
Katzen schlafen gerne und jagen Mäuse.
Eine Gruppe von Katzen heißt Clowder.
`);
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. Einbettungen erstellen und im vektoriellen Speicher speichern
const embeddings = new OpenAIEmbeddings();
const vectorStore = await HNSWLib.fromDocuments(docs, embeddings);
// 3. Einen Abrufmechanismus erstellen
const retriever = vectorStore.asRetriever();
// 4. Die RetrievalQA-Kette 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ähl mir von Füchsen.”;
const anotherResult = await chain.call({ query: anotherQuestion });
console.log(“Andere RAG-Antwort:”, anotherResult.text);
}
ragApplication();
“`
Führen Sie es mit `node ragExample.js` aus.
Dieses Beispiel fasst alle Teile des RAG zusammen. Die `RetrievalQAChain` abstrahiert den Prozess des Abrufens relevanter Dokumente und deren Verwendung zur Beantwortung einer Frage. Es ist eine praktische Möglichkeit, Chatbots oder Frage-Antwort-Systeme für Ihre spezifischen Daten mit LangChain.js zu erstellen.
Agenten: LLM, die Werkzeuge verwenden
Agenten ermöglichen es LLMs, Entscheidungen darüber zu treffen, welche Werkzeuge in welcher Reihenfolge verwendet werden sollen, basierend auf den Eingaben des Benutzers. Dies ermöglicht dynamischere und komplexere Interaktionen. Die Werkzeuge können alles Mögliche sein: eine Suchmaschine, einen Taschenrechner, einen API-Aufruf an Ihre internen Systeme oder sogar eine andere LLM-Kette.
Lassen Sie uns einen einfachen Agenten erstellen, der Berechnungen mit einem Werkzeug `Calculator` durchfü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()];
// Den Agenten-Executor initialisieren
const executor = await initializeAgentExecutorWithOptions(tools, model, {
agentType: “openai-functions”, // Verwenden Sie die Funktion zum Aufrufen von OpenAI-Funktionen
verbose: true, // Den Denkprozess des Agenten anzeigen
});
console.log(“Agentenaufruf mit einer einfachen mathematischen Frage…”);
const result1 = await executor.call({ input: “Was ist 123 plus 456?” });
console.log(“Agentenresultat 1:”, result1.output);
console.log(“\nAgentenaufruf mit einer komplexeren Frage…”);
const result2 = await executor.call({ input: “Was ist die Quadratwurzel von 625 multipliziert mit 3?” });
console.log(“Agentenresultat 2:”, result2.output);
}
runAgent();
“`
Führen Sie es mit `node agentExample.js` aus.
Mit `verbose: true` werden Sie die “Gedanken” des Agenten sehen: Er identifiziert, dass eine Berechnung erforderlich ist, verwendet das Werkzeug `Calculator` und gibt dann die Antwort weiter. Dies ist ein leistungsstarkes Modell, um Anwendungen zu erstellen, die über die einfache Textgenerierung hinausgehen. LangChain.js erleichtert die Konfiguration dieser Agenten.
Speicher: Den Gesprächskontext beibehalten
Standardmäßig sind LLMs zustandslos. Jeder API-Aufruf ist unabhängig. Für Konversationsanwendungen muss sich das LLM an vergangene Interaktionen erinnern. LangChain.js bietet verschiedene Arten von Speicher, um dies zu erreichen.
`ConversationBufferMemory` ist eine gängige Wahl, die die Rohhistorie der Gespräche 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(“Start der Konversation…”);
let result1 = await chain.call({ input: “Hallo, ich heiße Jake.” });
console.log(“Benutzer : Hallo, ich heiße 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ähle mir eine lustige Tatsache über JavaScript.” });
console.log(“Benutzer : Erzähle mir eine lustige Tatsache über JavaScript.”);
console.log(“KI :”, result3.response);
}
conversationalApp();
“`
Führen Sie es mit `node memoryExample.js` aus.
`ConversationBufferMemory` hält die Gesprächshistorie fest, wodurch das LLM in der Lage ist, korrekt auf die Frage „Wie heiße ich ?“ basierend auf der vorherigen Runde zu antworten. LangChain.js bietet weitere Arten von Speicher für fortgeschrittene Anwendungsfälle, wie Zusammenfassungen von Gesprächen oder die Speicherung von spezifischen Teilen nur.
Praktische Tipps für die Entwicklung mit LangChain.js
1. **Einfach anfangen:** Versuchen Sie nicht, sofort einen komplexen Agenten mit mehreren Werkzeugen und Speichern zu erstellen. Beginnen Sie mit einfachen LLM-Aufrufen und `LLMChain`.
2. **Verwenden Sie `verbose: true`:** Beim Debuggen von Ketten oder Agenten ist es hilfreich, `verbose: true` zu setzen. Es zeigt die Zwischenschritte, die gesendeten Aufforderungen und die erhaltenen Antworten, was Ihnen hilft zu verstehen, warum Ihre Kette möglicherweise nicht wie erwartet funktioniert.
3. **API-Schlüssel sicher verwalten:** Verwenden Sie immer Umgebungsvariablen für Ihre API-Schlüssel. Versionieren Sie diese niemals.
4. **Verstehen Sie die Kontextfenster:** Achten Sie auf die Token-Grenzen Ihres gewählten LLM. Längere Aufforderungen, eine umfangreiche Gesprächshistorie oder viele abgerufene Dokumente können schnell diese Grenzen überschreiten. LangChain.js verfügt über Werkzeuge zur Verwaltung dessen, aber es ist wichtig, sich dessen bewusst zu sein.
5. **Experimentieren Sie mit `temperature`:** Der Parameter `temperature` steuert den Zufallsfaktor der LLM-Ausgabe. Höhere Werte (z. B. 0.7-1.0) führen zu kreativeren und weniger deterministischen Antworten. Niedrigere Werte (z. B. 0.0-0.3) sind faktischer und konsistenter. Passen Sie dies an die Bedürfnisse Ihrer Anwendung an.
6. **Die Dokumentation durchsehen:** Die Dokumentation von LangChain.js ist umfassend. Wenn Sie nach einem spezifischen Loader, einer Kette oder einem Werkzeug suchen, gibt es gute Chancen, dass dies dort abgedeckt ist.
7. **Berücksichtigen Sie Vektor-Datenbanken in Produktionsumgebungen:** Für RAG-Anwendungen in der Praxis ersetzen Sie `HNSWLib` durch eine persistente Vektordatenbank wie Pinecone, Chroma oder Weaviate. Damit können Sie große Datenmengen skalieren und speichern.
8. **Fehlerbehandlung:** Implementieren Sie eine solide Fehlerbehandlung für API-Aufrufe, insbesondere in Produktionsumgebungen. Netzwerkprobleme, Rate-Limits oder ungültige Eingaben können zu Fehlfunktionen führen.
Häufige Fragen zu LangChain.js
Q1: Ist LangChain.js nur für OpenAI-Modelle?
Nein, LangChain.js unterstützt eine Vielzahl von LLM-Anbietern, einschließlich OpenAI, Hugging Face-Modelle (über `HuggingFaceHub` oder `HuggingFaceInference`), Google (z. B. `GoogleGenerativeAI`), Anthropic und viele mehr. Die grundlegenden Abstraktionen von LangChain.js ermöglichen es Ihnen, 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 Instanz eines LLM zu interagieren, indem er einen Rohaufforderungsstring übergibt. `chain.call()` wird für Ketten verwendet und nimmt ein Objekt entgegen, das Eingangsvariablen enthält (die dann durch ein `PromptTemplate` formatiert werden, falls es in der Kette verwendet wird). `chain.run()` ist eine Komfortmethode für Ketten, die nur eine Eingangsvariable haben und direkt den Ausgabetext zurückgeben. Für komplexere Ketten mit mehreren Eingaben/Ausgaben wird `chain.call()` bevorzugt.
Q3: Wie kann ich LangChain.js mit meiner vorhandenen Datenbank oder API integrieren?
Sie können LangChain.js mit Ihren bestehenden Systemen integrieren, indem Sie benutzerdefinierte Werkzeuge für die Agenten erstellen. Ein Werkzeug ist im Grunde eine Funktion, die einen Eingabestring entgegennimmt und einen Ausgabestring zurückgibt. Sie können ein Werkzeug definieren, das Ihre Datenbank abfragt, eine interne API aufruft oder jegliche andere benutzerdefinierte Logik ausführt, und dieses Werkzeug dann Ihrem LangChain.js-Agenten zur Verfügung stellen. Für RAG können Sie benutzerdefinierte Implementierungen von `DocumentLoader` erstellen, um Daten aus Ihren spezifischen Quellen zu laden.
Q4: Wann sollte ich LangChain.js verwenden, anstatt die LLM-APIs direkt aufzurufen?
Verwenden Sie LangChain.js, wenn Sie Anwendungen erstellen müssen, die mehr als einen einfachen isolierten LLM-Aufruf erfordern. Wenn Ihre Anwendung folgendes benötigt:
* Mehrstufiges Denken (Ketten).
* Integration externer Daten (RAG).
* Zugang zu externen Werkzeugen für das LLM (Agenten).
* Verwaltung der Gesprächshistorie (Speicher).
* Einfache Änderung von LLM-Anbietern.
* Strukturierteren und wartbareren Code.
Wenn Sie einfach nur für Tests eine einzelne Aufforderung machen, können 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 von komplexen LLM-Anwendungen in JavaScript und TypeScript. Indem Sie die Schlüsselkomponenten verstehen—LLMs, Prompts, Chains, Retrieval, Agents und Memory—können Sie intelligente Systeme aufbauen, die über die einfache Textgenerierung hinausgehen. Dieser Leitfaden hat einen praktischen und umsetzbaren Ausgangspunkt geboten. Von einfachen LLM-Aufrufen bis hin zu komplexen RAG-Pipelines und Agenten bietet LangChain.js die Werkzeuge, um Ihre Ideen zur KI-Automatisierung zum Leben zu erwecken. Beginnen Sie mit Experimenten, bauen Sie kleine Projekte und Sie werden schnell das Potenzial von LangChain.js in Ihrem Entwicklungsprozess entdecken.
🕒 Published: