Download instructor - Download do código fonte instructor

Instrutor, a biblioteca mais popular para saídas estruturadas simples

O instrutor é a biblioteca Python mais popular para trabalhar com saídas estruturadas de grandes modelos de idiomas (LLMS), com mais de 600.000 downloads mensais. Construído em cima do Pydantic, ele fornece uma API simples, transparente e fácil de usar para gerenciar validação, tentativas e respostas de streaming. Prepare -se para sobrecarregar seus fluxos de trabalho LLM com a melhor escolha da comunidade!

Quer seu logotipo em nosso site?

Se sua empresa usa muito o instrutor, gostaríamos de ter seu logotipo em nosso site! Por favor, preencha este formulário

Principais recursos

Modelos de resposta : especifique modelos pydantic para definir a estrutura de suas saídas LLM
Réstono de repetição : configure facilmente o número de tentativas de repetição para seus pedidos
Validação : verifique se as respostas do LLM estão em conformidade com suas expectativas com validação pydantic
Suporte de streaming : Trabalhe com listas e respostas parciais sem esforço
Backnds flexíveis : integrar -se perfeitamente a vários provedores de LLM além do Openai
Suporte em muitos idiomas : apoiamos muitos idiomas, incluindo Python, TypeScript, Ruby, Go e Elixir

Comece em minutos

Instale o instrutor com um único comando:

pip install -U instructor

Agora, vamos ver o instrutor em ação com um exemplo simples:

 import instructor
from pydantic import BaseModel
from openai import OpenAI


# Define your desired output structure
class UserInfo ( BaseModel ):
    name : str
    age : int


# Patch the OpenAI client
client = instructor . from_openai ( OpenAI ())

# Extract structured data from natural language
user_info = client . chat . completions . create (
    model = "gpt-4o-mini" ,
    response_model = UserInfo ,
    messages = [{ "role" : "user" , "content" : "John Doe is 30 years old." }],
)

print ( user_info . name )
#> John Doe
print ( user_info . age )
#> 30

Usando ganchos

O instrutor fornece um sistema de ganchos poderoso que permite interceptar e registrar vários estágios do processo de interação LLM. Aqui está um exemplo simples demonstrando como usar ganchos:

 import instructor
from openai import OpenAI
from pydantic import BaseModel


class UserInfo ( BaseModel ):
    name : str
    age : int


# Initialize the OpenAI client with Instructor
client = instructor . from_openai ( OpenAI ())


# Define hook functions
def log_kwargs ( ** kwargs ):
    print ( f"Function called with kwargs: { kwargs } " )


def log_exception ( exception : Exception ):
    print ( f"An exception occurred: { str ( exception ) } " )


client . on ( "completion:kwargs" , log_kwargs )
client . on ( "completion:error" , log_exception )

user_info = client . chat . completions . create (
    model = "gpt-4o-mini" ,
    response_model = UserInfo ,
    messages = [
        { "role" : "user" , "content" : "Extract the user name: 'John is 20 years old'" }
    ],
)

"""
{
        'args': (),
        'kwargs': {
            'messages': [
                {
                    'role': 'user',
                    'content': "Extract the user name: 'John is 20 years old'",
                }
            ],
            'model': 'gpt-4o-mini',
            'tools': [
                {
                    'type': 'function',
                    'function': {
                        'name': 'UserInfo',
                        'description': 'Correctly extracted `UserInfo` with all the required parameters with correct types',
                        'parameters': {
                            'properties': {
                                'name': {'title': 'Name', 'type': 'string'},
                                'age': {'title': 'Age', 'type': 'integer'},
                            },
                            'required': ['age', 'name'],
                            'type': 'object',
                        },
                    },
                }
            ],
            'tool_choice': {'type': 'function', 'function': {'name': 'UserInfo'}},
        },
    }
"""

print ( f"Name: { user_info . name } , Age: { user_info . age } " )
#> Name: John, Age: 20

Este exemplo demonstra:

Um gancho de pré-execução que registra todos os Kwargs passou para a função.
Um gancho de exceção que registra todas as exceções que ocorrem durante a execução.

Os ganchos fornecem informações valiosas sobre as entradas da função e quaisquer erros, aprimorando os recursos de depuração e monitoramento.

Usando modelos antrópicos

 import instructor
from anthropic import Anthropic
from pydantic import BaseModel


class User ( BaseModel ):
    name : str
    age : int


client = instructor . from_anthropic ( Anthropic ())

# note that client.chat.completions.create will also work
resp = client . messages . create (
    model = "claude-3-opus-20240229" ,
    max_tokens = 1024 ,
    system = "You are a world class AI that excels at extracting user data from a sentence" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Extract Jason is 25 years old." ,
        }
    ],
    response_model = User ,
)

assert isinstance ( resp , User )
assert resp . name == "Jason"
assert resp . age == 25

Usando modelos coere

