Un guide complet de Langchain en JavaScript

Langchainjs: un cadre puissant pour construire des modèles et des agents de langue JavaScript dirigés par AI-AI

Points de base:

• Langchainjs est un puissant framework JavaScript qui permet aux développeurs de construire et d'expérimenter avec des modèles de langage et des agents axés sur l'IA qui sont intégrés de manière transparente dans les applications Web.
• Ce cadre permet à la création d'agents qui peuvent tirer parti de divers outils et sources de données pour effectuer des tâches de langage complexes telles que les recherches sur Internet et les calculs mathématiques, améliorant ainsi la précision et la pertinence des réponses.
• Langchain prend en charge une variété de modèles, y compris des modèles de langage pour une sortie de texte simple, des modèles de chat pour des conversations interactives et des modèles d'intégration pour convertir du texte en vecteurs numériques, facilitant ainsi le développement de diverses applications PNL.
• Les données de texte peuvent être gérées et traitées efficacement grâce à des méthodes de chasse personnalisables, assurant des performances optimales et une pertinence contextuelle lors du traitement du texte important.
• En plus d'utiliser le modèle OpenAI, Langchain est compatible avec d'autres modèles de langage grand (LLMS) et des services d'IA, offrant des capacités de flexibilité et d'extension pour les développeurs explorant l'intégration de différentes IA dans leurs projets.

Ce guide plongera dans les composants clés de Langchain et montrera comment tirer parti de sa puissance en JavaScript. Langchainjs est un cadre JavaScript commun qui permet aux développeurs et aux chercheurs de créer, expérimenter et analyser les modèles et les agents linguistiques. Il offre aux amateurs de traitement du langage naturel (PNLP) avec une multitude de capacités, de la construction de modèles personnalisés à une manipulation efficace de données de texte. En tant que cadre JavaScript, il permet également aux développeurs d'intégrer facilement leurs applications AI dans les applications Web.

Prérequis:

Pour apprendre cet article, créez un nouveau dossier et installez le package NPM Langchain:

<code class="language-bash">npm install -S langchain</code>

Après avoir créé un nouveau dossier, utilisez le suffixe .mjs pour créer un nouveau fichier de module JS (par exemple test1.mjs).

AGENTS:

Dans Langchain, un agent est une entité qui peut comprendre et générer du texte. Ces agents peuvent configurer des comportements et des sources de données spécifiques et sont formés pour effectuer diverses tâches liées à la langue, ce qui en fait un outil multifonctionnel pour une variété d'applications.

Créer Langchain Agent:

Les agences peuvent être configurées pour utiliser des "outils" pour collecter les données requises et développer une bonne réponse. Veuillez consulter l'exemple ci-dessous. Il utilise l'API SERP (une API de recherche sur Internet) pour rechercher des informations liées à une question ou une entrée et y répondre. Il utilise également l'outil llm-math pour effectuer des opérations mathématiques - par exemple, la conversion des unités ou la recherche d'un pourcentage de variation entre deux valeurs:

<code class="language-bash">npm install -S langchain</code>

Après avoir créé des variables de modèle en utilisant modelName: "gpt-3.5-turbo" et temperature: 0, nous créons un exécuteur qui combine le modèle créé avec les outils spécifiés (Serpapi et calculatrice). Dans l'entrée, j'ai demandé à LLM de rechercher sur Internet (en utilisant Serpapi) et de savoir quel artiste a publié plus d'albums depuis 2010 - Nas ou Boldy James - et afficher la différence en pourcentage (en utilisant la calculatrice).

Dans cet exemple, je dois dire explicitement à LLM de "via la recherche d'Internet ..." pour qu'il utilise Internet pour obtenir des données jusqu'à aujourd'hui, plutôt que d'utiliser OpenAI par défaut à 2021 uniquement.

La sortie est la suivante:

<code class="language-javascript">import { initializeAgentExecutorWithOptions } from "langchain/agents";
import { ChatOpenAI } from "langchain/chat_models/openai";
import { SerpAPI } from "langchain/tools";
import { Calculator } from "langchain/tools/calculator";

