Comment extraire et générer des données JSON avec GPT, LangChain et Node.js

Dans cet article de blog, je vais partager comment utiliser LangChain, un framework flexible pour créer des applications pilotées par l'IA, pour extraire et générer des données JSON structurées avec GPT et Node.js. Je fournirai des extraits de code et des instructions concises pour vous aider à configurer et à exécuter le projet.

À propos de LangChain

LangChain est un framework innovant et polyvalent conçu pour rationaliser le développement d'applications basées sur l'IA.

Avec son architecture modulaire, il fournit une suite complète de composants pour créer des modèles d'invite, se connecter à diverses sources de données et interagir de manière transparente avec divers outils.

En simplifiant l'ingénierie rapide, l'intégration des sources de données et l'interaction avec les outils, LangChain permet aux développeurs de se concentrer sur la logique d'application de base, accélérant ainsi le processus de développement.

Disponible dans les API Python et JavaScript, LangChain est hautement adaptable, permettant aux développeurs d'exploiter la puissance du traitement du langage naturel et de l'IA sur plusieurs plates-formes et cas d'utilisation.

LangChain contient des outils qui permettent d'obtenir une sortie structurée (comme au format JSON) à partir des LLM. Utilisons-les à notre avantage.

Installation et configuration

Je suppose que vous avez l'une des dernières versions de NodeJS. J'ai utilisé le nœud 18. Visitez le site Web de LangChain si vous avez besoin de plus de détails.

Tout d'abord, créez un nouveau projet de nœud, c'est-à-dire :

1. Créez un nouveau répertoire pour votre projet et accédez-y dans votre terminal.

   
   

2. Exécutez npm init pour initialiser un nouveau projet Node.js.

   
   

3. Créez un fichier index.js .

Ensuite, installons LangChain et configurons les clés API. D'autres dépendances sont incluses.

 npm i langchain # configure credentials (easiest) export OPENAI_API_KEY=XXX export SERPAPI_API_KEY=XXX

Ceci est juste pour une utilisation démonstrative. Je préfère ne pas exporter de variables ; J'utilise à la place la bibliothèque populaire dotenv npm.

Importons les dépendances requises au-dessus de notre fichier JS.

 import { z } from "zod"; import { OpenAI } from "langchain/llms/openai"; import { PromptTemplate } from "langchain/prompts"; import { StructuredOutputParser, OutputFixingParser, } from "langchain/output_parsers";

Génération de données

Commençons par générer de fausses données pour voir les possibilités d'analyse.

Définition du schéma de sortie

Tout d'abord, nous devons dire à la bibliothèque ce que nous voulons obtenir. LangChain prend en charge la définition du schéma attendu à l'aide d'une bibliothèque populaire appelée Zod :

 const parser = StructuredOutputParser.fromZodSchema( z.object({ name: z.string().describe("Human name"), surname: z.string().describe("Human surname"), age: z.number().describe("Human age"), appearance: z.string().describe("Human appearance description"), shortBio: z.string().describe("Short bio secription"), university: z.string().optional().describe("University name if attended"), gender: z.string().describe("Gender of the human"), interests: z .array(z.string()) .describe("json array of strings human interests"), }) );

Modèle d'invite

Pour utiliser ce modèle, nous devons créer une construction LangChain appelée PromptTemplate. Il contiendra les instructions de format de l'analyseur :

 const formatInstructions = parser.getFormatInstructions(); const prompt = new PromptTemplate({ template: `Generate details of a hypothetical person.\n{format_instructions} Person description: {description}`, inputVariables: ["description"], partialVariables: { format_instructions: formatInstructions }, });

Essaye le

Pour exécuter la sortie structurée, appelez le modèle OpenAI avec l'entrée :

 const model = new OpenAI({ temperature: 0.5, model: "gpt-3.5-turbo" }); const input = await prompt.format({ description: "A man, living in Poland", }); const response = await model.call(input);

Voici ce qui sera envoyé au modèle d'IA. Cela changera très probablement dans les futures versions de LangChain.

 Generate details of a hypothetical person. You must format your output as a JSON value that adheres to a given "JSON Schema" instance. "JSON Schema" is a declarative language that allows you to annotate and validate JSON documents. For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}} would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings. Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted. Your output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match exactly! Here is the JSON Schema instance your output must adhere to: '''json {"type":"object","properties":{"name":{"type":"string","description":"Human name"},"surname":{"type":"string","description":"Human surname"},"age":{"type":"number","description":"Human age"},"appearance":{"type":"string","description":"Human appearance description"},"shortBio":{"type":"string","description":"Short bio secription"},"university":{"type":"string","description":"University name if attended"},"gender":{"type":"string","description":"Gender of the human"},"interests":{"type":"array","items":{"type":"string"},"description":"json array of strings human interests"}},"required":["name","surname","age","appearance","shortBio","gender","interests"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"} ''' Person description: A man, living in Poland.

