Cómo extraer y generar datos JSON con GPT, LangChain y Node.js

En esta publicación de blog, compartiré cómo usar LangChain, un marco flexible para crear aplicaciones impulsadas por IA, para extraer y generar datos JSON estructurados con GPT y Node.js. Proporcionaré fragmentos de código e instrucciones concisas para ayudarlo a configurar y ejecutar el proyecto.

Acerca de LangChain

LangChain es un marco innovador y versátil diseñado para agilizar el desarrollo de aplicaciones impulsadas por IA.

Con su arquitectura modular, proporciona un conjunto completo de componentes para crear plantillas de solicitud, conectarse a diversas fuentes de datos e interactuar sin problemas con varias herramientas.

Al simplificar la ingeniería rápida, la integración de fuentes de datos y la interacción de herramientas, LangChain permite a los desarrolladores centrarse en la lógica de la aplicación principal, lo que acelera el proceso de desarrollo.

Disponible en las API de Python y JavaScript, LangChain es altamente adaptable y permite a los desarrolladores aprovechar el poder del procesamiento del lenguaje natural y la IA en múltiples plataformas y casos de uso.

LangChain contiene herramientas que hacen que la salida estructurada (como en formato JSON) de los LLM. Usémoslos a nuestro favor.

Instalación y configuración

Supongo que tiene una de las últimas versiones de NodeJS. He usado el nodo 18. Visite el sitio web de LangChain si necesita más detalles.

Primero, cree un nuevo proyecto de nodo, es decir:

1. Cree un nuevo directorio para su proyecto y navegue hasta él en su terminal.

   
   

2. Ejecute npm init para inicializar un nuevo proyecto de Node.js.

   
   

3. Cree un archivo index.js .

Luego, instalemos LangChain y configuremos las claves API. Se incluyen otras dependencias.

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

Esto es solo para uso demostrativo. Prefiero no exportar variables; En su lugar, estoy usando la popular biblioteca dotenv npm.

Importemos las dependencias requeridas encima de nuestro archivo JS.

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

Generación de datos

Comencemos generando algunos datos falsos para ver las posibilidades de análisis.

Definición del esquema de salida

Primero, debemos decirle a la biblioteca lo que queremos obtener. LangChain admite la definición del esquema esperado utilizando una biblioteca popular llamada 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"), }) );

Plantilla de solicitud

Para usar esta plantilla, necesitamos crear una construcción LangChain llamada PromptTemplate. Contendrá instrucciones de formato del analizador:

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

Pruébalo

Para ejecutar la salida estructurada, llame al modelo OpenAI con la entrada:

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

Esto es lo que se enviará al modelo de IA. Lo más probable es que esto cambie en las futuras versiones 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 salida del modelo se verá así:

 { "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"] }

Como puede ver, tenemos justo lo que necesitábamos. Podemos generar identidades completas con descripciones complejas que coincidan con otras partes de la persona. Si necesitáramos enriquecer nuestro conjunto de datos simulados, podríamos pedirle a otro modelo de IA que generara una foto basada en la apariencia.

Manejo de errores

Quizás se pregunte si usar LLM en una aplicación de producción es seguro de alguna manera. Afortunadamente, LangChain se enfoca en problemas como este. En caso de que sea necesario corregir la salida, utilice OutputFixingParser. Intentará corregir errores en caso de que su LLM genere algo que no coincida con sus requisitos.

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

Extracción de datos de archivos

Para cargar y extraer datos de archivos usando LangChain, puede seguir estos pasos. En este ejemplo, vamos a cargar el archivo PDF. Convenientemente, LangChain tiene utilidades solo para este propósito. Necesitamos una dependencia adicional.

 npm install pdf-parse

Vamos a cargar una breve biografía de Elon Musk y extraer la información que hemos generado previamente. Descarga el archivo PDF aquí: google drive .

Primero, creemos un nuevo archivo, por ejemplo, structured-pdf.js . Empecemos por cargar el PDF.

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

Necesitamos modificar la plantilla de solicitud para indicar extracción, no generación. También tuve que modificar un aviso para solucionar el problema de representación de JSON, ya que los resultados a veces eran inconsistentes.

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

Finalmente, necesitamos ampliar la longitud de salida que permitimos (son un poco más de datos que en el caso generado), ya que el valor predeterminado es 256 tokens. También necesitamos llamar al modelo usando nuestro documento cargado, no una descripción de persona predeterminada.

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

Gracias a estas modificaciones, obtenemos el siguiente resultado:

 { 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' ] }

¡Siguiendo estos pasos, hemos extraído datos JSON estructurados de un archivo PDF! Este enfoque es versátil y se puede adaptar para adaptarse a su caso de uso específico.

Conclusión

En conclusión, al aprovechar LangChain, GPT y Node.js, puede crear aplicaciones poderosas para extraer y generar datos JSON estructurados de varias fuentes.

Las aplicaciones potenciales son amplias y, con un poco de creatividad, puede usar esta tecnología para crear aplicaciones y soluciones innovadoras.

Puede encontrar el código para este tutorial aquí: https://gist.github.com/horosin/5351ae4dc3eebbf181f9db212f5d3ebc

¡Suscríbase a mi perfil completando su dirección de correo electrónico a la izquierda y manténgase actualizado con mis artículos!

¡No olvides seguirme en Twitter @ horosin y suscribirte al boletín en mi blog para obtener más consejos e información!

Si no tienes Twitter, también puedes seguirme en LinkedIn .