process.env["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"
process.env["SERPAPI_API_KEY"] = "YOUR_SERPAPI_KEY"

const tools = [new Calculator(), new SerpAPI()];
const model = new ChatOpenAI({ modelName: "gpt-3.5-turbo", temperature: 0 });

const executor = await initializeAgentExecutorWithOptions(tools, model, {
  agentType: "openai-functions",
  verbose: false,
});

const result = await executor.run("通过搜索互联网，查找Boldy James自2010年以来发行了多少张专辑，以及Nas自2010年以来发行了多少张专辑？找出谁发行了更多专辑，并显示百分比差异。");
console.log(result);</code>

Modèles (modèles):

Il existe trois types de modèles dans Langchain: LLM, modèle de chat et modèle d'intégration de texte. Explorons chaque type de modèle avec quelques exemples.

Modèle de langue:

Langchain fournit un moyen d'utiliser des modèles de langage en JavaScript pour générer une sortie de texte en fonction de l'entrée de texte. Il n'est pas aussi complexe que le modèle de chat et est le mieux adapté aux tâches de langage de sortie d'entrée. Voici un exemple utilisant Openai:

<code>// 输出将取决于互联网搜索结果</code>

Comme vous pouvez le voir, il utilise le modèle gpt-3.5-turbo pour répertorier toutes les baies rouges. Dans cet exemple, j'ai réglé la température à 0 pour donner la précision de facto LLM.

Sortie:

<code class="language-javascript">import { OpenAI } from "langchain/llms/openai";

const llm = new OpenAI({
  openAIApiKey: "YOUR_OPENAI_KEY",
  model: "gpt-3.5-turbo",
  temperature: 0
});

const res = await llm.call("列出所有红色的浆果");

console.log(res);</code>

Modèle de chat:

Si vous voulez des réponses et des conversations plus complexes, vous devez utiliser le modèle de chat. Techniquement, en quoi le modèle de chat est-il différent d'un modèle de langue? Dans les mots de la documentation de Langchain:

Le modèle de chat est une variante du modèle de langue. Bien que les modèles de chat utilisent des modèles de langue en arrière-plan, ils utilisent des interfaces légèrement différentes. Au lieu d'utiliser l'API "Entrée de texte, sortie de texte", ils utilisent le "message de chat" comme interface pour l'entrée et la sortie.

Il s'agit d'un script de modèle de chat JavaScript simple (tout à fait inutile mais intéressant):

<code>// 输出将列出红色的浆果</code>

Comme vous pouvez le voir, le code envoie d'abord un message système et dit au chatbot de devenir un assistant poétique qui répond toujours avec des rimes, puis il envoie un message humain disant au chatbot pour me dire qui est le meilleur joueur de tennis: De Jokovic, Federer ou Nadal. Si vous exécutez ce modèle de chatbot, vous verrez quelque chose comme ceci:

<code class="language-javascript">import { ChatOpenAI } from "langchain/chat_models/openai";
import { PromptTemplate } from "langchain/prompts";

const chat = new ChatOpenAI({
  openAIApiKey: "YOUR_OPENAI_KEY",
  model: "gpt-3.5-turbo",
  temperature: 0
});
const prompt = PromptTemplate.fromTemplate(`你是一个诗意的助手，总是用押韵来回答：{question}`);
const runnable = prompt.pipe(chat);
const response = await runnable.invoke({ question: "谁更好，德约科维奇、费德勒还是纳达尔？" });
console.log(response);</code>

Embeddings:

Le modèle d'emballage fournit un moyen de convertir les mots et les nombres en texte en vecteurs qui peuvent ensuite être associés à d'autres mots ou nombres. Cela peut sembler abstrait, alors regardons un exemple:

<code>// 输出将是一个用押韵回答的问题</code>

Cela renverra une longue liste de numéros de points flottants:

<code class="language-javascript">import { OpenAIEmbeddings } from "langchain/embeddings/openai";

process.env["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"

const embeddings = new OpenAIEmbeddings();
const res = await embeddings.embedQuery("谁创造了万维网？");
console.log(res)</code>

C'est à quoi ressemble l'intégration. Il y a tellement de numéros de points flottants en seulement six mots!

Cette intégration peut ensuite être utilisée pour associer le texte d'entrée à des réponses potentielles, à un texte connexe, des noms, etc.

Regardons un cas d'utilisation pour les modèles intégrés maintenant ...

Maintenant, c'est un script qui utilisera des intégres pour obtenir la question "Quel est le plus lourd animal?"

<code class="language-bash">npm install -S langchain</code>

morceaux:

Les modèles Langchain ne peuvent pas traiter de grands textes et les utiliser pour générer des réponses. C'est là que la segmentation du bunking et du texte entre en jeu. Permettez-moi de vous montrer deux façons simples de diviser les données de texte en morceaux avant de les nourrir à Langchain.

segment par caractère:

Pour éviter les interruptions soudaines de set, vous pouvez diviser le texte par paragraphe en divisant chaque occurrence d'un caractère de Newline:

<code class="language-javascript">import { initializeAgentExecutorWithOptions } from "langchain/agents";
import { ChatOpenAI } from "langchain/chat_models/openai";
import { SerpAPI } from "langchain/tools";
import { Calculator } from "langchain/tools/calculator";

process.env["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"
process.env["SERPAPI_API_KEY"] = "YOUR_SERPAPI_KEY"

const tools = [new Calculator(), new SerpAPI()];
const model = new ChatOpenAI({ modelName: "gpt-3.5-turbo", temperature: 0 });

const executor = await initializeAgentExecutorWithOptions(tools, model, {
  agentType: "openai-functions",
  verbose: false,
});

const result = await executor.run("通过搜索互联网，查找Boldy James自2010年以来发行了多少张专辑，以及Nas自2010年以来发行了多少张专辑？找出谁发行了更多专辑，并显示百分比差异。");
console.log(result);</code>

C'est un moyen utile de diviser le texte. Cependant, vous pouvez utiliser n'importe quel personnage comme séparateur de morceaux, pas seulement

. n

segmentant récursivement Chunking:

Si vous souhaitez diviser strictement le texte par des caractères d'une certaine longueur, vous pouvez utiliser

: RecursiveCharacterTextSplitter

<code>// 输出将取决于互联网搜索结果</code>

Dans cet exemple, le texte est divisé tous les 100 caractères, et les morceaux se chevauchent à 15 caractères.

Taille et chevauchement des blocs:

En regardant ces exemples, vous avez peut-être commencé à vous demander ce que signifient la taille de la taille et les paramètres de chevauchement et comment ils affectent les performances. Ok, laissez-moi expliquer brièvement deux choses.

La taille du morceau détermine le nombre de caractères dans chaque morceau. Plus la taille du morceau est grande, plus il y a de données dans le morceau, plus il faut Langchain pour le traiter et générer la sortie, et vice versa.
Le chevauchement des blocs est le contenu qui partage des informations entre les blocs afin qu'ils partagent un certain contexte. Plus le chevauchement du morceau est élevé, plus vos morceaux seront redondants; plus le chevauchement du morceau est bas, moins le contexte partageait entre les morceaux. En règle générale, un bon chevauchement de section est d'environ 10% à 20% de la taille de la section, bien que le chevauchement de section souhaité varie selon différents types de texte et cas d'utilisation.

chaînes:

Le chapitre est essentiellement des fonctions LLM multiples liées ensemble pour effectuer des tâches plus complexes, sinon elle ne peut pas être effectuée via la sortie LLM simple-& GT. Regardons un exemple sympa:

<code class="language-javascript">import { OpenAI } from "langchain/llms/openai";

const llm = new OpenAI({
  openAIApiKey: "YOUR_OPENAI_KEY",
  model: "gpt-3.5-turbo",
  temperature: 0
});

const res = await llm.call("列出所有红色的浆果");

console.log(res);</code>

au-delà de l'Openai:

Même si j'utilise le modèle OpenAI comme exemple de différentes fonctions de Langchain, elle n'est pas limitée au modèle OpenAI. Vous pouvez utiliser Langchain avec de nombreux autres services LLM et AI. Vous pouvez trouver une liste complète des LLM intégrés Langchain et JavaScript dans leur documentation.

Par exemple, vous pouvez utiliser Cohere avec Langchain. Après avoir installé Cohere, en utilisant

, vous pouvez créer un code de questions-réponses simple à l'aide de Langchain et Cohere, comme indiqué ci-dessous: npm install cohere-ai

<code>// 输出将列出红色的浆果</code>

Sortie:

<code class="language-javascript">import { ChatOpenAI } from "langchain/chat_models/openai";
import { PromptTemplate } from "langchain/prompts";

const chat = new ChatOpenAI({
  openAIApiKey: "YOUR_OPENAI_KEY",
  model: "gpt-3.5-turbo",
  temperature: 0
});
const prompt = PromptTemplate.fromTemplate(`你是一个诗意的助手，总是用押韵来回答：{question}`);
const runnable = prompt.pipe(chat);
const response = await runnable.invoke({ question: "谁更好，德约科维奇、费德勒还是纳达尔？" });
console.log(response);</code>

Conclusion:

Dans ce guide, vous avez vu différents aspects et fonctions de Langchain en JavaScript. Vous pouvez facilement développer des applications Web alimentées par AI en JavaScript à l'aide de Langchain et expérimenter avec LLM. Assurez-vous de vous référer à la documentation LangchainJS pour plus de détails sur les fonctionnalités spécifiques.

Je vous souhaite un codage et d'expérimenter avec Langchain en JavaScript! Si vous aimez cet article, vous pouvez également lire des articles sur l'utilisation de Langchain avec Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!