Ollama dans LangChain - Intégration JavaScript

Tutoriels pratiques sur l'IAMise à jour il y a 5 mois Cercle de partage de l'IA

1.3K 00

bref

Ce document décrit comment utiliser le Ollama Ollama est un outil de déploiement open source pour les grands modèles de langage, et LangChain est un cadre pour la création d'applications basées sur des modèles de langage. En combinant les deux, nous pouvons rapidement déployer et utiliser des modèles d'IA avancés dans un environnement local.

Note : Ce document contient des extraits de code et des explications détaillées. Le code complet se trouve dans notebook/c5/ollama_langchain_javascript.

1) Paramètres environnementaux

Configuration de l'environnement Node.js

Tout d'abord, assurez-vous que Node.js est installé sur votre système ; vous pouvez télécharger et installer la dernière version à partir du site web de Node.js.

Création d'un projet et installation des dépendances

Passez dans le répertoire d'exécution pour l'exécuter :

cd notebook/C5/ollama_langchain_javascript
npm init -y

Installer les dépendances nécessaires :

npm install @langchain/ollama @langchain/core @langchain/community zod

existent package.json en ajoutant l'élément "type": "module" pour activer la prise en charge du module ES :

{
"type": "module",
// ... 其他配置
}

2. télécharger le modèle requis et initialiser Ollama

Télécharger le modèle llama3.1

Rendez-vous sur le site officiel https://ollama.com/download pour télécharger et installer Ollama sur les plates-formes compatibles disponibles.
Consultez le site https://ollama.ai/library pour connaître tous les modèles disponibles.
faire passer (un projet de loi, une inspection, etc.) ollama pull <name-of-model> pour obtenir les modèles LLM disponibles (par exemple :ollama pull llama3.1).

La ligne de commande est exécutée comme indiqué dans la figure :

Emplacement de stockage du modèle :

Mac. ~/.ollama/models/
Linux (ou WSL). /usr/share/ollama/.ollama/models
Fenêtres. C:\Users\Administrator\.ollama\models

Une fois le téléchargement terminé, vous devez vous assurer que le service Ollama est démarré :

ollama ps

3. exemples d'utilisation de base

Conversations simples avec ChatOllama

exécutable base_chat.js le code spécifique est le suivant :

import { Ollama } from "@langchain/community/llms/ollama";
const ollama = new Ollama({
baseUrl: "http://localhost:11434",  // 确保Ollama服务已经启动
model: "llama3.1", // 替换为实际使用的模型
});
const stream = await ollama.stream(
`你比GPT4厉害吗?`
);
const chunks = [];
for await (const chunk of stream) {
chunks.push(chunk);
}
console.log(chunks.join(""));

Exécutez le code :

node base_chat.js

Ce code a plusieurs fonctions :

Importer la classe Ollama et l'initialiser en spécifiant le modèle et l'URL de base.
utiliser stream envoie une question au modèle, ce qui nous permet de recevoir la réponse bloc par bloc.
Utilisez une boucle for-await pour collecter tous les blocs de réponse.
Combinez tous les blocs et imprimez la réponse complète.

Utilisation de modèles multimodaux

être en mouvementbase_multimodal.jsle code spécifique est le suivant :

import { Ollama } from "@langchain/community/llms/ollama";
import * as fs from "node:fs/promises";
const imageData = await fs.readFile("../../../docs/images/C5-1-4.png"); // 可以替换为你想询问的图片
const model = new Ollama({
model: "llava",
baseUrl: "http://127.0.0.1:11434",
}).bind({
images: [imageData.toString("base64")],
});
const res = await model.invoke("图片里是什么动物呀？");
console.log({ res });

Exécutez le code :

node base_multimodal.js

Ce code montre comment traiter des entrées d'images et de textes à l'aide d'un modèle multimodal tel que llava :

Lit un fichier image et le convertit en encodage base64.
Initialiser le modèle Ollama et utiliser la fonction bind lie les données de l'image au modèle.
utiliser invoke envoie une question sur une image.
Imprimer la réponse du modèle.

Appel d'outil

être en mouvement base_tool.js avec le code suivant :

import { tool } from "@langchain/core/tools";
import { ChatOllama } from "@langchain/ollama";
import { z } from "zod";
// 定义简单计算器工具
const simpleCalculatorTool = tool((args) => {
const { operation, x, y } = args;
switch (operation) {
case "add":
return x + y;
case "subtract":
return x - y;
case "multiply":
return x * y;
case "divide":
if (y !== 0) {
return x / y;
} else {
throw new Error("Cannot divide by zero");
}
default:
throw new Error("Invalid operation");
}
}, {
name: "simple_calculator",
description: "Perform simple arithmetic operations",
schema: z.object({
operation: z.enum(["add", "subtract", "multiply", "divide"]),
x: z.number(),
y: z.number(),
}),
});
// 定义模型
const llm = new ChatOllama({
model: "llama3.1",
temperature: 0,
});
// 将工具绑定到模型
const llmWithTools = llm.bindTools([simpleCalculatorTool]);
// 使用模型进行工具调用
const result = await llmWithTools.invoke(
"你知道一千万乘二是多少吗？请使用 'simple_calculator' 工具来计算。"
);
console.log(result);

