Ollama em LangChain - Integração com JavaScript

breve

Este documento descreve como usar o Ollama O Ollama é uma ferramenta de implantação de código aberto para grandes modelos de linguagem, e o LangChain é uma estrutura para a criação de aplicativos baseados em modelos de linguagem. Ao combinar os dois, podemos implementar e usar rapidamente modelos avançados de IA em um ambiente local.

Observação: este documento contém trechos do código principal e explicações detalhadas. O código completo pode ser encontrado em notebook/c5/ollama_langchain_javascript.

1. configurações ambientais

Configuração do ambiente do Node.js

Primeiro, certifique-se de ter o Node.js instalado em seu sistema; você pode fazer download e instalar a versão mais recente no site do Node.js.

Criação de um projeto e instalação de dependências

1. Vá para o diretório de execução para executá-lo:

cd notebook/C5/ollama_langchain_javascript
npm init -y

2. Instale as dependências necessárias:

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

3. existir package.json adicionando o atributo "type": "module" para ativar o suporte ao módulo ES:

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

2. faça o download do modelo necessário e inicialize o Ollama

Baixar o modelo llama3.1

1. Acesse o site oficial https://ollama.com/download para fazer o download e instalar o Ollama nas plataformas compatíveis disponíveis.
2. Acesse https://ollama.ai/library para ver todos os modelos disponíveis.
3. aprovar (um projeto de lei ou inspeção etc.) ollama pull <name-of-model> para obter os modelos LLM disponíveis (por exemplo:ollama pull llama3.1).

A linha de comando é executada conforme mostrado na figura:

Local de armazenamento do modelo:

• Mac. ~/.ollama/models/
• Linux (ou WSL). /usr/share/ollama/.ollama/models
• Windows. C:\Users\Administrator\.ollama\models

Após a conclusão do download, você precisa se certificar de que o serviço Ollama foi iniciado:

ollama ps

3. exemplos de uso básico

Conversas simples com o ChatOllama

executável base_chat.js o código específico é o seguinte:

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(""));

Execute o código:

node base_chat.js

Esse código faz várias coisas:

1. Importe a classe Ollama e inicialize-a, especificando o modelo e o URL de base.
2. fazer uso de stream envia uma pergunta ao modelo, o que nos permite receber a resposta bloco a bloco.
3. Use um loop for-await para coletar todos os blocos de resposta.
4. Combine todos os blocos e imprima a resposta completa.

Uso de modelos multimodais

estar em movimentobase_multimodal.jso código específico é o seguinte:

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 });

Execute o código:

node base_multimodal.js

Esse código demonstra como processar entradas de imagem e texto usando um modelo multimodal como o llava:

1. Lê um arquivo de imagem e o converte em codificação base64.
2. Inicialize o modelo Ollama e use a função bind vincula os dados da imagem ao modelo.
3. fazer uso de invoke envia uma pergunta sobre uma imagem.
4. Imprima a resposta do modelo.

Chamada de ferramenta

estar em movimento base_tool.js com o seguinte código:

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);

Execute o código:

node base_tool.js

Este código mostra como definir e usar ferramentas:

1. fazer uso de tool define uma ferramenta de calculadora simples, incluindo a lógica de operação e o esquema de parâmetros.
2. Inicializar o modelo ChatOllama.
3. fazer uso de bindTools vincula a ferramenta ao modelo.
4. fazer uso de invoke envia um problema que precisa ser computado e o modelo chama automaticamente a ferramenta apropriada.

4. uso avançado

Modelos personalizados de avisos

Os modelos de prompt personalizados não apenas aumentam a eficiência da geração de conteúdo, mas também garantem a consistência e a relevância do resultado. Com modelos bem projetados, podemos utilizar totalmente os recursos do modelo de IA e, ao mesmo tempo, manter o controle e a orientação sobre o conteúdo de saída:

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));

Execute o código:

node advanced_prompt.js

Este código mostra como criar e usar um modelo de prompt personalizado:

1. Definir modelos de mensagens do sistema e de mensagens humanas.
2. fazer uso de ChatPromptTemplate.fromMessages Crie um modelo de prompt completo.
3. fazer uso de pipe conecta o modelo de sinalização ao modelo, criando uma cadeia de processamento.
4. Defina uma função para gerar uma descrição de produto que use uma cadeia de processamento para processar as informações de entrada do produto.

Os modelos de prompt personalizados têm uma grande variedade de usos na prática, especialmente quando você precisa gerar conteúdo em um formato ou estilo específico. Veja abaixo alguns cenários de aplicação prática:

