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" (tipo: "módulo") para ativar o suporte ao módulo ES:

{
"type": "module", // ...
// ... Outras configurações
}

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  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:\Usuários\Administrador\.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:

importar { Ollama } de "@langchain/community/llms/ollama" ;
const ollama = new Ollama({
baseUrl: "http://localhost:11434", // certifique-se de que o serviço Ollama esteja iniciado
model: "ollama3.1", // substitua pelo modelo real usado
}); const stream = await ollama.
const stream = await ollama.stream(
`Você é melhor que o 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 fluxo 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"); // pode ser substituído pela imagem que você deseja solicitar
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("Qual animal está na imagem?") console.log({ res })
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 vincular vincula os dados da imagem ao modelo.
3. fazer uso de invocar 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:

importar { tool } de "@langchain/core/tools" ;
import { ChatOllama } de "@langchain/ollama".
import { z } from "zod";
// Definir a ferramenta de calculadora simples
const simpleCalculatorTool = tool((args) => {
const { operation, x, y } = args;
switch (operation) {
case "add".
retorna x + y;
case "subtrair".
return x - y; case "multiply": return x + y
case "multiply".
return x * y; case "divide": return x - y; case "multiply": return x - y
case "divide": if (y !
se (y ! == 0) {
return x / y; } else { if (y ! == 0)
} else {
throw new Error("Cannot divide by zero"); }
}
default.
throw new Error("Operação inválida"); } default.
}
}, {
name: "simple_calculator", description: "Executa operações aritméticas simples", {
description: "Executa operações aritméticas simples", { name: "simple_calculator", description: "Executa operações aritméticas simples", } }
schema: z.object({
operations: z.enum(["add", "subtract", "multiply", "divide"]), x: z.number(), z.number(), z.number(), z.number(), z.number()
x: z.number(),
y: z.number(),
}), }
}).
// Definir o modelo
const llm = new ChatOllama({
model: "llama3.1",
temperature: 0, }); // Defina o modelo.
}); // Vincule a ferramenta ao modelo.
// Vincular ferramentas ao modelo
const llmWithTools = llm.bindTools([simpleCalculatorTool]);
// Usar o modelo para chamadas de ferramentas
const result = await llmWithTools.invoke(
"Você sabe quanto é 10 milhões vezes dois? Por favor, use a ferramenta 'simple_calculator' para calculá-lo."
);
console.log(result);

Execute o código:

node base_tool.js

Este código mostra como definir e usar ferramentas:

1. fazer uso de ferramenta 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 invocar 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:

importar { ChatOllama } de "@langchain/ollama"; ;
import { ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate } from "@langchain/core/prompts";
// Inicializar o modelo do ChatOllama
const model = new ChatOllama({
model: "llama3.1",
temperature: 0.7, }); // Inicializa o modelo do ChatOllama.
});
const systemMessageContent = `
Você é um especialista experiente em redação de comércio eletrônico. Sua tarefa é criar descrições de itens envolventes com base nas informações fornecidas sobre o produto.
Certifique-se de que sua descrição seja concisa, poderosa e destaque os principais benefícios do produto.
`;
const humanMessageTemplate = `
Por favor, crie uma descrição de produto atraente para o seguinte produto:
Tipo de produto: {product_type}
Principais recursos: {key_feature}
Público-alvo: {target_audience}
Faixa de preço: {price_range}
Posicionamento da marca: {posicionamento_da_marca}
Forneça uma descrição de cada um dos três estilos diferentes a seguir em aproximadamente 50 palavras cada:
1. análise racional
2. apelo emocional
3. narração de histórias
`; const prompt = ChatPrompt
const prompt = ChatPromptTemplate.fromMessages([
SystemMessagePromptTemplate.fromTemplate(systemMessageContent),
HumanMessagePromptTemplate.fromTemplate(humanMessageTemplate),
]); const chain = prompt.pipe(model), humanMessagePromptTemplate.
const chain = prompt.pipe(model);
função async generateProductDescriptions(productInfo) {
const response = await chain.invoke(productInfo); async function generateProductDescriptions(productInfo) {
return response.content; }
}
// Exemplo de uso
const productInfo = {
product_type: "Smartwatch", key_feature: "Heart rate monitor and sleep analytics", }
key_feature: "Monitor de frequência cardíaca e análise do sono",
target_audience: "Jovens profissionais preocupados com a saúde",

brand_positioning: "A combinação perfeita de tecnologia e saúde"
};
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 tubulação 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 = `
Você é um especialista na área médica e se especializou na criação de gráficos de conhecimento. Por favor, formate todas as respostas como objetos JSON com a seguinte estrutura:
{
"node": [
{ "id": "string", "label": "string", "type": "string"}
],
"relationship" (relação): [
{ "source": "string", "target": "string", "relationship": "string"}
]
}
Certifique-se de que todos os IDs de nó sejam exclusivos e que a relação faça referência a um ID de nó pré-existente.
`;
const humanTemplate = `
Por favor, crie um gráfico de conhecimento para o tópico médico "{topic}". Inclua os seguintes conceitos relacionados: {concepts}.
Forneça pelo menos 5 nós e 5 relações. Certifique-se de responder em chinês.
`;
const systemMessage = new SystemMessage(systemTemplate);
const humanPrompt = PromptTemplate.fromTemplate(humanTemplate);
const llmJsonMode = new ChatOllama({
baseUrl: "http://localhost:11434", // valor padrão
model: "llama3.1", format: "json", // valor padrão
formato: "json", // padrão
}).
função async generateMedicalKnowledgeGraph(topic, concepts) {
try {
const humanMessageContent = await humanPrompt.format({
topic: topic, concepts: concepts.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("Error generating knowledge graph:", error); }
}
}
// Exemplo de uso
const topic = "Diabetes";
const concepts = ["insulin", "blood glucose", "complications", "dietary management", "exercise therapy"]; const concepts = ["insulin", "blood glucose", "complications", "dietary management", "exercise therapy"]; }
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 formato: "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.