Exécutez le code :

node base_tool.js

Ce code montre comment définir et utiliser les outils :

utiliser tool définit un outil de calcul simple, y compris la logique de fonctionnement et le schéma des paramètres.
Initialiser le modèle ChatOllama.
utiliser bindTools lie l'outil au modèle.
utiliser invoke envoie un problème à calculer et le modèle appelle automatiquement l'outil approprié.

4. utilisation avancée

Modèles de messages personnalisés

Les modèles de messages personnalisés améliorent non seulement l'efficacité de la génération de contenu, mais garantissent également la cohérence et la pertinence du résultat. Grâce à des modèles bien conçus, nous pouvons exploiter pleinement les capacités du modèle d'IA tout en conservant le contrôle et l'orientation du contenu de sortie :

import { ChatOllama } from "@langchain/ollama";
import { ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate } from "@langchain/core/prompts";
// 初始化ChatOllama模型
const model = new ChatOllama({
model: "llama3.1",
temperature: 0.7,
});
const systemMessageContent = `
你是一位经验丰富的电商文案撰写专家。你的任务是根据给定的产品信息创作吸引人的商品描述。
请确保你的描述简洁、有力，并且突出产品的核心优势。
`;
const humanMessageTemplate = `
请为以下产品创作一段吸引人的商品描述：
产品类型: {product_type}
核心特性: {key_feature}
目标受众: {target_audience}
价格区间: {price_range}
品牌定位: {brand_positioning}
请提供以下三种不同风格的描述，每种大约50字：
1. 理性分析型
2. 情感诉求型
3. 故事化营销型
`;
const prompt = ChatPromptTemplate.fromMessages([
SystemMessagePromptTemplate.fromTemplate(systemMessageContent),
HumanMessagePromptTemplate.fromTemplate(humanMessageTemplate),
]);
const chain = prompt.pipe(model);
async function generateProductDescriptions(productInfo) {
const response = await chain.invoke(productInfo);
return response.content;
}
// 示例使用
const productInfo = {
product_type: "智能手表",
key_feature: "心率监测和睡眠分析",
target_audience: "注重健康的年轻专业人士",
price_range: "中高端",
brand_positioning: "科技与健康的完美结合"
};
generateProductDescriptions(productInfo)
.then((result) => console.log(result))
.catch((error) => console.error("Error:", error));

Exécutez le code :

node advanced_prompt.js

Ce code montre comment créer et utiliser un modèle d'invite personnalisé :

Définir les modèles de message système et de message humain.
utiliser ChatPromptTemplate.fromMessages Créer un modèle d'invite complet.
utiliser pipe relie le modèle de repère au modèle, créant ainsi une chaîne de traitement.
Définir une fonction pour générer une description de produit qui utilise une chaîne de traitement pour traiter les informations d'entrée sur le produit.

Les modèles d'invite personnalisés ont un large éventail d'utilisations dans la pratique, en particulier lorsque vous devez générer du contenu dans un format ou un style particulier. Vous trouverez ci-dessous quelques scénarios d'application pratique :

Génération de descriptions de produits pour le commerce électronique : comme le montre cet exemple, il peut être utilisé pour générer automatiquement différents styles de descriptions de produits afin d'améliorer l'attrait de la page produit et le taux de conversion.
Modèles de réponse du service clientèle : vous pouvez créer des modèles de réponse pour différents scénarios, tels que le traitement des réclamations, la fourniture d'informations sur les produits, etc.
Génération d'articles de presse : des modèles peuvent être conçus pour générer différents types d'articles de presse, tels que des informations de dernière minute, des analyses approfondies, etc.
E-mails marketing personnalisés : générez un contenu d'e-mail marketing personnalisé basé sur les données clients et les objectifs marketing afin d'améliorer l'efficacité de l'e-mail marketing.

Sortie JSON avancée et génération de graphes de connaissances

Dans cet exemple, nous montrons comment Ollama et LangChain peuvent être utilisés pour générer des sorties JSON structurées, en particulier pour créer des graphes de connaissances. Cette approche est étroitement liée au projet open source GraphRAG de Microsoft, notamment en ce qui concerne l'automatisation de l'extraction des connaissances et la génération de triades.

