instructor js
v1.5.0
Strukturierte Extraktion in Typenkript, die von LLMs betrieben wird und für Einfachheit, Transparenz und Kontrolle ausgelegt ist.
Tauchen Sie in die Welt der typeskript-basierten strukturierten Extraktion, durch OpenAIs Funktionsaufruf API und ZOD, Typscript-First-Schema-Validierung mit statischer Typinferenz. Der Ausbilder zeichnet sich durch Einfachheit, Transparenz und benutzerzentriertes Design aus. Egal, ob Sie ein erfahrener Entwickler sind oder gerade erst anfangen, Sie finden den Ansatz des Ausbilders intuitiv und lenkbar.
bun add @instructor-ai/instructor zod openainpm i @instructor-ai/instructor zod openaipnpm add @instructor-ai/instructor zod openaiUm alle Tipps und Tricks zu überprüfen, um Daten aufzurufen und zu extrahieren, lesen Sie die Dokumentation.
import Instructor from "@instructor-ai/instructor" ;
import OpenAI from "openai"
import { z } from "zod"
const oai = new OpenAI ( {
apiKey : process . env . OPENAI_API_KEY ?? undefined ,
organization : process . env . OPENAI_ORG_ID ?? undefined
} )
const client = Instructor ( {
client : oai ,
mode : "TOOLS"
} )
const UserSchema = z . object ( {
// Description will be used in the prompt
age : z . number ( ) . describe ( "The age of the user" ) ,
name : z . string ( )
} )
// User will be of type z.infer<typeof UserSchema>
const user = await client . chat . completions . create ( {
messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
model : "gpt-3.5-turbo" ,
response_model : {
schema : UserSchema ,
name : "User"
}
} )
console . log ( user )
// { age: 30, name: "Jason Liu" } Die Hauptklasse zum Erstellen eines Lehrers.
createInstructor
function createInstructor < C extends GenericClient | OpenAI > ( args : {
client : OpenAILikeClient < C > ;
mode : Mode ;
debug ?: boolean ;
} ) : InstructorClient < C >Erstellt eine Instanz der Ausbilderklasse.
Gibt den erweiterten OpenAI-ähnlichen Kunden zurück.
chat.completions.create
chat . completions . create <
T extends z . AnyZodObject ,
P extends T extends z . AnyZodObject ? ChatCompletionCreateParamsWithModel < T >
: ClientTypeChatCompletionParams < OpenAILikeClient < C > > & { response_model : never }
> (
params : P
) : Promise < ReturnTypeBasedOnParams < typeof this . client , P > >Wenn Response_Model in den Paramien vorhanden ist, erstellt ein Chat -Abschluss mit strukturierter Extraktion basierend auf dem bereitgestellten Schema - andernfalls wird der Proxy zum bereitgestellten Client zurückgeführt.
Ausbilder unterstützt verschiedene Modi zur Definition der Struktur und des Formats der Antwort aus dem Sprachmodell. Diese Modi sind im zod-stream -Paket definiert und sind wie folgt:
FUNCTIONS ( veraltet ): Erzeugt eine Antwort mit OpenAIs Funktionsaufruf API. Es ordnet die erforderlichen Parameter für die Funktion auf, die API aufruft, einschließlich der Eigenschaften function_call und functions .
TOOLS : Generiert eine Antwort mithilfe der Toolspezifikation von OpenAI. Es konstruiert die erforderlichen Parameter für die Toolspezifikation, einschließlich der Eigenschaften tool_choice und tools .
JSON : Es legt die response_format auf json_object und enthält das JSON -Schema in die Systemmeldung, um die Reaktionsgenerierung zu leiten. (Zusammen & anyscale)
MD_JSON : Generiert eine Antwort im JSON -Format in einem Markdown -Code -Block. Es enthält das JSON -Schema in die Systemmeldung und erwartet, dass die Antwort ein gültiges JSON -Objekt ist, das in einen Markdown -Code -Block eingewickelt ist.
JSON_SCHEMA : Erzeugt eine Antwort mit dem "JSON -Modus", der einem bereitgestellten JSON -Schema entspricht. Es legt die response_format auf json_object mit dem bereitgestellten Schema fest und enthält die Schemabeschreibung in die Systemmeldung.
Ausbilder unterstützt teilweise Streaming-Abschlüsse und ermöglicht es Ihnen, extrahierte Daten in Echtzeit zu empfangen, wenn das Modell seine Antwort generiert. Dies kann nützlich sein, um eine interaktivere Benutzererfahrung bereitzustellen oder große Datenmengen inkrementell zu verarbeiten.
import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"
const textBlock = `
In our recent online meeting, participants from various backgrounds joined to discuss the upcoming tech conference.
The names and contact details of the participants were as follows:
- Name: John Doe, Email: [email protected], Twitter: @TechGuru44
- Name: Jane Smith, Email: [email protected], Twitter: @DigitalDiva88
- Name: Alex Johnson, Email: [email protected], Twitter: @CodeMaster2023
During the meeting, we agreed on several key points. The conference will be held on March 15th, 2024, at the Grand Tech Arena located at 4521 Innovation Drive. Dr. Emily Johnson, a renowned AI researcher, will be our keynote speaker. The budget for the event is set at $50,000, covering venue costs, speaker fees, and promotional activities.
Each participant is expected to contribute an article to the conference blog by February 20th. A follow-up meeting is scheduled for January 25th at 3 PM GMT to finalize the agenda and confirm the list of speakers.
`
async function extractData ( ) {
const ExtractionSchema = z . object ( {
users : z . array (
z . object ( {
name : z . string ( ) ,
handle : z . string ( ) ,
twitter : z . string ( )
} )
) . min ( 3 ) ,
location : z . string ( ) ,
budget : z . number ( )
} )
const oai = new OpenAI ( {
apiKey : process . env . OPENAI_API_KEY ?? undefined ,
organization : process . env . OPENAI_ORG_ID ?? undefined
} )
const client = Instructor ( {
client : oai ,
mode : "TOOLS"
} )
const extractionStream = await client . chat . completions . create ( {
messages : [ { role : "user" , content : textBlock } ] ,
model : "gpt-3.5-turbo" ,
response_model : {
schema : ExtractionSchema ,
name : "Extraction"
} ,
max_retries : 3 ,
stream : true
} )
let extractedData = { }
for await ( const result of extractionStream ) {
extractedData = result
console . log ( "Partial extraction:" , result )
}
console . log ( "Final extraction:" , extractedData )
}
extractData ( )In diesem Beispiel definieren wir ein Extraktionenschema mit ZOD, um die Struktur der Daten anzugeben, die wir extrahieren möchten. Anschließend erstellen wir einen Lehrer -Client mit aktiviertem Streaming und übergeben das Schema an den Parameter response_model.
Die Extraktionenstream -Variable enthält einen asynchronen Generator, der partielle Extraktionsergebnisse erzielt, sobald sie verfügbar sind. Wir iterieren über den Stream mit A for Await ... der Schleife, aktualisieren das extrahierte Data -Objekt mit jedem Teilergebnis und protokollieren es an der Konsole.
Schließlich protokollieren wir die vollständigen extrahierten Daten, sobald der Stream erschöpft ist.
Ausbilder unterstützt verschiedene Anbieter, die sich an die OpenAI -API -Spezifikation halten. Sie können problemlos zwischen Anbietern wechseln, indem Sie den entsprechenden Client konfigurieren und das gewünschte Modell und Modus angeben.
AnyScale
import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"
const UserSchema = z . object ( {
age : z . number ( ) ,
name : z . string ( ) . refine ( name => name . includes ( " " ) , {
message : "Name must contain a space"
} )
} )
async function extractUser ( ) {
const client = new OpenAI ( {
baseURL : "https://api.endpoints.anyscale.com/v1" ,
apiKey : process . env . ANYSCALE_API_KEY
} )
const instructor = Instructor ( {
client : client ,
mode : "TOOLS"
} )
const user = await instructor . chat . completions . create ( {
messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
model : "mistralai/Mixtral-8x7B-Instruct-v0.1" ,
response_model : {
schema : UserSchema ,
name : "User"
} ,
max_retries : 4
} )
return user
}
const anyscaleUser = await extractUser ( )
console . log ( "Anyscale user:" , anyscaleUser )Zusammen
import Instructor from "@instructor-ai/instructor"
import OpenAI from "openai"
import { z } from "zod"
const UserSchema = z . object ( {
age : z . number ( ) ,
name : z . string ( ) . refine ( name => name . includes ( " " ) , {
message : "Name must contain a space"
} )
} )
async function extractUser ( ) {
const client = new OpenAI ( {
baseURL : "https://api.together.xyz/v1" ,
apiKey : process . env . TOGETHER_API_KEY
} )
const instructor = Instructor ( {
client : client ,
mode : "TOOLS"
} )
const user = await instructor . chat . completions . create ( {
messages : [ { role : "user" , content : "Jason Liu is 30 years old" } ] ,
model : "mistralai/Mixtral-8x7B-Instruct-v0.1" ,
response_model : {
schema : UserSchema ,
name : "User"
} ,
max_retries : 4
} )
return user
}
const togetherUser = await extractUser ( )
console . log ( "Together user:" , togetherUser )In diesen Beispielen geben wir einen bestimmten Basis -URL- und API -Schlüssel aus AnyScale und zusammen an.
Die ExtractUser -Funktion nimmt Modell, Modus und Anbieter als Parameter. Es ruft die entsprechende Anbieterkonfiguration ab, erstellt einen OpenAI -Client und initialisiert eine Ausbilderinstanz mit dem angegebenen Modus.
Anschließend rufen wir lehrende.chat.completions.create mit dem gewünschten Modell, dem Antwortschema und anderen Parametern auf, um die Benutzerinformationen zu extrahieren.
Durch Variieren des Anbieters, des Modells und der Modus -Argumente beim Aufrufen von ExtractUser können Sie problemlos zwischen verschiedenen Anbietern und Konfigurationen wechseln.
Ausbilder unterstützt die Integration mit Anbietern, die sich nicht an die OpenAI-SDK halten, wie anthropisch, azure und Cohere, durch die von @Dimitrikennedy gepflegte llm-polyglot -Bibliothek. Diese Bibliothek bietet eine einheitliche Schnittstelle für die Interaktion mit verschiedenen Sprachmodellen über verschiedene Anbieter hinweg.
import { createLLMClient } from "llm-polyglot"
import Instructor from "@instructor-ai/instructor"
import { z } from "zod"
const anthropicClient = createLLMClient ( {
provider : "anthropic" ,
apiKey : process . env . ANTHROPIC_API_KEY
} )
const UserSchema = z . object ( {
age : z . number ( ) ,
name : z . string ( )
} )
const instructor = Instructor < typeof anthropicClient > ( {
client : anthropicClient ,
mode : "TOOLS"
} )
async function extractUser ( ) {
const user = await instructor . chat . completions . create ( {
model : "claude-3-opus-20240229" ,
max_tokens : 1000 ,
messages : [
{
role : "user" ,
content : "My name is Dimitri Kennedy."
}
] ,
response_model : {
name : "extract_name" ,
schema : UserSchema
}
} )
return user
}
// Example usage
const extractedUser = await extractUser ( )
console . log ( "Extracted user:" , extractedUser )In diesem Beispiel verwenden wir die Funktion createSclient aus der LLM-Polyglot-Bibliothek, um einen Kunden für den anthropischen Anbieter zu erstellen. Wir übergeben den Anbieternamen ("anthropisch") und den entsprechenden API -Schlüssel an die Funktion.
Als nächstes definieren wir ein UserSchema mit ZOD, um die Struktur der Benutzerdaten anzugeben, die wir extrahieren möchten.
Wir erstellen eine Instanzinstanz, indem wir den anthropischen Kunden und den gewünschten Modus an die Ausbilderfunktion übergeben. Beachten Sie, dass wir den Ausbilder verwenden, um den Client -Typ explizit anzugeben.
Die Extractuser -Funktion zeigt, wie die Instanzinstanz verwendet wird, um Benutzerinformationen aus einer bestimmten Eingabe zu extrahieren. Wir nennen den entsprechenden Modell ("Claude-3-opus-20240229" in diesem Fall lehrende.chat.completions.create.
Schließlich protokollieren wir die extrahierten Benutzerinformationen.
Durch die Nutzung der LLM-Polyglot-Bibliothek ermöglicht der Ausbilder eine nahtlose Integration mit einer Vielzahl von Anbietern, die über diejenigen hinausgehen, die dem OpenAI-SDK folgen. Auf diese Weise können Sie die einzigartigen Funktionen und Modelle nutzen, die von verschiedenen Anbietern angeboten werden, während Sie dennoch von den strukturierten Extraktions- und Validierungsmerkmalen des Ausbilders profitieren.
Weitere Unterstützung und Informationen zur Verwendung anderer Anbieter mit LLM-Polyglot finden Sie in den Dokumentationen und Beispielen der Bibliothek.
Wenn Sie mehr sehen möchten, schauen Sie sich unser Kochbuch an.
Die Installation des Ausbilders ist ein Kinderspiel.
Ausbilder basieren auf mehreren leistungsstarken Paketen des Island AI Toolkit, das von Dimitri Kennedy entwickelt und gepflegt wird. Diese Pakete bieten eine wesentliche Funktionalität für die strukturierte Datenhandhabung und Streaming mit großen Sprachmodellen.
ZOD-Stream ist ein Client-Modul, das direkt mit LLM-Streams übergeht. Es wird ein Schema-Stream zur effizienten Parsen verwendet und ist mit Tools zur Verarbeitung von Reaktionen von OpenAI ausgestattet, kategorisiert sie nach Modus (Funktion, Tools, JSON usw.) und sicherzustellen, dass die ordnungsgemäße Fehlerbehebung und Stream-Konvertierung sichergestellt werden. Es ist ideal für die API -Integration für strukturierte LLM -Antwortströme.
Schema-Stream ist ein JSON-Streaming-Parser, der die Reaktionsmodelle basierend auf ZOD-Schemas inkrementell konstruiert und aktualisiert. Es ist für die Echtzeit-Datenverarbeitung und die inkrementelle Modellhydratation ausgelegt.
LLM-Polyglot ist eine Bibliothek, die eine einheitliche Schnittstelle für die Interaktion mit verschiedenen Sprachmodellen über verschiedene Anbieter wie OpenAI, Anthropic, Azure und Cohere bietet. Es vereinfacht den Prozess der Arbeit mit mehreren LLM -Anbietern und ermöglicht eine nahtlose Integration in den Ausbilder.
Ausbilder nutzt die Leistung dieser Island -KI -Pakete, um ein nahtloses und effizientes Erlebnis für strukturierte Datenextraktion und Streaming mit LLMs zu bieten. Die Zusammenarbeit zwischen Dimitri Kennedy, dem Schöpfer von Island AI, und Jason Liu, dem Autor des ursprünglichen Ausbilders Python -Paket, hat zur Entwicklung der Typuskriptversion des Ausbilders geführt, die das Konzept des partiellen JSON -Streamings aus LLM vorstellt.
Weitere Informationen zu Insel AI und ihren Paketen finden Sie im Insel -AI -Repository.
Die Frage der Verwendung von Ausbildern ist grundsätzlich eine Frage, warum ZOD verwendet werden soll.
Arbeitet mit dem OpenAI SDK - Ausbilder folgt OpenAs API. Dies bedeutet, dass Sie dieselbe API sowohl für die Aufforderung als auch für die Extraktion über mehrere Anbieter verwenden können, die die OpenAI -API unterstützen.
Anpassbar - Zod ist sehr anpassbar. Sie können Ihre eigenen Validatoren, benutzerdefinierte Fehlermeldungen und mehr definieren.
Ökosystem Zod ist die am häufigsten verwendete Datenvalidierungsbibliothek für Typscript.
Battle getestet - Zod wird über 24 m -Mal pro Monat heruntergeladen und von einer großen Community von Mitwirkenden unterstützt.
Wenn Sie helfen möchten, überprüfen Sie einige der Probleme, die als good-first-issue oder help-wanted markiert sind. Hier gefunden. Sie könnten alles von Codeverbesserungen, einem Gast -Blog -Beitrag oder einem neuen Kochbuch sein.
Schauen Sie sich den Beitragshandbuch an, um Informationen zum Einrichten, Testen, Änderungen und Richtlinien einzurichten.
Tipp: Unterstützung in anderen Sprachen
Check out ports to other languages below:
- [Python](https://www.github.com/jxnl/instructor)
- [Elixir](https://github.com/thmsmlr/instructor_ex/)
If you want to port Instructor to another language, please reach out to us on [Twitter](https://twitter.com/jxnlco) we'd love to help you get started!
Dieses Projekt ist gemäß den Bedingungen der MIT -Lizenz lizenziert.