La sortie du modèle ressemblera à ceci :

 { "name": "Adam", "surname": "Kowalski", "age": 21, "appearance": "Adam is a tall and slim man with short dark hair and blue eyes.", "shortBio": "Adam is a 21 year old man from Poland. He is currently studying computer science at the University of Warsaw.", "university": "University of Warsaw", "gender": "Male", "interests": ["Computer Science", "Cooking", "Photography"] }

Comme vous pouvez le voir, nous avons obtenu exactement ce dont nous avions besoin. Nous pouvons générer des identités entières avec des descriptions complexes correspondant à d'autres parties de la personnalité. Si nous devions enrichir notre ensemble de données fictives, nous pourrions alors demander à un autre modèle d'IA de générer une photo basée sur l'apparence.

La gestion des erreurs

Vous vous demandez peut-être si l'utilisation de LLM dans une application de production est sans danger. Heureusement, LangChain se concentre sur des problèmes comme celui-ci. Si la sortie doit être corrigée, utilisez OutputFixingParser. Il essaiera de corriger les erreurs au cas où votre LLM sortirait quelque chose qui ne correspondrait pas à vos besoins.

 try { console.log(await parser.parse(response)); } catch (e) { console.error("Failed to parse bad output: ", e); const fixParser = OutputFixingParser.fromLLM( new OpenAI({ temperature: 0, model: "gpt-3.5-turbo" }), parser ); const output = await fixParser.parse(response); console.log("Fixed output: ", output); }

Extraction de données à partir de fichiers

Pour charger et extraire des données de fichiers à l'aide de LangChain, vous pouvez suivre ces étapes. Dans cet exemple, nous allons charger le fichier PDF. Commodément, LangChain a des utilitaires juste à cette fin. Nous avons besoin d'une dépendance supplémentaire.

 npm install pdf-parse

Nous allons charger une courte biographie d'Elon Musk et extraire les informations que nous avons précédemment générées. Téléchargez le fichier PDF ici : google drive .

Tout d'abord, créons un nouveau fichier, par exemple, structured-pdf.js . Commençons par charger le PDF.

 import { PDFLoader } from "langchain/document_loaders/fs/pdf"; const loader = new PDFLoader("./elon.pdf"); const docs = await loader.load(); console.log(docs);

Nous devons modifier le modèle d'invite pour indiquer l'extraction, pas la génération. J'ai également dû modifier une invite pour résoudre le problème de rendu JSON, car les résultats étaient parfois incohérents.

 const prompt = new PromptTemplate({ template: "Extract information from the person description.\n{format_instructions}\nThe response should be presented in a markdown JSON codeblock.\nPerson description: {inputText}", inputVariables: ["inputText"], partialVariables: { format_instructions: formatInstructions }, });

Enfin, nous devons étendre la longueur de sortie que nous autorisons (c'est un peu plus de données que dans le cas généré), car la valeur par défaut est de 256 jetons. Nous devons également appeler le modèle en utilisant notre document chargé, et non une description de personne prédéterminée.

 const model = new OpenAI({ temperature: 0.5, model: "gpt-3.5-turbo", maxTokens: 2000 }); const input = await prompt.format({ inputText: docs[0].pageContent, });

Grâce à ces modifications, nous obtenons la sortie suivante :

 { name: 'Elon', surname: 'Musk', age: 51, appearance: 'normal build, short-cropped hair, and a trimmed beard', // truncated by me shortBio: "Elon Musk, a 51-year-old male entrepreneur, inventor, and CEO, is best known for his...', gender: 'male', interests: [ 'space exploration', 'electric vehicles', 'artificial intelligence', 'sustainable energy', 'tunnel construction', 'neural interfaces', 'Mars colonization', 'hyperloop transportation' ] }

En suivant ces étapes, nous avons extrait des données JSON structurées d'un fichier PDF ! Cette approche est polyvalente et peut être adaptée à votre cas d'utilisation spécifique.

Conclusion

En conclusion, en tirant parti de LangChain, des GPT et de Node.js, vous pouvez créer des applications puissantes pour extraire et générer des données JSON structurées à partir de diverses sources.

Les applications potentielles sont vastes et, avec un peu de créativité, vous pouvez utiliser cette technologie pour créer des applications et des solutions innovantes.

Vous pouvez trouver le code de ce tutoriel ici : https://gist.github.com/horosin/5351ae4dc3eebbf181f9db212f5d3ebc

Abonnez-vous à mon profil en renseignant votre adresse mail à gauche et soyez au courant de mes articles !

N'oubliez pas de me suivre sur Twitter @ horosin et de vous abonner à la newsletter sur mon blog pour plus de conseils et d'idées !

Si vous n'avez pas Twitter, vous pouvez aussi me suivre sur LinkedIn .