import { ChatOllama } from "@langchain/ollama";
import { PromptTemplate } from "@langchain/core/prompts";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";
const systemTemplate = `
你是一位医疗领域的专家，擅长创建知识图谱。请将所有响应格式化为具有以下结构的JSON对象：
{
"节点": [
{"id": "string", "标签": "string", "类型": "string"}
],
"关系": [
{"源": "string", "目标": "string", "关系": "string"}
]
}
确保所有节点id都是唯一的，并且关系引用的是已存在的节点id。
`;
const humanTemplate = `
请为医疗主题"{topic}"创建一个知识图谱。包括以下相关概念: {concepts}。
提供至少5个节点和5个关系。请确保使用中文回答。
`;
const systemMessage = new SystemMessage(systemTemplate);
const humanPrompt = PromptTemplate.fromTemplate(humanTemplate);
const llmJsonMode = new ChatOllama({
baseUrl: "http://localhost:11434", // 默认值
model: "llama3.1",
format: "json",
});
async function generateMedicalKnowledgeGraph(topic, concepts) {
try {
const 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(JSON.stringify(result, null, 2));
return result;
} catch (error) {
console.error("生成知识图谱时出错:", error);
}
}
// 使用示例
const topic = "糖尿病";
const concepts = ["胰岛素", "血糖", "并发症", "饮食管理", "运动疗法"];
generateMedicalKnowledgeGraph(topic, concepts);

Exécutez le code :

node advanced_json.js

Ce code montre comment générer une sortie JSON structurée à l'aide d'Ollama :

Définit un modèle de système qui spécifie la structure JSON souhaitée.
Créer un modèle d'invite humaine pour générer des requêtes pour le Knowledge Graph.
Initialiser le modèle ChatOllama, définir le paramètre format: "json" pour obtenir la sortie JSON.
Définir une fonction pour générer un graphe de connaissances médicales qui combine les messages du système et les messages humains et appeler le modèle.

Nous pouvons avoir un aperçu des nombreuses façons dont cela peut être utilisé grâce à la sortie spécifique du format json :

Génération automatisée de ternaires La création de graphes de connaissances : Dans les approches traditionnelles, la création de graphes de connaissances nécessite généralement un important travail d'étiquetage manuel. Les experts doivent lire attentivement les documents, identifier les concepts importants et leurs relations, puis créer manuellement des triples (sujet-relation-objet). Ce processus est non seulement chronophage, mais également source d'erreurs, en particulier lorsqu'il s'agit d'un grand nombre de documents. Grâce à notre approche, le Big Language Model peut générer automatiquement des nœuds et des relations pertinents à partir de sujets et de concepts donnés. Cela accélère considérablement le processus de construction des graphes de connaissances.
Amélioration des données Cette approche peut être utilisée non seulement pour la génération directe de graphes de connaissances, mais aussi pour l'enrichissement des données. Par exemple, cette approche peut être utilisée pour générer directement des graphes de connaissances, mais aussi pour améliorer les données :
- Extension de l'ensemble de données de formation existant : le modèle génère de nouveaux triples pertinents sur la base des triples existants.
- Création d'exemples divers : la création de graphes de connaissances pour différentes conditions médicales ajoute de la diversité aux données.
- Génération de données multilingues : en ajustant les messages-guides, il est possible de générer des graphes de connaissances dans différentes langues pour soutenir les applications multilingues.
Améliorer la qualité des données Le Big Language Model peut être exploité pour générer des graphes de connaissances cohérents et de haute qualité à partir de sa vaste base de connaissances. Grâce à des invites bien conçues, nous pouvons nous assurer que les données générées répondent à des normes de qualité spécifiques et à des spécifications de domaine.
Flexibilité et évolutivité Cette approche est très flexible et peut être facilement adaptée à différents domaines et besoins :
- En modifiant les invites du système, nous pouvons changer la structure JSON de la sortie pour nous adapter à différents formats de graphes de connaissances.
- Il est facile d'étendre cette approche à d'autres domaines tels que la technologie, la finance, l'éducation, etc.

rendre un verdict

Avec ces exemples, nous montrons comment utiliser Ollama et LangChain pour construire une variété d'applications d'IA dans un environnement JavaScript, depuis les systèmes de dialogue simples jusqu'à la génération de graphes de connaissances complexes. Ces outils et techniques constituent une base solide pour le développement d'applications d'IA puissantes.

La combinaison d'Ollama et de LangChain offre aux développeurs une grande flexibilité et de nombreuses possibilités. Vous pouvez choisir les bons modèles et composants en fonction de vos besoins spécifiques et construire un système d'IA adapté à votre scénario d'application.

Au fur et à mesure que la technologie continue d'évoluer, nous nous attendons à voir émerger de nouvelles applications innovantes. Nous espérons que ce guide vous aidera à vous lancer dans le développement de l'IA et inspirera votre créativité pour explorer les possibilités infinies de la technologie de l'IA.