instructor js
v1.5.0
Extracción estructurada en TypeScript, alimentada por LLMS, diseñada para la simplicidad, la transparencia y el control.
Coloque en el mundo de la extracción estructurada basada en TypeScript, mediante la función de OpenAI llamando a API y ZOD, validación de esquema mecanografiado con inferencia de tipo estático. El instructor destaca por su simplicidad, transparencia y diseño centrado en el usuario. Ya sea que sea un desarrollador experimentado o que comience, encontrará el enfoque del instructor intuitivo y orientable.
bun add @instructor-ai/instructor zod openainpm i @instructor-ai/instructor zod openaipnpm add @instructor-ai/instructor zod openaiPara consultar todos los consejos y trucos para solicitar y extraer datos, consulte la documentación.
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 clase principal para crear un cliente instructor.
createinstructor
function createInstructor < C extends GenericClient | OpenAI > ( args : {
client : OpenAILikeClient < C > ;
mode : Mode ;
debug ?: boolean ;
} ) : InstructorClient < C >Crea una instancia de la clase de instructor.
Devuelve el cliente extendido de 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 > >Cuando Response_Model está presente en los parámetros, crea una finalización de chat con extracción estructurada basada en el esquema proporcionado; de lo contrario, volverá al cliente proporcionado.
El instructor admite diferentes modos para definir la estructura y el formato de la respuesta del modelo de lenguaje. Estos modos se definen en el paquete zod-stream y son los siguientes:
FUNCTIONS ( en desuso ): genera una respuesta utilizando la función de llamadas de funciones de OpenAI. Se asigna a los parámetros necesarios para la API de llamadas de función, incluidas las propiedades function_call y functions .
TOOLS : genera una respuesta utilizando la especificación de herramienta de OpenAI. Construye los parámetros requeridos para la especificación de la herramienta, incluidas las propiedades tool_choice y tools .
JSON : Establece la response_format en json_object e incluye el esquema JSON en el mensaje del sistema para guiar la generación de respuesta. (Juntos y cualquier escala)
MD_JSON : Genera una respuesta en formato JSON incrustado dentro de un bloque de código de markdown. Incluye el esquema JSON en el mensaje del sistema y espera que la respuesta sea un objeto JSON válido envuelto en un bloque de código de markdown.
JSON_SCHEMA : genera una respuesta usando "Modo JSON" que se ajusta a un esquema JSON proporcionado. Establece la response_format en json_object con el esquema proporcionado e incluye la descripción del esquema en el mensaje del sistema.
El instructor admite finalizaciones de transmisión parciales, lo que le permite recibir datos extraídos en tiempo real a medida que el modelo genera su respuesta. Esto puede ser útil para proporcionar una experiencia de usuario más interactiva o procesar grandes cantidades de datos de forma incremental.
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 ( )En este ejemplo, definimos una Casa de Extracciones usando ZOD para especificar la estructura de los datos que queremos extraer. Luego creamos un cliente de instructor con transmisión habilitada y pasamos el esquema al parámetro Respuesta_Model.
La variable ExtractionTream contiene un generador de asíncrono que produce resultados de extracción parcial a medida que están disponibles. Iteramos sobre el flujo usando un para esperar ... de bucle, actualizando el objeto ExtraedData con cada resultado parcial y registrándolo en la consola.
Finalmente, registramos los datos extraídos completos una vez que la transmisión está agotada.
El instructor admite varios proveedores que se adhieren a la especificación de la API de OpenAI. Puede cambiar fácilmente entre proveedores configurando el cliente apropiado y especificando el modelo y el modo deseados.
Escala
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 )Juntos
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 )En estos ejemplos, especificamos una URL base específica y una tecla API de cualquier escala, y juntos.
La función ExtractUser toma el modelo, el modo y el proveedor como parámetros. Recupera la configuración del proveedor correspondiente, crea un cliente OpenAI e inicializa una instancia de instructor con el modo especificado.
Luego llamamos al instructor.chat.completions.create con el modelo deseado, el esquema de respuesta y otros parámetros para extraer la información del usuario.
Al variar el proveedor, el modelo y los argumentos de modo al llamar a Extractuser, puede cambiar fácilmente entre diferentes proveedores y configuraciones.
El instructor apoya la integración con proveedores que no se adhieren al SDK de OpenAI, como Anthrope, Azure y Cohere, a través de la Biblioteca llm-polyglot mantenida por @Dimitrikennedy. Esta biblioteca proporciona una interfaz unificada para interactuar con varios modelos de idiomas en diferentes proveedores.
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 )En este ejemplo, utilizamos la función CreatellMclient de la biblioteca LLM-Polyglot para crear un cliente para el proveedor antrópico. Pasamos el nombre del proveedor ("antrópico") y la clave API correspondiente a la función.
A continuación, definimos un UserSchema usando Zod para especificar la estructura de los datos del usuario que queremos extraer.
Creamos una instancia de instructor pasando el cliente antrópico y el modo deseado a la función del instructor. Tenga en cuenta que usamos el instructor para especificar el tipo de cliente explícitamente.
La función ExtractUser demuestra cómo usar la instancia del instructor para extraer información del usuario de una entrada dada. Llamamos al instructor.chat.completions.create con el modelo apropiado ("Claude-3-OPUS-20240229" en este caso), los parámetros y la respuesta_model que incluye nuestro UserSchema.
Finalmente, registramos la información extraída del usuario.
Al aprovechar la Biblioteca LLM-Polyglot, el instructor permite una integración perfecta con una amplia gama de proveedores más allá de los que siguen el SDK de OpenAI. Esto le permite aprovechar las capacidades y modelos únicos ofrecidos por diferentes proveedores, al tiempo que se beneficia de las características estructuradas de extracción y validación del instructor.
Para obtener apoyo e información adicionales sobre el uso de otros proveedores con LLM-Polyglot, consulte la documentación y los ejemplos de la biblioteca.
Si desea ver más, consulte nuestro libro de cocina.
Instalar instructor es muy fácil.
El instructor está construido sobre varios paquetes poderosos del kit de herramientas de IA Island, desarrollado y mantenido por Dimitri Kennedy. Estos paquetes proporcionan una funcionalidad esencial para el manejo y transmisión de datos estructurados con modelos de idiomas grandes.
ZOD-STREAM es un módulo de cliente que se interactúa directamente con las transmisiones LLM. Utiliza la transmisión de esquema para un análisis eficiente y está equipado con herramientas para procesar respuestas sin procesar desde OpenAI, categorizarlas por modo (función, herramientas, JSON, etc.), y garantizar un manejo adecuado de errores y conversión de flujo. Es ideal para la integración de API que entrega corrientes de respuesta LLM estructuradas.
Schema-stream es un analizador JSON que construye y actualiza incrementalmente los modelos de respuesta basados en esquemas Zod. Está diseñado para el procesamiento de datos en tiempo real e hidratación del modelo incremental.
LLM-Polyglot es una biblioteca que proporciona una interfaz unificada para interactuar con varios modelos de idiomas en diferentes proveedores, como OpenAI, antrópico, Azure y Cohere. Simplifica el proceso de trabajo con múltiples proveedores de LLM y permite una integración perfecta con el instructor.
El instructor aprovecha la potencia de estos paquetes de IA de la isla para ofrecer una experiencia perfecta y eficiente para la extracción de datos estructurados y la transmisión con LLM. La colaboración entre Dimitri Kennedy, el creador de Island AI, y Jason Liu, el autor del paquete original del instructor Python, ha llevado al desarrollo de la versión mecanografiada del instructor, que introduce el concepto de transmisión parcial de JSON de LLM.
Para obtener más información sobre Island AI y sus paquetes, consulte el repositorio de la IA de la isla.
La cuestión del uso del instructor es fundamentalmente una cuestión de por qué usar Zod.
Funciona con el SDK Operai : el instructor sigue la API de OpenAI. Esto significa que puede usar la misma API para la solicitud y la extracción en múltiples proveedores que admiten la API de OpenAI.
Customizable : Zod es altamente personalizable. Puede definir sus propios validadores, mensajes de error personalizados y más.
El ecosistema Zod es la biblioteca de validación de datos más utilizada para TypeScript.
Battle Probado : Zod se descarga más de 24 millones de veces al mes y es apoyado por una gran comunidad de contribuyentes.
Si desea ayudar, consulte algunos de los problemas marcados como good-first-issue o help-wanted . Encontrado aquí. Podrían ser cualquier cosa, desde mejoras en el código, una publicación de blog invitada o un nuevo libro de cocina.
Consulte la Guía de contribución para obtener detalles sobre cómo configurar las cosas, las pruebas, los cambios de cambios y las pautas.
Consejo: Soporte en otros idiomas
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!
Este proyecto tiene licencia bajo los términos de la licencia MIT.
