instructor js
v1.5.0
Extraction structurée en dactylographie, alimentée par LLMS, conçue pour la simplicité, la transparence et le contrôle.
Plongez dans le monde de l'extraction structurée basée sur TypeScript, par la fonction d'Openai appelant l'API et ZOD, la validation de schéma de type TypeScript avec une inférence de type statique. L'instructeur se distingue par sa simplicité, sa transparence et sa conception centrée sur l'utilisateur. Que vous soyez un développeur chevronné ou que vous commenciez simplement, vous trouverez une approche de l'instructeur intuitif et orientable.
bun add @instructor-ai/instructor zod openainpm i @instructor-ai/instructor zod openaipnpm add @instructor-ai/instructor zod openaiPour consulter tous les conseils et astuces pour inviter et extraire les données, consultez la documentation.
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" } La classe principale pour créer un client d'instructeur.
créationinstructor
function createInstructor < C extends GenericClient | OpenAI > ( args : {
client : OpenAILikeClient < C > ;
mode : Mode ;
debug ?: boolean ;
} ) : InstructorClient < C >Crée une instance de la classe d'instructeurs.
Renvoie le client étendu de type OpenAI.
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 > >Lorsque Response_Model est présent dans les paramètres, crée une complétion de chat avec une extraction structurée basée sur le schéma fourni - sinon, il va se procurer au client fourni.
L'instructeur prend en charge différents modes pour définir la structure et le format de la réponse du modèle de langue. Ces modes sont définis dans le package zod-stream et sont les suivants:
FUNCTIONS ( dépréciées ): génère une réponse à l'aide de l'API d'appel de fonction d'Openai. Il correspond aux paramètres nécessaires pour l'API d'appel de fonction, y compris les propriétés function_call et functions .
TOOLS : génère une réponse à l'aide de la spécification d'outil d'Openai. Il construit les paramètres requis pour la spécification de l'outil, y compris les propriétés tool_choice et tools .
JSON : il définit la response_format sur json_object et inclut le schéma JSON dans le message système pour guider la génération de réponse. (Ensemble et anyscale)
MD_JSON : génère une réponse au format JSON intégré dans un bloc de code Markdown. Il comprend le schéma JSON dans le message système et s'attend à ce que la réponse soit un objet JSON valide enveloppé dans un bloc de code de démarque.
JSON_SCHEMA : génère une réponse en utilisant "Mode JSON" conforme à un schéma JSON fourni. Il définit la response_format sur json_object avec le schéma fourni et comprend la description du schéma dans le message système.
L'instructeur prend en charge les compléments de streaming partiel, vous permettant de recevoir des données extraites en temps réel car le modèle génère sa réponse. Cela peut être utile pour fournir une expérience utilisateur plus interactive ou traiter de grandes quantités de données progressivement.
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 ( )Dans cet exemple, nous définissons une extractschema en utilisant ZOD pour spécifier la structure des données que nous voulons extraire. Nous créons ensuite un client d'instructeur avec streaming activé et passons le schéma au paramètre Response_Model.
La variable ExtractionStream contient un générateur asynchrone qui donne des résultats d'extraction partielle à mesure qu'ils deviennent disponibles. Nous itons sur le flux en utilisant un pour attendre ... de Loop, mettant à jour l'objet extrait dedata à chaque résultat partiel et en le enregistrant sur la console.
Enfin, nous enregistrons les données extraites complètes une fois le flux épuisé.
L'instructeur prend en charge divers fournisseurs qui adhèrent à la spécification API OpenAI. Vous pouvez facilement basculer entre les fournisseurs en configurant le client approprié et en spécifiant le modèle et le mode souhaités.
Tous les niveaux
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 )Ensemble
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 )Dans ces exemples, nous spécifions une URL de base et une clé API spécifiques de tous les niveaux, et ensemble ..
La fonction d'extraction prend le modèle, le mode et le fournisseur comme paramètres. Il récupère la configuration du fournisseur correspondant, crée un client OpenAI et initialise une instance d'instructeur avec le mode spécifié.
Nous appelons ensuite l'instructeur.chat.completions.Create avec le modèle souhaité, le schéma de réponse et d'autres paramètres pour extraire les informations de l'utilisateur.
En faisant varier les arguments du fournisseur, du modèle et du mode lors de l'appel d'extraction, vous pouvez facilement basculer entre différents fournisseurs et configurations.
L'instructeur prend en charge l'intégration avec des fournisseurs qui n'adhèrent pas au SDK OpenAI, comme Anthropic, Azure et Cohere, via la bibliothèque llm-polyglot entretenue par @dimitrikennedy. Cette bibliothèque fournit une interface unifiée pour interagir avec divers modèles de langage entre différents fournisseurs.
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 )Dans cet exemple, nous utilisons la fonction CrerellMClient de la bibliothèque LLM-PolyGlot pour créer un client pour le fournisseur anthropique. Nous passons le nom du fournisseur ("anthropic") et la clé API correspondante à la fonction.
Ensuite, nous définissons un SHECHEMA utilisateur à l'aide de ZOD pour spécifier la structure des données utilisateur que nous souhaitons extraire.
Nous créons une instance d'instructeur en passant le client anthropique et le mode souhaité à la fonction de l'instructeur. Notez que nous utilisons l'instructeur pour spécifier explicitement le type de client.
La fonction d'extraction montre comment utiliser l'instance de l'instructeur pour extraire les informations utilisateur à partir d'une entrée donnée. Nous appelons instructor.chat.completions.create avec le modèle approprié ("Claude-3-Opus-20240229" dans ce cas), les paramètres et la réponse_model qui inclut notre tamisage utilisateur.
Enfin, nous enregistrons les informations utilisateur extraites.
En tirant parti de la bibliothèque LLM-Polyglot, l'instructeur permet une intégration transparente avec un large éventail de fournisseurs au-delà de ceux qui suivent le SDK OpenAI. Cela vous permet de profiter des capacités et modèles uniques offerts par différents fournisseurs tout en bénéficiant des caractéristiques structurées d'extraction et de validation de l'instructeur.
Pour un support supplémentaire et des informations sur l'utilisation d'autres fournisseurs avec LLM-PolyGlot, veuillez vous référer à la documentation et aux exemples de la bibliothèque.
Si vous souhaitez en voir plus, consultez notre livre de cuisine.
L'installation de l'instructeur est un jeu d'enfant.
L'instructeur est construit au-dessus de plusieurs forfaits puissants de la boîte à outils Island AI, développé et entretenu par Dimitri Kennedy. Ces packages fournissent des fonctionnalités essentielles pour la gestion structurée des données et le streaming avec des modèles de gros langues.
ZOD-Stream est un module client qui interface directement avec les flux LLM. Il utilise un schéma de schéma pour l'analyse efficace et est équipé d'outils pour traiter les réponses brutes à partir d'OpenAI, les catégoriser par mode (fonction, outils, JSON, etc.), et assurer une bonne gestion des erreurs et une conversion de flux. Il est idéal pour l'intégration d'API fournissant des flux de réponse LLM structurés.
Schema-Stream est un analyseur de streaming JSON qui construit et met à jour les modèles de réponse basés sur les schémas ZOD. Il est conçu pour le traitement des données en temps réel et l'hydratation incrémentielle du modèle.
LLM-PolyGlot est une bibliothèque qui fournit une interface unifiée pour interagir avec divers modèles de langage entre différents fournisseurs, tels que OpenAI, Anthropic, Azure et Cohere. Il simplifie le processus de travail avec plusieurs fournisseurs de LLM et permet une intégration transparente avec l'instructeur.
L'instructeur exploite la puissance de ces forfaits Island IA pour offrir une expérience transparente et efficace pour l'extraction et le streaming de données structurées avec des LLM. La collaboration entre Dimitri Kennedy, le créateur de Island AI, et Jason Liu, l'auteur de l'instructeur original Python Python, a conduit au développement de la version dactylographiée de l'instructeur, qui introduit le concept de streaming JSON partiel à partir de LLM.
Pour plus d'informations sur l'île Island et ses forfaits, veuillez vous référer au référentiel Island AI.
La question de l'utilisation de l'instructeur est fondamentalement une question de savoir pourquoi utiliser Zod.
Fonctionne avec le SDK OpenAI - l'instructeur suit l'API d'Openai. Cela signifie que vous pouvez utiliser la même API pour l'invitation et l'extraction entre plusieurs fournisseurs qui prennent en charge l'API OpenAI.
Personnalisable - Zod est hautement personnalisable. Vous pouvez définir vos propres validateurs, messages d'erreur personnalisés et plus encore.
Ecosystem Zod est la bibliothèque de validation de données la plus utilisée pour TypeScript.
Tested Battle - Zod est téléchargé plus de 24 millions de fois par mois et soutenu par une grande communauté de contributeurs.
Si vous voulez aider, consultez certains des problèmes marqués comme good-first-issue ou help-wanted . Trouvé ici. Ils pourraient être des améliorations de code, un article de blog invité ou un nouveau livre de cuisine.
Découvrez le guide de contribution pour plus de détails sur la façon de configurer les choses, les tests, les changements et les directives.
Conseil: support dans d'autres langues
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!
Ce projet est concédé sous licence de la licence du MIT.
