So extrahieren und generieren Sie JSON-Daten mit GPTs, LangChain und Node.js

In diesem Blogbeitrag werde ich erläutern, wie man LangChain, ein flexibles Framework zum Erstellen KI-gesteuerter Anwendungen, verwendet, um strukturierte JSON-Daten mit GPTs und Node.js zu extrahieren und zu generieren. Ich stelle Ihnen Codeausschnitte und prägnante Anweisungen zur Verfügung, die Sie bei der Einrichtung und Ausführung des Projekts unterstützen.

Über LangChain

LangChain ist ein innovatives und vielseitiges Framework, das die Entwicklung KI-gesteuerter Anwendungen rationalisieren soll.

Mit seiner modularen Architektur bietet es eine umfassende Suite von Komponenten zum Erstellen von Eingabeaufforderungsvorlagen, zur Verbindung mit verschiedenen Datenquellen und zur nahtlosen Interaktion mit verschiedenen Tools.

Durch die Vereinfachung von Prompt Engineering, Datenquellenintegration und Tool-Interaktion ermöglicht LangChain Entwicklern, sich auf die Kernanwendungslogik zu konzentrieren und so den Entwicklungsprozess zu beschleunigen.

LangChain ist sowohl in Python- als auch in JavaScript-APIs verfügbar und äußerst anpassungsfähig, sodass Entwickler die Leistungsfähigkeit der Verarbeitung natürlicher Sprache und der KI über mehrere Plattformen und Anwendungsfälle hinweg nutzen können.

LangChain enthält Tools, die eine strukturierte Ausgabe (wie im JSON-Format) aus LLMs ermöglichen. Nutzen wir sie zu unserem Vorteil.

Installation und Einrichtung

Ich gehe davon aus, dass Sie eine der neuesten Versionen von NodeJS haben. Ich habe Knoten 18 verwendet. Besuchen Sie die LangChain-Website, wenn Sie weitere Informationen benötigen.

Erstellen Sie zunächst ein neues Knotenprojekt, d. h.:

1. Erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie in Ihrem Terminal dorthin.

   
   

2. Führen Sie npm init aus, um ein neues Node.js-Projekt zu initialisieren.

   
   

3. Erstellen Sie eine index.js Datei.

Dann installieren wir LangChain und konfigurieren die API-Schlüssel. Weitere Abhängigkeiten sind enthalten.

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

Dies dient lediglich der Demonstration. Ich ziehe es vor, Variablen nicht zu exportieren; Ich verwende stattdessen die beliebte dotenv NPM-Bibliothek.

Importieren wir die erforderlichen Abhängigkeiten über unsere JS-Datei.

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

Daten generieren

Beginnen wir mit der Generierung einiger gefälschter Daten, um die Möglichkeiten des Parsens zu sehen.

Definition des Ausgabeschemas

Zuerst müssen wir der Bibliothek mitteilen, was wir erhalten möchten. LangChain unterstützt die Definition des erwarteten Schemas mithilfe einer beliebten Bibliothek namens 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"), }) );

Eingabeaufforderungsvorlage

Um diese Vorlage zu verwenden, müssen wir ein LangChain-Konstrukt namens PromptTemplate erstellen. Es enthält Formatanweisungen vom Parser:

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

Versuch es

Um die strukturierte Ausgabe auszuführen, rufen Sie das OpenAI-Modell mit der Eingabe auf:

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

Hier ist, was an das KI-Modell gesendet wird. Dies wird sich höchstwahrscheinlich in zukünftigen LangChain-Versionen ändern.

 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.

Die Ausgabe des Modells sieht folgendermaßen aus:

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

Wie Sie sehen, haben wir genau das bekommen, was wir brauchten. Wir können ganze Identitäten mit komplexen Beschreibungen generieren, die zu anderen Teilen der Persona passen. Wenn wir unseren Scheindatensatz bereichern müssten, könnten wir ein anderes KI-Modell bitten, ein Foto basierend auf dem Erscheinungsbild zu erstellen.

Fehlerbehandlung

Sie fragen sich vielleicht, ob die Verwendung von LLM in einer Produktionsanwendung überhaupt sicher ist. Glücklicherweise konzentriert sich LangChain auf solche Probleme. Falls die Ausgabe korrigiert werden muss, verwenden Sie den OutputFixingParser. Es wird versuchen, Fehler zu beheben, falls Ihr LLM etwas ausgibt, das nicht Ihren Anforderungen entspricht.

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

Extrahieren von Daten aus Dateien

Um Daten aus Dateien mit LangChain zu laden und zu extrahieren, können Sie die folgenden Schritte ausführen. In diesem Beispiel laden wir die PDF-Datei. Praktischerweise verfügt LangChain über Dienstprogramme, die genau diesem Zweck dienen. Wir brauchen eine zusätzliche Abhängigkeit.

 npm install pdf-parse

Wir werden eine kurze Biografie von Elon Musk laden und die Informationen extrahieren, die wir zuvor generiert haben. Laden Sie die PDF-Datei hier herunter: Google Drive .

Erstellen wir zunächst eine neue Datei, z. B. structured-pdf.js . Beginnen wir mit dem Laden des PDF.

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

Wir müssen die Eingabeaufforderungsvorlage ändern, um die Extraktion und nicht die Generierung anzuzeigen. Ich musste auch eine Eingabeaufforderung ändern, um das JSON-Rendering-Problem zu beheben, da die Ergebnisse zeitweise inkonsistent waren.

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

Schließlich müssen wir die zulässige Ausgabelänge erweitern (es sind etwas mehr Daten als im generierten Fall), da der Standardwert 256 Token beträgt. Wir müssen das Modell auch anhand unseres geladenen Dokuments aufrufen, nicht anhand einer vorgegebenen Personenbeschreibung.

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

Dank dieser Modifikationen erhalten wir die folgende Ausgabe:

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

Durch Befolgen dieser Schritte haben wir strukturierte JSON-Daten aus einer PDF-Datei extrahiert! Dieser Ansatz ist vielseitig und kann an Ihren spezifischen Anwendungsfall angepasst werden.

Abschluss

Zusammenfassend lässt sich sagen, dass Sie durch die Nutzung von LangChain, GPTs und Node.js leistungsstarke Anwendungen zum Extrahieren und Generieren strukturierter JSON-Daten aus verschiedenen Quellen erstellen können.

Die potenziellen Anwendungen sind vielfältig und mit etwas Kreativität können Sie diese Technologie nutzen, um innovative Apps und Lösungen zu entwickeln.

Den Code für dieses Tutorial finden Sie hier: https://gist.github.com/horosin/5351ae4dc3eebbf181f9db212f5d3ebc

Abonnieren Sie mein Profil, indem Sie links Ihre E-Mail-Adresse eingeben und bleiben Sie über meine Artikel auf dem Laufenden!

Vergessen Sie nicht, mir auf Twitter @horosin zu folgen und den Newsletter auf meinem Blog zu abonnieren, um weitere Tipps und Einblicke zu erhalten!

Wenn Sie kein Twitter haben, können Sie mir auch auf LinkedIn folgen.