Certifique -se de instalar cohere e defina a variável de ambiente do sistema com export CO_API_KEY=<YOUR_COHERE_API_KEY> .

 pip install cohere

 import instructor
import cohere
from pydantic import BaseModel


class User ( BaseModel ):
    name : str
    age : int


client = instructor . from_cohere ( cohere . Client ())

# note that client.chat.completions.create will also work
resp = client . chat . completions . create (
    model = "command-r-plus" ,
    max_tokens = 1024 ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Extract Jason is 25 years old." ,
        }
    ],
    response_model = User ,
)

assert isinstance ( resp , User )
assert resp . name == "Jason"
assert resp . age == 25

Usando modelos Gemini

Certifique -se de instalar o Google AI Python SDK. Você deve definir uma variável de ambiente GOOGLE_API_KEY com sua chave de API. A chamada de ferramentas Gemini também exige que jsonref seja instalado.

 pip install google-generativeai jsonref

 import instructor
import google . generativeai as genai
from pydantic import BaseModel


class User ( BaseModel ):
    name : str
    age : int


# genai.configure(api_key=os.environ["API_KEY"]) # alternative API key configuration
client = instructor . from_gemini (
    client = genai . GenerativeModel (
        model_name = "models/gemini-1.5-flash-latest" ,  # model defaults to "gemini-pro"
    ),
    mode = instructor . Mode . GEMINI_JSON ,
)

Como alternativa, você pode ligar para Gemini do cliente Openai. Você precisará configurar gcloud , configurar no Vertex AI e instalar a biblioteca do Google Auth.

pip install google-auth

 import google . auth
import google . auth . transport . requests
import instructor
from openai import OpenAI
from pydantic import BaseModel

creds , project = google . auth . default ()
auth_req = google . auth . transport . requests . Request ()
creds . refresh ( auth_req )

# Pass the Vertex endpoint and authentication to the OpenAI SDK
PROJECT = 'PROJECT_ID'
LOCATION = (
    'LOCATION'  # https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations
)
base_url = f'https:// { LOCATION } -aiplatform.googleapis.com/v1beta1/projects/ { PROJECT } /locations/ { LOCATION } /endpoints/openapi'

client = instructor . from_openai (
    OpenAI ( base_url = base_url , api_key = creds . token ), mode = instructor . Mode . JSON
)


# JSON mode is req'd
class User ( BaseModel ):
    name : str
    age : int


resp = client . chat . completions . create (
    model = "google/gemini-1.5-flash-001" ,
    max_tokens = 1024 ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Extract Jason is 25 years old." ,
        }
    ],
    response_model = User ,
)

assert isinstance ( resp , User )
assert resp . name == "Jason"
assert resp . age == 25

Usando Litellm

 import instructor
from litellm import completion
from pydantic import BaseModel


class User ( BaseModel ):
    name : str
    age : int


client = instructor . from_litellm ( completion )

resp = client . chat . completions . create (
    model = "claude-3-opus-20240229" ,
    max_tokens = 1024 ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Extract Jason is 25 years old." ,
        }
    ],
    response_model = User ,
)

assert isinstance ( resp , User )
assert resp . name == "Jason"
assert resp . age == 25

Os tipos são inferidos corretamente

Este foi o sonho do instrutor, mas devido ao patch do OpenAI, não foi possível que eu tivesse digitar bem. Agora, com o novo cliente, podemos fazer uma digitação funcionar bem! Também adicionamos alguns métodos create_* para facilitar a criação de iteráveis e parciais e acessar a conclusão original.

Chamando `create`

 import openai
import instructor
from pydantic import BaseModel


class User ( BaseModel ):
    name : str
    age : int


client = instructor . from_openai ( openai . OpenAI ())

user = client . chat . completions . create (
    model = "gpt-4-turbo-preview" ,
    messages = [
        { "role" : "user" , "content" : "Create a user" },
    ],
    response_model = User ,
)

Agora, se você usar um IDE, poderá ver que o tipo é inferido corretamente.

tipo

Manuseio assíncrono: `await create`

Isso também funcionará corretamente com clientes assíncronos.

 import openai
import instructor
from pydantic import BaseModel


client = instructor . from_openai ( openai . AsyncOpenAI ())


class User ( BaseModel ):
    name : str
    age : int


async def extract ():
    return await client . chat . completions . create (
        model = "gpt-4-turbo-preview" ,
        messages = [
            { "role" : "user" , "content" : "Create a user" },
        ],
        response_model = User ,
    )

Observe que, simplesmente porque retornamos o método create , a função extract() retornará o tipo de usuário correto.

assíncrono

Retornando a conclusão original: `create_with_completion`

Você também pode devolver o objeto de conclusão original

 import openai
import instructor
from pydantic import BaseModel


client = instructor . from_openai ( openai . OpenAI ())


class User ( BaseModel ):
    name : str
    age : int


user , completion = client . chat . completions . create_with_completion (
    model = "gpt-4-turbo-preview" ,
    messages = [
        { "role" : "user" , "content" : "Create a user" },
    ],
    response_model = User ,
)

