instructor js
v1.5.0
Extração estruturada no TypeScript, alimentado pelo LLMS, projetado para simplicidade, transparência e controle.
Mergulhe no mundo da extração estruturada baseada em texto datilografado, pela API de chamadas de função do OpenAI e pela Validação de Esquema de Zod, Primeira Digitada com inferência de tipo estático. O instrutor se destaca por sua simplicidade, transparência e design centrado no usuário. Seja você um desenvolvedor experiente ou apenas começando, encontrará a abordagem do instrutor intuitiva e orientável.
bun add @instructor-ai/instructor zod openainpm i @instructor-ai/instructor zod openaipnpm add @instructor-ai/instructor zod openaiPara conferir todas as dicas e truques para solicitar e extrair dados, consulte a documentação.
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" } A classe principal para criar um cliente de instrutor.
CreateInstructor
function createInstructor < C extends GenericClient | OpenAI > ( args : {
client : OpenAILikeClient < C > ;
mode : Mode ;
debug ?: boolean ;
} ) : InstructorClient < C >Cria uma instância da classe de instrutor.
Retorna o cliente estendido do 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 > >Quando o Response_model está presente nos parâmetros, cria uma conclusão de bate -papo com extração estruturada com base no esquema fornecido - caso contrário, será proxy de volta ao cliente fornecido.
O instrutor suporta modos diferentes para definir a estrutura e o formato da resposta do modelo de idioma. Esses modos são definidos no pacote zod-stream e são os seguintes:
FUNCTIONS ( depreciadas ): gera uma resposta usando a API de chamada de função do OpenAI. Ele mapeia os parâmetros necessários para a API de chamada de função, incluindo as propriedades function_call e functions .
TOOLS : gera uma resposta usando a especificação da ferramenta do OpenAI. Ele constrói os parâmetros necessários para a especificação da ferramenta, incluindo as propriedades tool_choice e tools .
JSON : Ele define o response_format como json_object e inclui o esquema JSON na mensagem do sistema para orientar a geração de resposta. (Juntos e qualquer escala)
MD_JSON : gera uma resposta no formato JSON incorporado em um bloco de código de marcação. Ele inclui o esquema JSON na mensagem do sistema e espera que a resposta seja um objeto JSON válido envolvido em um bloco de código de marcação.
JSON_SCHEMA : gera uma resposta usando o "modo json" que está em conformidade com um esquema JSON fornecido. Ele define o response_format como json_object com o esquema fornecido e inclui a descrição do esquema na mensagem do sistema.
O instrutor suporta conclusões parciais de streaming, permitindo que você receba dados extraídos em tempo real, pois o modelo gera sua resposta. Isso pode ser útil para fornecer uma experiência mais interativa do usuário ou processar grandes quantidades de dados incrementalmente.
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 ( )Neste exemplo, definimos uma extração do Zod para especificar a estrutura dos dados que queremos extrair. Em seguida, criamos um cliente de instrutor com o streaming ativado e passamos o esquema para o parâmetro Response_model.
A variável ExtraçãoTream detém um gerador assíncrono que produz resultados de extração parcial à medida que estão disponíveis. Iteramos sobre o fluxo usando um para aguardar ... de loop, atualizando o objeto ExtractedData com cada resultado parcial e registrando -o no console.
Finalmente, registramos os dados extraídos completos assim que o fluxo estiver esgotado.
O instrutor suporta vários fornecedores que aderem à especificação da API OpenAI. Você pode alternar facilmente entre os provedores configurando o cliente apropriado e especificando o modelo e o modo desejados.
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 )Junto
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 )Nestes exemplos, especificamos uma chave de URL e API específica de qualquer escala e juntos ..
A função extractuser leva o modelo, o modo e o provedor como parâmetros. Ele recupera a configuração do provedor correspondente, cria um cliente OpenAI e inicializa uma instância do instrutor com o modo especificado.
Em seguida, chamamos o instrutor.chat.completions.create com o modelo desejado, esquema de resposta e outros parâmetros para extrair as informações do usuário.
Ao variar os argumentos do provedor, modelo e modo Ao chamar o Extractuser, você pode alternar facilmente entre diferentes fornecedores e configurações.
O instrutor suporta integração com fornecedores que não aderem ao SDK Openai, como Antrópico, Azure e Coere, através da Biblioteca llm-polyglot mantida por @Dimitrikennedy. Esta biblioteca fornece uma interface unificada para interagir com vários modelos de idiomas em diferentes fornecedores.
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 )Neste exemplo, usamos a função CreatellMclient da Biblioteca LLM-Poleglot para criar um cliente para o provedor antrópico. Passamos pelo nome do provedor ("antropic") e a chave da API correspondente para a função.
Em seguida, definimos um UsersChema usando o Zod para especificar a estrutura dos dados do usuário que queremos extrair.
Criamos uma instância do instrutor passando o cliente antrópico e o modo desejado para a função do instrutor. Observe que usamos o instrutor para especificar o tipo de cliente explicitamente.
A função Extractuser demonstra como usar a instância do instrutor para extrair informações do usuário de uma determinada entrada. Chamamos o instrutor.chat.completions.create com o modelo apropriado ("Claude-3-Opus-20240229" neste caso), parâmetros e o Response_model que inclui nosso UsersChema.
Por fim, registramos as informações extraídas do usuário.
Ao alavancar a Biblioteca LLM-Poliglot, o instrutor permite a integração perfeita com uma ampla gama de fornecedores além daqueles que seguem o SDK OpenAI. Isso permite que você aproveite os recursos e modelos exclusivos oferecidos por diferentes fornecedores, enquanto ainda se beneficia dos recursos estruturados de extração e validação do instrutor.
Para obter suporte e informações adicionais sobre o uso de outros provedores com LLM-Poleglot, consulte a documentação e os exemplos da biblioteca.
Se você quiser ver mais, consulte nosso livro de receitas.
A instalação do instrutor é uma brisa.
O instrutor é construído sobre vários pacotes poderosos do kit de ferramentas da Ilha AI, desenvolvido e mantido por Dimitri Kennedy. Esses pacotes fornecem funcionalidade essencial para manuseio de dados estruturados e streaming com grandes modelos de idiomas.
O Zod-Stream é um módulo de cliente que interfina diretamente com os fluxos LLM. Ele utiliza fluxo de esquema para análise eficiente e está equipado com ferramentas para processar respostas brutas do OpenAI, categorizando-as por modo (função, ferramentas, json, etc.) e garantindo manuseio de erro adequado e conversão de fluxo. É ideal para integração da API que fornece fluxos de resposta LLM estruturados.
O Schema-Stream é um analisador de streaming JSON que constrói e atualiza incrementalmente os modelos de resposta com base nos esquemas ZOD. Ele foi projetado para processamento de dados em tempo real e hidratação incremental do modelo.
O LLM-Pologlot é uma biblioteca que fornece uma interface unificada para interagir com vários modelos de idiomas em diferentes fornecedores, como OpenAI, Antrópico, Azure e Coere. Ele simplifica o processo de trabalho com vários fornecedores de LLM e permite integração perfeita com o instrutor.
O instrutor aproveita o poder desses pacotes de IA da ilha para oferecer uma experiência perfeita e eficiente para extração de dados estruturados e streaming com LLMs. A colaboração entre Dimitri Kennedy, o criador da Ilha AI, e Jason Liu, autor do pacote original do instrutor Python, levou ao desenvolvimento da versão datilografada do instrutor, que introduz o conceito de streaming parcial de JSON do LLM.
Para obter mais informações sobre a ILA IA e seus pacotes, consulte o repositório da IA da ilha.
A questão do uso do instrutor é fundamentalmente uma questão de por que usar o Zod.
Trabalha com o Openai SDK - o instrutor segue a API do OpenAI. Isso significa que você pode usar a mesma API para solicitar e extração em vários fornecedores que suportam a API do OpenAI.
Customizable - Zod é altamente personalizável. Você pode definir seus próprios validadores, mensagens de erro personalizadas e muito mais.
O ecossistema Zod é a biblioteca de validação de dados mais usada para o TypeScript.
Battle Tested - Zod é baixado mais de 24m vezes por mês e apoiado por uma grande comunidade de colaboradores.
Se você quiser ajudar, consulte alguns dos problemas marcados como good-first-issue ou help-wanted . Encontrado aqui. Eles podem ser qualquer coisa, desde melhorias de código, uma postagem no blog de convidados ou um novo livro de culinária.
Confira o guia de contribuição para obter detalhes sobre como configurar as coisas, testes, alterações e diretrizes.
Dica: Suporte em outros 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 projeto está licenciado nos termos da licença do MIT.
