Descarga instructor - Descarga del código fuente instructor

Instructor, la biblioteca más popular para salidas estructuradas simples

El instructor es la biblioteca de Python más popular para trabajar con salidas estructuradas de grandes modelos de idiomas (LLM), con más de 600,000 descargas mensuales. Construido sobre Pydantic, proporciona una API simple, transparente y fácil de usar para administrar la validación, los reintentos y las respuestas de transmisión. ¡Prepárese para sobrealimentar sus flujos de trabajo LLM con la mejor opción de la comunidad!

¿Quieres tu logotipo en nuestro sitio web?

Si su empresa usa mucho el instructor, ¡nos encantaría tener su logotipo en nuestro sitio web! Por favor complete este formulario

Características clave

Modelos de respuesta : Especifique modelos Pydantic para definir la estructura de sus salidas LLM
Reinting Management : configure fácilmente el número de intentos de reintento para sus solicitudes
Validación : Asegúrese de que las respuestas de LLM se ajusten a sus expectativas con la validación de Pydantic
Soporte de transmisión : Trabajar con listas y respuestas parciales sin esfuerzo
Backends flexibles : Integre a la perfección con varios proveedores de LLM más allá de Openai
Soporte en muchos idiomas : apoyamos muchos idiomas, incluidos Python, TypeScript, Ruby, GO y Elixir

Empiece en minutos

Instalar instructor con un solo comando:

pip install -U instructor

Ahora, veamos el instructor en acción con un ejemplo simple:

 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

El instructor proporciona un poderoso sistema de ganchos que le permite interceptar y registrar varias etapas del proceso de interacción LLM. Aquí hay un ejemplo simple que demuestra cómo 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 ejemplo demuestra:

Un gancho previo a la ejecución que registra todos los Kwargs pasó a la función.
Un gancho de excepción que registra cualquier excepción que ocurra durante la ejecución.

Los ganchos proporcionan información valiosa sobre las entradas de la función y cualquier error, mejorando las capacidades de depuración y monitoreo.

Uso de 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

Uso de modelos de cohere

Asegúrese de instalar cohere y establecer la variable de entorno de su sistema con 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 Géminis

Asegúrese de instalar el SDK de Google Ai Python. Debe establecer una variable de entorno GOOGLE_API_KEY con su clave API. La llamada de herramienta Gemini también requiere que se instale jsonref .

 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 ,
)

Alternativamente, puede llamar a Gemini desde el cliente Operai. Tendrá que configurar gcloud , configurar en Vertex AI e instalar la biblioteca de 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

Los tipos se infieren correctamente

Este era el sueño del instructor, pero debido al parche de OpenAi, no era posible que la escritura funcionara bien. Ahora, con el nuevo cliente, ¡podemos hacer que la escritura funcione bien! También hemos agregado algunos métodos create_* para facilitar la creación de iterables y parciales, y para acceder a la finalización original.

Llamar `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 ,
)

Ahora, si usa un IDE, puede ver que el tipo se infiere correctamente.

tipo

Manejo de async: `await create`

Esto también funcionará correctamente con clientes asincrónicos.

 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 simplemente porque devolvemos el método create , la función extract() devolverá el tipo de usuario correcto.

asíncrata

Devolviendo la finalización original: `create_with_completion`

También puede devolver el objeto de finalización 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

Transmisión de objetos parciales: `create_partial`

Para manejar las transmisiones, todavía admitimos Iterable[T] y Partial[T] pero para simplificar la inferencia de tipos, ¡también hemos agregado métodos create_iterable y create_partial !

 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 ahora que el tipo inferido es Generator[User, None]

generador

Transmisión iterable: `create_iterable`

Obtenemos una iterable de objetos cuando queremos extraer múltiples 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)

itreable

Evals

Lo invitamos a contribuir a Evals en pytest como una forma de monitorear la calidad de los modelos Operai y la biblioteca instructor . Para comenzar, consulte las Evals de Anthrope y OpenAI y contribuya con sus propias evals en forma de pruebas de Pytest. Estas evals se ejecutarán una vez por semana y se publicarán los resultados.

Que contribuye

Si desea ayudar, consulte algunos de los problemas marcados como good-first-issue o help-wanted se encuentra aquí. Podrían ser cualquier cosa, desde mejoras en el código, una publicación de blog invitada o un nuevo libro de cocina.

CLI

También proporcionamos alguna funcionalidad CLI adicional para una fácil comodidad:

instructor jobs : esto ayuda con la creación de trabajos de ajuste fino con OpenAI. instructor jobs create-from-file --help para comenzar a crear su primer modelo GPT-3.5 ajustado
instructor files : Administre sus archivos cargados con facilidad. Podrá crear, eliminar y cargar archivos todo desde la línea de comando
instructor usage : en lugar de dirigirse al sitio de Operai cada vez, puede monitorear su uso desde la CLI y filtrar por fecha y período de tiempo. Tenga en cuenta que el uso a menudo tarda ~ 5-10 minutos en actualizarse desde el lado de OpenAi

Licencia

Este proyecto tiene licencia bajo los términos de la licencia MIT.

Colaboradores

Expandir

instructor

Instructor, la biblioteca más popular para salidas estructuradas simples

¿Quieres tu logotipo en nuestro sitio web?

Características clave

Empiece en minutos

Usando ganchos

Uso de modelos antrópicos

Uso de modelos de cohere

Usando modelos Géminis

Usando litellm

Los tipos se infieren correctamente

Llamar `create`

Manejo de async: `await create`

Devolviendo la finalización original: `create_with_completion`

Transmisión de objetos parciales: `create_partial`

Transmisión iterable: `create_iterable`

Evals

Que contribuye

CLI

Licencia

Colaboradores

waymo open dataset

chat.petals.dev

Sunamu

SmartTube

MySchedule.py

viptools for eslam

chat.petals.dev

GPT Prompt Templates

GPTyped

waymo open dataset

chat.petals.dev

Sunamu

waymo open dataset

termwind

wp functions

instructor

Instructor, la biblioteca más popular para salidas estructuradas simples

¿Quieres tu logotipo en nuestro sitio web?

Características clave

Empiece en minutos

Usando ganchos

Uso de modelos antrópicos

Uso de modelos de cohere

Usando modelos Géminis

Usando litellm

Los tipos se infieren correctamente

Llamar create

Manejo de async: await create

Devolviendo la finalización original: create_with_completion

Transmisión de objetos parciales: create_partial

Transmisión iterable: create_iterable

Evals

Que contribuye

CLI

Licencia

Colaboradores

Llamar `create`

Manejo de async: `await create`

Devolviendo la finalización original: `create_with_completion`

Transmisión de objetos parciales: `create_partial`

Transmisión iterable: `create_iterable`