kurz
In diesem Dokument wird beschrieben, wie Sie die Ollama Ollama ist ein Open-Source-Implementierungstool für große Sprachmodelle, und LangChain ist ein Framework für die Entwicklung von Sprachmodell-basierten Anwendungen. Durch die Kombination der beiden können wir fortschrittliche KI-Modelle in einer lokalen Umgebung schnell einsetzen und nutzen.
Hinweis: Dieses Dokument enthält wichtige Codeschnipsel und ausführliche Erklärungen. Der vollständige Code ist in notebook/c5/ollama_langchain_javascript zu finden.
1. umweltbezogene Einstellungen
Konfigurieren der Node.js-Umgebung
Stellen Sie zunächst sicher, dass Sie Node.js auf Ihrem System installiert haben. Sie können die neueste Version von der Node.js-Website herunterladen und installieren.
Erstellen eines Projekts und Installieren von Abhängigkeiten
- Wechseln Sie in das Ausführungsverzeichnis, um es auszuführen:
cd notebook/C5/ollama_langchain_javascript
npm init -y
- Installieren Sie die erforderlichen Abhängigkeiten:
npm install @langchain/ollama @langchain/core @langchain/community zod
- existieren
paket.jsonDatei durch Hinzufügen der"Typ": "Modul"um die Unterstützung von ES-Modulen zu aktivieren:
{
"Typ": "Modul", // ...
// ... Andere Konfigurationen
}
2. das gewünschte Modell herunterladen und Ollama initialisieren
Lama3.1-Modell herunterladen
- Besuchen Sie die offizielle Website https://ollama.com/download, um Ollama auf den verfügbaren unterstützten Plattformen herunterzuladen und zu installieren.
- Unter https://ollama.ai/library finden Sie alle verfügbaren Modelle.
- passieren (eine Rechnung oder Inspektion etc.)
ollama ziehenum die verfügbaren LLM-Modelle abzurufen (zum Beispiel:ollama pull llama3.1).
Die Befehlszeile wird wie in der Abbildung gezeigt ausgeführt:
Speicherort des Modells:
- Mac.
~/.ollama/models/ - Linux (oder WSL).
/usr/share/ollama/.ollama/models - Fenster.
C:\Benutzer\Administrator\.ollama\models
Sobald der Download abgeschlossen ist, müssen Sie sicherstellen, dass der Ollama-Dienst gestartet ist:
ollama ps
3 Beispiele für die grundlegende Verwendung
Einfache Unterhaltungen mit ChatOllama
lauffähig base_chat.js Datei ist der spezifische Code wie folgt:
import { Ollama } from "@langchain/community/llms/ollama" ;
const ollama = new Ollama({
baseUrl: "http://localhost:11434", // sicherstellen, dass der Ollama-Dienst gestartet ist
model: "ollama3.1", // durch das tatsächlich verwendete Modell ersetzen
}); const stream = await ollama.
const stream = await ollama.stream(
`Sind Sie besser als GPT4? `
);
const chunks = [];
for await (const chunk of stream) {
chunks.push(chunk);
}
console.log(chunks.join(""));
Führen Sie den Code aus:
node base_chat.js
Dieser Code bewirkt mehrere Dinge:
- Importieren Sie die Klasse Ollama und initialisieren Sie sie, indem Sie das Modell und die Basis-URL angeben.
- ausnutzen
StromMethode sendet eine Frage an das Modell, die es uns ermöglicht, die Antwort blockweise zu erhalten. - Verwenden Sie eine for-await-Schleife, um alle Antwortblöcke zu sammeln.
- Kombinieren Sie alle Blöcke und drucken Sie die vollständige Antwort.
Verwendung von multimodalen Modellen
in Bewegung seinbase_multimodal.jsDatei ist der spezifische Code wie folgt:
import { Ollama } from "@langchain/community/llms/ollama" ;
import * as fs von "node:fs/promises";
const imageData = await fs.readFile("... /... /... /docs/images/C5-1-4.png"); // kann durch das Bild ersetzt werden, nach dem Sie fragen möchten
const model = new Ollama({
model: "llava",
baseUrl: "http://127.0.0.1:11434", }).
}).bind({
images: [imageData.toString("base64")], }); { images: [imageData.toString("base64")], {
}); const res = await model.
const res = await model.invoke("Welches Tier ist auf dem Bild?") console.log({ res })
console.log({ res });
Führen Sie den Code aus:
node base_multimodal.js
Dieser Code zeigt, wie Bild- und Texteingaben mit einem multimodalen Modell wie llava verarbeitet werden können:
- Liest eine Bilddatei und konvertiert sie in base64-Kodierung.
- Initialisieren Sie das Ollama-Modell und verwenden Sie die
bindenMethode bindet die Bilddaten an das Modell. - ausnutzen
aufrufen.Methode sendet eine Frage zu einem Bild. - Drucken Sie die Modellantwort.
Werkzeug Aufruf
in Bewegung sein base_tool.js Datei mit dem folgenden Code:
import { tool } from "@langchain/core/tools" ;
importieren { ChatOllama } aus "@langchain/ollama".
import { z } from "zod";
// Definieren Sie das einfache Taschenrechner-Tool
const simpleCalculatorTool = tool((args) => {
const { operation, x, y } = args;
switch (operation) {
Fall "addieren".
return x + y;
case "subtrahieren".
return x - y; case "multiplizieren": return x + y
case "multiplizieren".
return x * y; case "divide": return x - y; case "multiply": return x - y
case "divide": if (y !
wenn (y ! == 0) {
return x / y; } else { if (y ! == 0)
} else {
throw new Error("Kann nicht durch Null geteilt werden"); }
}
default.
throw new Error("Ungültige Operation"); } default.
}
}, {
name: "simple_calculator", description: "Einfache arithmetische Operationen durchführen", {
description: "Einfache arithmetische Operationen durchführen", { name: "simple_calculator", description: "Einfache arithmetische Operationen durchführen", }
schema: z.object({
operation: z.enum(["add", "subtract", "multiply", "divide"]), x: z.number(), z.number(), z.number(), z.number(), z.number(), z.number()
x: z.Zahl(),
y: z.Zahl(),
}), }
}).
// Definieren Sie das Modell
const llm = new ChatOllama({
model: "llama3.1",
Temperatur: 0, }); // Definieren Sie das Modell.
}); // Binden Sie das Werkzeug an das Modell.
// Werkzeuge an das Modell binden
const llmWithTools = llm.bindTools([simpleCalculatorTool]);
// Verwendung des Modells für Werkzeugaufrufe
const result = await llmWithTools.invoke(
"Wissen Sie, was 10 Millionen mal zwei ist? Bitte verwenden Sie das Tool 'simple_calculator', um es zu berechnen."
);
console.log(result);
Führen Sie den Code aus:
node base_tool.js
Dieser Code zeigt, wie man Werkzeuge definiert und verwendet:
- ausnutzen
WerkzeugFunktion definiert ein einfaches Taschenrechner-Tool, einschließlich der Betriebslogik und des Parameterschemas. - Initialisieren Sie das ChatOllama-Modell.
- ausnutzen
bindToolsMethode bindet das Werkzeug an das Modell. - ausnutzen
aufrufen.Methode sendet ein zu berechnendes Problem und das Modell ruft automatisch das entsprechende Werkzeug auf.
4. erweiterte Nutzung
Benutzerdefinierte Prompt-Vorlagen
Maßgeschneiderte Prompt-Vorlagen verbessern nicht nur die Effizienz der Inhaltserstellung, sondern gewährleisten auch die Konsistenz und Relevanz der Ausgabe. Mit gut gestalteten Vorlagen können wir die Fähigkeiten des KI-Modells voll ausschöpfen und gleichzeitig die Kontrolle und Anleitung über den Ausgabeinhalt behalten:
import { ChatOllama } from "@langchain/ollama" ;
import { ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate } from "@langchain/core/prompts";
// Initialisieren des ChatOllama-Modells
const model = new ChatOllama({
model: "llama3.1",
Temperatur: 0.7, }); // ChatOllama-Modell initialisieren.
});
const systemMessageContent = `
Sie sind ein erfahrener Experte für E-Commerce-Texte. Ihre Aufgabe ist es, ansprechende Artikelbeschreibungen auf der Grundlage der gegebenen Produktinformationen zu erstellen.
Stellen Sie sicher, dass Ihre Beschreibung prägnant und aussagekräftig ist und die wichtigsten Vorteile des Produkts hervorhebt.
`;
const humanMessageTemplate = `
Bitte erstellen Sie eine ansprechende Produktbeschreibung für das folgende Produkt:
Produkttyp: {product_type}
Hauptmerkmale: {key_feature}
Zielgruppe: {target_audience}
Preisspanne: {price_range}
Markenpositionierung: {brand_positioning}
Bitte beschreiben Sie jeden der drei folgenden Stile in jeweils etwa 50 Wörtern:
1. rationale Analyse
2. emotionale Ansprache
3. storytelling
`; const prompt = ChatPrompt
const prompt = ChatPromptTemplate.fromMessages([
SystemMessagePromptTemplate.fromTemplate(systemMessageContent),
HumanMessagePromptTemplate.fromTemplate(humanMessageTemplate),
]); const chain = prompt.pipe(model), humanMessagePromptTemplate.
const chain = prompt.pipe(model);
async function generateProductDescriptions(productInfo) {
const response = await chain.invoke(productInfo); async function generateProductDescriptions(productInfo) {
return response.content; }
}
// Beispielverwendung
const productInfo = {
product_type: "Smartwatch", key_feature: "Herzfrequenzmesser und Schlafanalyse", }
key_feature: "Herzfrequenzmonitor und Schlafanalyse",
target_audience: "Gesundheitsbewusste junge Berufstätige",
brand_positioning: "Die perfekte Kombination aus Technologie und Gesundheit"
};
generateProductDescriptions(productInfo)
.then((result) => console.log(result))
.catch((error) => console.error("Fehler:", error));
Führen Sie den Code aus:
node advanced_prompt.js
Dieser Code zeigt, wie man eine benutzerdefinierte Eingabeaufforderungsvorlage erstellt und verwendet:
- Definieren Sie Vorlagen für Systemmeldungen und menschliche Meldungen.
- ausnutzen
ChatPromptTemplate.fromMessagesErstellen Sie eine vollständige Prompt-Vorlage. - ausnutzen
RohrMethode verbindet die Cue-Vorlage mit dem Modell und bildet eine Verarbeitungskette. - Definieren Sie eine Funktion zur Erstellung einer Produktbeschreibung, die eine Verarbeitungskette zur Verarbeitung der eingegebenen Produktinformationen verwendet.
Benutzerdefinierte Vorlagen für Eingabeaufforderungen sind in der Praxis vielfältig einsetzbar, insbesondere wenn Sie Inhalte in einem bestimmten Format oder Stil erstellen müssen. Im Folgenden finden Sie einige praktische Anwendungsszenarien:
- Generierung von E-Commerce-Produktbeschreibungen: Wie in diesem Beispiel gezeigt, können damit automatisch verschiedene Stile von Produktbeschreibungen generiert werden, um die Attraktivität der Produktseite und die Konversionsrate zu verbessern.
- Antwortvorlagen für den Kundenservice: Sie können Antwortvorlagen für verschiedene Szenarien erstellen, z. B. für die Bearbeitung von Beschwerden, die Bereitstellung von Produktinformationen usw., um die Konsistenz und Professionalität der Antworten im Kundenservice zu gewährleisten.
- Erstellung von Nachrichtenbeiträgen: Es können Vorlagen für verschiedene Arten von Nachrichtenbeiträgen erstellt werden, wie z. B. Eilmeldungen, ausführliche Analysen usw., um Journalisten bei der schnellen Erstellung ihrer ersten Entwürfe zu unterstützen.
- Personalisierte Marketing-E-Mails: Erstellen Sie personalisierte Marketing-E-Mail-Inhalte auf der Grundlage von Kundendaten und Marketingzielen, um die Effektivität des E-Mail-Marketings zu verbessern.
Erweiterte JSON-Ausgabe und Wissensgraphengenerierung
In diesem Beispiel zeigen wir, wie Ollama und LangChain verwendet werden können, um strukturierte JSON-Ausgaben zu erzeugen, insbesondere für die Erstellung von Wissensgraphen. Dieser Ansatz ist eng mit dem Open-Source-Projekt GraphRAG von Microsoft verwandt, insbesondere bei der Automatisierung der Wissensextraktion und der Generierung von Triaden.
import { ChatOllama } from "@langchain/ollama" ;
importiere { PromptTemplate } aus "@langchain/core/prompts";
importiere { HumanMessage, SystemMessage } von "@langchain/core/messages";
const systemTemplate = `
Sie sind ein Experte auf dem Gebiet der Medizin und auf die Erstellung von Wissensgraphen spezialisiert. Bitte formatieren Sie alle Antworten als JSON-Objekte mit der folgenden Struktur:
{
"node": [
{ "id": "string", "label": "string", "type": "string"}
],
"relationship": [
{ "Quelle": "string", "Ziel": "string", "Beziehung": "string"}
]
}
Stellen Sie sicher, dass alle Knoten-IDs eindeutig sind und dass die Beziehung auf eine bereits vorhandene Knoten-ID verweist.
`;
const humanTemplate = `
Bitte erstellen Sie einen Wissensgraphen für das medizinische Thema "{topic}". Fügen Sie die folgenden verwandten Konzepte ein: {concepts}.
Geben Sie mindestens 5 Knoten und 5 Beziehungen an. Antworten Sie bitte auf Chinesisch.
`;
const systemMessage = new SystemMessage(systemTemplate);
const humanPrompt = PromptTemplate.fromTemplate(humanTemplate);
const llmJsonMode = new ChatOllama({
baseUrl: "http://localhost:11434", // Standardwert
model: "llama3.1", format: "json", // Standardwert
format: "json", // Voreinstellung
}).
async function generateMedicalKnowledgeGraph(topic, concepts) {
try {
const humanMessageContent = await humanPrompt.format({
Thema: Thema, Konzepte: Konzepte.format({
concepts: concepts.join(","), }); humanMessageContent = await humanPrompt.format({ topic: topic, concepts: concepts.join(","), }
});
const humanMessage = new HumanMessage(humanMessageContent);
const messages = [systemMessage, humanMessage];
const result = await llmJsonMode.call(messages); console.log(JSONMode.string)
console.log(JSON.stringify(result, null, 2)); return result; const messages = [systemMessage]; const humanMessage
return result; } catch (error) { { return result; }
} catch (error) {
console.error("Fehler beim Erzeugen des Wissensgraphen:", error); }
}
}
// Beispielverwendung
const topic = "Diabetes";
const concepts = ["Insulin", "Blutzucker", "Komplikationen", "Diätmanagement", "Bewegungstherapie"]; const concepts = ["Insulin", "Blutzucker", "Komplikationen", "Diätmanagement", "Bewegungstherapie"]; }
generateMedicalKnowledgeGraph(topic, concepts).
Führen Sie den Code aus:
node advanced_json.js
Dieser Code zeigt, wie man mit Ollama eine strukturierte JSON-Ausgabe erzeugt:
- Definiert eine Systemvorlage, die die gewünschte JSON-Struktur angibt.
- Erstellen Sie eine Vorlage für die menschliche Eingabeaufforderung zur Erstellung von Anfragen für den Knowledge Graph.
- Initialisieren Sie das ChatOllama-Modell, setzen Sie die
Format: "json"um die JSON-Ausgabe zu erhalten. - Definieren Sie eine Funktion zur Erstellung eines medizinischen Wissensgraphen, der Systemmeldungen und menschliche Meldungen kombiniert, und rufen Sie das Modell auf.
Wir können einen Einblick in die vielen Möglichkeiten erhalten, in denen dies durch spezifische Ausgaben im json-Format verwendet werden kann:
- Automatisierte ternäre Generierung Bei herkömmlichen Ansätzen erfordert die Erstellung von Wissensgraphen in der Regel einen erheblichen manuellen Beschriftungsaufwand. Experten müssen Dokumente sorgfältig lesen, wichtige Konzepte und ihre Beziehungen identifizieren und dann manuell Triples (Subjekt-Beziehung-Objekt) erstellen. Dieser Prozess ist nicht nur zeitaufwändig, sondern auch fehleranfällig, insbesondere bei einer großen Anzahl von Dokumenten. Mit unserem Ansatz kann das Big Language Model automatisch relevante Knoten und Beziehungen aus gegebenen Themen und Konzepten generieren. Dadurch wird der Prozess der Wissensgraphenerstellung erheblich beschleunigt.
- Datenerweiterung Dieser Ansatz kann nicht nur für die direkte Erstellung von Wissensgraphen, sondern auch für die Anreicherung von Daten verwendet werden. Zum Beispiel:
- Erweiterung des vorhandenen Trainingsdatensatzes: Das Modell generiert neue relevante Tripel auf der Grundlage der vorhandenen Tripel.
- Erstellung vielfältiger Beispiele: Durch die Erstellung von Wissensgraphen für verschiedene Krankheitsbilder wird die Vielfalt der Daten erhöht.
- Sprachübergreifende Datengenerierung: Durch Anpassung der Eingabeaufforderungen können Wissensgraphen in verschiedenen Sprachen erstellt werden, um mehrsprachige Anwendungen zu unterstützen.
- Verbesserung der Datenqualität Big Language Model: Das Big Language Model kann genutzt werden, um hochwertige, kohärente Wissensgraphen aus seiner umfangreichen Wissensbasis zu erstellen. Mit gut konzipierten Eingabeaufforderungen können wir sicherstellen, dass die generierten Daten bestimmte Qualitätsstandards und Domänenspezifikationen erfüllen.
- Flexibilität und Skalierbarkeit Dieser Ansatz ist sehr flexibel und kann leicht an verschiedene Bereiche und Bedürfnisse angepasst werden:
- Durch Änderung der Systemaufforderungen können wir die JSON-Struktur der Ausgabe ändern, um verschiedene Wissensgraphenformate zu berücksichtigen.
- Dieser Ansatz lässt sich leicht auf andere Bereiche wie Technologie, Finanzen, Bildung usw. ausweiten.
ein Urteil fällen
Anhand dieser Beispiele zeigen wir, wie Ollama und LangChain verwendet werden können, um eine Vielzahl von KI-Anwendungen in einer JavaScript-Umgebung zu erstellen, von einfachen Dialogsystemen bis hin zur komplexen Wissensgraphengenerierung. Diese Werkzeuge und Techniken bieten eine solide Grundlage für die Entwicklung leistungsstarker KI-Anwendungen.
Die Kombination von Ollama und LangChain bietet Entwicklern eine große Flexibilität und viele Möglichkeiten. Sie können die richtigen Modelle und Komponenten entsprechend Ihren spezifischen Anforderungen auswählen und ein KI-System aufbauen, das zu Ihrem Anwendungsszenario passt.
Da sich die Technologie weiter entwickelt, erwarten wir, dass noch mehr innovative Anwendungen entstehen. Wir hoffen, dass dieser Leitfaden Ihnen den Einstieg in die KI-Entwicklung erleichtert und Ihre Kreativität anregt, die unendlichen Möglichkeiten der KI-Technologie zu erkunden.
Deutsch (Sie) 
简体中文 
English 
日本語 
Português do Brasil