1. Geração de descrição de produtos de comércio eletrônico: conforme mostrado neste exemplo, pode ser usado para gerar automaticamente diferentes estilos de descrições de produtos para melhorar a atratividade da página do produto e a taxa de conversão.
2. Modelos de resposta de atendimento ao cliente: você pode criar modelos de resposta para vários cenários, como tratamento de reclamações, fornecimento de informações sobre produtos, etc., para garantir consistência e profissionalismo nas respostas de atendimento ao cliente.
3. Geração de matérias jornalísticas: os modelos podem ser projetados para gerar diferentes tipos de matérias jornalísticas, como notícias de última hora, análises aprofundadas etc., para ajudar os jornalistas a redigir rapidamente seus primeiros rascunhos.
4. E-mails de marketing personalizados: gere conteúdo de e-mail de marketing personalizado com base nos dados do cliente e nos objetivos de marketing para aumentar a eficácia do marketing por e-mail.

Saída JSON avançada e geração de gráfico de conhecimento

Neste exemplo, mostramos como o Ollama e o LangChain podem ser usados para gerar saída JSON estruturada, especialmente para criar gráficos de conhecimento. Essa abordagem está intimamente relacionada ao projeto de código aberto GraphRAG da Microsoft, especialmente na automatização da extração de conhecimento e geração de tríades.

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);

Execute o código:

node advanced_json.js

Este código demonstra como gerar uma saída JSON estruturada usando o Ollama:

1. Define um modelo de sistema que especifica a estrutura JSON desejada.
2. Crie um modelo de prompt humano para gerar solicitações para o Knowledge Graph.
3. Inicialize o modelo ChatOllama, defina o format: "json" para obter a saída JSON.
4. Defina uma função para gerar um gráfico de conhecimento médico que combine mensagens do sistema e mensagens humanas e chame o modelo.

Podemos ter uma ideia das várias maneiras pelas quais isso pode ser usado por meio de saídas específicas no formato json:

1. Geração ternária automatizada Em abordagens tradicionais, a criação de gráficos de conhecimento geralmente requer uma quantidade significativa de trabalho de rotulagem manual. Os especialistas precisam ler cuidadosamente os documentos, identificar conceitos importantes e seus relacionamentos e, em seguida, criar manualmente triplas (sujeito-relacionamento-objeto). Esse processo não é apenas demorado, mas também propenso a erros, especialmente quando se lida com um grande número de documentos. Com a nossa abordagem, o Big Language Model pode gerar automaticamente nós e relações relevantes a partir de determinados assuntos e conceitos. Isso acelera muito o processo de construção do gráfico de conhecimento.
2. Aprimoramento de dados Essa abordagem pode ser usada não apenas para a geração direta de gráficos de conhecimento, mas também para o aprimoramento de dados. Por exemplo:
   • Ampliação do conjunto de dados de treinamento existente: fazendo com que o modelo gere novas triplas relevantes com base nas triplas existentes.
   • Criação de exemplos diversos: a geração de gráficos de conhecimento para diferentes condições médicas acrescenta diversidade aos dados.
   • Geração de dados em vários idiomas: ao ajustar os prompts, é possível gerar gráficos de conhecimento em diferentes idiomas para dar suporte a aplicativos multilíngues.
3. Melhorar a qualidade dos dados O Big Language Model pode ser aproveitado para gerar gráficos de conhecimento coerentes e de alta qualidade a partir de sua ampla base de conhecimento. Com prompts bem projetados, podemos garantir que os dados gerados atendam a padrões de qualidade e especificações de domínio específicos.
4. Flexibilidade e escalabilidade Essa abordagem é muito flexível e pode ser facilmente adaptada a diferentes áreas e necessidades:
   • Ao modificar os prompts do sistema, podemos alterar a estrutura JSON da saída para acomodar diferentes formatos de gráficos de conhecimento.
   • É fácil estender essa abordagem a outras áreas, como tecnologia, finanças, educação, etc.

chegar a um veredicto

Com esses exemplos, mostramos como usar o Ollama e o LangChain para criar uma variedade de aplicativos de IA em um ambiente JavaScript, desde sistemas de diálogo simples até a complexa geração de gráficos de conhecimento. Essas ferramentas e técnicas fornecem uma base sólida para o desenvolvimento de aplicativos avançados de IA.

A combinação de Ollama e LangChain oferece aos desenvolvedores grande flexibilidade e possibilidades. Você pode escolher os modelos e componentes certos de acordo com suas necessidades específicas e criar um sistema de IA que se adapte ao cenário do seu aplicativo.

À medida que a tecnologia continua a evoluir, esperamos ver o surgimento de aplicativos mais inovadores. Esperamos que este guia o ajude a iniciar sua jornada de desenvolvimento de IA e inspire sua criatividade para explorar as infinitas possibilidades da tecnologia de IA.