with_completion

Streaming Objetos parciais: `create_partial`

Para lidar com fluxos, ainda apoiamos Iterable[T] e Partial[T] mas para simplificar a inferência do tipo, adicionamos os métodos create_iterable e create_partial também!

 import openai
import instructor
from pydantic import BaseModel


client = instructor . from_openai ( openai . OpenAI ())


class User ( BaseModel ):
    name : str
    age : int


user_stream = client . chat . completions . create_partial (
    model = "gpt-4-turbo-preview" ,
    messages = [
        { "role" : "user" , "content" : "Create a user" },
    ],
    response_model = User ,
)

for user in user_stream :
    print ( user )
    #> name=None age=None
    #> name=None age=None
    #> name=None age=None
    #> name=None age=None
    #> name=None age=None
    #> name=None age=None
    #> name='John Doe' age=None
    #> name='John Doe' age=None
    #> name='John Doe' age=None
    #> name='John Doe' age=30
    #> name='John Doe' age=30
    # name=None age=None
    # name='' age=None
    # name='John' age=None
    # name='John Doe' age=None
    # name='John Doe' age=30

Observe agora que o tipo inferido é Generator[User, None]

gerador

Streaming iterables: `create_iterable`

Temos um itemerável de objetos quando queremos extrair vários objetos.

 import openai
import instructor
from pydantic import BaseModel


client = instructor . from_openai ( openai . OpenAI ())


class User ( BaseModel ):
    name : str
    age : int


users = client . chat . completions . create_iterable (
    model = "gpt-4-turbo-preview" ,
    messages = [
        { "role" : "user" , "content" : "Create 2 users" },
    ],
    response_model = User ,
)

for user in users :
    print ( user )
    #> name='John Doe' age=30
    #> name='Jane Doe' age=28
    # User(name='John Doe', age=30)
    # User(name='Jane Smith', age=25)

iterável

Evals

Convidamos você a contribuir com o EVALS no pytest como uma maneira de monitorar a qualidade dos modelos OpenAI e a Biblioteca instructor . Para começar, confira o Evals para antrópicos e o OpenAI e contribua com seus próprios evalas na forma de testes de pytest. Esses evalas serão executados uma vez por semana e os resultados serão publicados.

Contribuindo

Se você quiser ajudar, consulte alguns dos problemas marcados como good-first-issue ou help-wanted aqui. Eles podem ser qualquer coisa, desde melhorias de código, uma postagem no blog de convidados ou um novo livro de receitas.

CLI

Também fornecemos alguma funcionalidade adicional da CLI para facilitar a conveniência:

instructor jobs : isso ajuda na criação de empregos de ajuste fino no OpenAI. instructor jobs create-from-file --help para começar a criar seu primeiro modelo GPT-3.5 de ajuste fino
instructor files : Gerencie seus arquivos enviados com facilidade. Você poderá criar, excluir e fazer upload de arquivos da linha de comando
instructor usage : em vez de ir para o site do OpenAI a cada vez, você pode monitorar seu uso da CLI e filtrar por data e hora. Observe que o uso geralmente leva ~ 5-10 minutos para atualizar do lado do OpenAi

Licença

Este projeto está licenciado nos termos da licença do MIT.

Colaboradores

Expandir

instructor

Instrutor, a biblioteca mais popular para saídas estruturadas simples

Quer seu logotipo em nosso site?

Principais recursos

Comece em minutos

Usando ganchos

Usando modelos antrópicos

Usando modelos coere

Usando modelos Gemini

Usando Litellm

Os tipos são inferidos corretamente

Chamando `create`

Manuseio assíncrono: `await create`

Retornando a conclusão original: `create_with_completion`

Streaming Objetos parciais: `create_partial`

Streaming iterables: `create_iterable`

Evals

Contribuindo

CLI

Licença

Colaboradores

Google Dorks

shepherd

hidusbf

mongo express

Free Algorithms Books

markdownpedia

chat.petals.dev

GPT Prompt Templates

GPTyped

Google Dorks

shepherd

hidusbf

Google Dorks

shepherd

hidusbf

instructor

Instrutor, a biblioteca mais popular para saídas estruturadas simples

Quer seu logotipo em nosso site?

Principais recursos

Comece em minutos

Usando ganchos

Usando modelos antrópicos

Usando modelos coere

Usando modelos Gemini

Usando Litellm

Os tipos são inferidos corretamente

Chamando create

Manuseio assíncrono: await create

Retornando a conclusão original: create_with_completion

Streaming Objetos parciais: create_partial

Streaming iterables: create_iterable

Evals

Contribuindo

CLI

Licença

Colaboradores

Chamando `create`

Manuseio assíncrono: `await create`

Retornando a conclusão original: `create_with_completion`

Streaming Objetos parciais: `create_partial`

Streaming iterables: `create_iterable`