Créez votre première application LLM avec Langchain & TypeScript

Apprenez les étapes rapides et faciles pour construire votre première application TypeScript LLM à l’aide de Langchain et du modèle OpenAI.

Dans cet article, je vous guiderai à travers un guide étape par étape pour construire votre première application alimentée par LLM en utilisant Lubriole et le Openai modèle. J’utiliserai TypeScript pour créer l’application, et à la fin, vous aurez un traducteur de travail construit avec le modèle OpenAI GPT-4 et le package de messagerie de Langchain.

Configurer le projet

Pour commencer, créez une application Node.js et installez la bibliothèque Core Langchain à l’intérieur:

npm i langchain @langchain/core

Nous utiliserons TypeScript, alors configurons le projet pour l’utiliser. Pour ce faire, installer:

npm install -D typescript @types/node ts-node

Ensuite, ajoutez le tsconfig.json Fichier dans le projet en exécutant cette commande:

npx tsc –init

Remplacez le fichier tsconfig.json par la configuration ci-dessous.

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Ensuite, mettez à jour le package.json Fichier à utiliser TypeScript pour la création et l’exécution de l’application.

"scripts": {
    "build": "tsc",
    "start": "tsc && node dist/index.js"
  },

Nous allons placer des fichiers de projet dans le SRC dossier, alors créez un dossier nommé SRC Dans votre répertoire de projet et, à l’intérieur, ajouter un fichier appelé index.ts.

Configurer l’environnement

Pour utiliser Langchain avec divers modèles de langue, vous aurez besoin de clés API. Nous stockons ces clés dans un fichier environnement. Travailler avec le .env fichier, vous devrez avoir installé le dotenv dépendance:

npm install dotenv

Ensuite, ajoutez le fichier .env au projet root et collez les informations ci-dessous à l’intérieur du fichier.

OPENAI_API_KEY= "..."
export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="..."

# Other common environment variables
NODE_ENV=development
PORT=3000

Enfin, nous devons installer le type pour les variables d’environnement, ce qui peut être effectué en exécutant la commande suivante:

npm install -D @types/dotenv

Maintenant, dans le fichier d’index, lisez les variables d’environnement comme ci-dessous:

import dotenv from 'dotenv';
dotenv.config();

const openaiApiKey: string | undefined = process.env.OPENAI_API_KEY;
const langChainKey: string | undefined = process.env.LANGSMITH_API_KEY;
const port: number = parseInt(process.env.PORT || '3000', 10);
console.log(`OpenAI API Key: ${openaiApiKey}`);
console.log(`LangChain API Key: ${langChainKey}`);

Vous devriez pouvoir imprimer vos touches Openai et Langsmith. Remplacez-les par les clés de votre abonnement dans votre projet.

Travailler avec le modèle

Nous allons utiliser le modèle OpenAI. Pour l’utiliser, installez le langchain openai Dépendance dans le projet:

npm i @langchain/openai

Après avoir installé la bibliothèque OpenAI, utilisons-la pour traduire le texte. Tout d’abord, importez les packages suivants:

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";

Après l’installation, créez un objet modèle et définissez le système et les messages humains à l’aide du package Langchain Messages pour traduire le texte.

const model = new ChatOpenAI({ model: "gpt-4" });
const messages = [
  new SystemMessage("Translate the following from English into Italian"),
  new HumanMessage("hi!"),
];

async function translate(){
 let m =   await model.invoke(messages);
 console.log(m);
}

translate();

Pour utiliser le modèle OpenAI et traduire le texte:

• Configurer le modèle
• Structurez le message
• Le message système agit comme une instruction pour définir le contexte du modèle
• Le message humain construit le message d’entrée réel à traduire

Tout assembler, une application LLM simple pour traduire le texte devrait ressembler à ceci:

import dotenv from 'dotenv';
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";

dotenv.config();

const openaiApiKey: string | undefined = process.env.OPENAI_API_KEY;
const langChainKey: string | undefined = process.env.LANGSMITH_API_KEY;

const model = new ChatOpenAI({ model: "gpt-4" });
const messages = [
  new SystemMessage("Translate the following from English into Italian"),
  new HumanMessage("What rooms are available in the hotel?"),
];

async function translate(){
 let m =   await model.invoke(messages);
 console.log(m);
}

translate();

Vous devriez obtenir une sortie comme ceci:

Étant donné que les modèles Langchain sont exécutés, ils prennent également en charge la sortie de streaming. Nous pouvons convertir le résultat ci-dessus en une réponse de streaming comme indiqué ci-dessous:

async function translate(){

 const stream = await model.stream(messages);
 for await (const chunk of stream) {
    console.log(chunk.content);
  }
 console.log('\n');
}

translate();

Avec le streaming, vous gardez essentiellement une connexion en direct avec le modèle OpenAI. C’est super utile pour les traductions plus longues ou lorsque vous souhaitez donner des commentaires instantanés aux utilisateurs. Au lieu d’attendre que le tout se charge, ils peuvent voir la traduction apparaître mot par mot – tout comme si elle était tapée en temps réel. Vous obtiendrez une sortie en streaming comme indiqué ci-dessous:

Vous savez maintenant qu’il est facile de créer votre première application LLM à l’aide de Langchain, Openai GPT-4 et TypeScript. J’espère que vous trouverez cet article utile. Merci d’avoir lu.