AI Engineering Academy · Lección

Instructor: extracción tipada con Pydantic

Use la biblioteca instructor para adaptar el cliente de OpenAI de modo que reintente y valide automáticamente las respuestas frente a su esquema de Pydantic hasta que la extracción se complete correctamente.

Lección 1 de 413 pasos

Instructor: extracción tipada con Pydantic es una lección gratuita de AI Engineering Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Engineering Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Engineering Academy incluye 4 lecciones en total.

¿Qué es la biblioteca Instructor?

La biblioteca instructor es un wrapper ligero del cliente de OpenAI que hace fiable la extracción estructurada. En lugar de confiar en que el modelo devuelva un JSON válido, instructor impone su esquema de Pydantic y vuelve a intentarlo automáticamente si la validación falla. Así elimina la necesidad de escribir su propia lógica personalizada de análisis y reintento.

Instalación de Instructor

Instale instructor con un único comando de pip. Requiere pydantic v2 y el SDK de openai. Una vez instalado, adapte el cliente de OpenAI con instructor.patch() para obtener el cliente mejorado, que admite el parámetro response_model en cada llamada.

pip install instructor openai pydantic

Adaptación del cliente de OpenAI

Instructor funciona adaptando el cliente estándar de OpenAI. Al llamar a instructor.from_openai(client) se devuelve un cliente nuevo en el que cada llamada a chat.completions.create acepta un argumento de palabra clave response_model. La llamada a la API subyacente es idéntica; instructor simplemente añade la validación del esquema.

import instructor
from openai import OpenAI

client = instructor.from_openai(OpenAI())

Definición del esquema de Pydantic

Defina la estructura de datos que desea recibir del modelo como un BaseModel de Pydantic. Los nombres de los campos, los tipos y las cadenas de documentación se convierten automáticamente en el esquema JSON que se envía al modelo. Use nombres de campo claros y descriptivos para que el modelo entienda qué debe rellenar. Añada validadores para las reglas de negocio.

from pydantic import BaseModel, Field
from typing import Optional

class PersonExtract(BaseModel):
    name: str = Field(description='Full name of the person')
    age: Optional[int] = Field(None, description='Age in years if mentioned')
    email: Optional[str] = Field(None, description='Email address if present')
    company: Optional[str] = Field(None, description='Company or employer')

Realización de una llamada de extracción

Pase la clase de su modelo de Pydantic como response_model al cliente adaptado. Instructor construye una llamada a una herramienta en segundo plano, el modelo rellena los campos e instructor deserializa el resultado en un objeto de Python tipado. Obtendrá autocompletado completo en el IDE y seguridad de tipos para los datos devueltos.

result = client.chat.completions.create(
    model='gpt-4o-mini',
    response_model=PersonExtract,
    messages=[
        {'role': 'user', 'content': 'Alice Smith, 34, works at Acme Corp. Email: alice@acme.com'}
    ]
)
print(result.name)   # Alice Smith
print(result.email)  # alice@acme.com

Reintento automático tras un fallo de validación

Si el modelo devuelve datos que no superan la validación de Pydantic, instructor envía automáticamente el error de validación al modelo y le pide que corrija su respuesta. Puede configurar el número máximo de reintentos con el parámetro max_retries. Este ciclo de autocorrección elimina la mayoría de los fallos puntuales de extracción sin necesidad de código adicional.

import instructor
from openai import OpenAI
from pydantic import BaseModel, field_validator

client = instructor.from_openai(OpenAI())

class Product(BaseModel):
    name: str
    price_usd: float

    @field_validator('price_usd')
    @classmethod
    def must_be_positive(cls, v):
        if v <= 0:
            raise ValueError('Price must be positive')
        return v

result = client.chat.completions.create(
    model='gpt-4o-mini',
    response_model=Product,
    max_retries=3,
    messages=[{'role': 'user', 'content': 'Widget costs $12.99'}]
)

Modelos anidados para estructuras complejas

Instructor gestiona sin problemas los modelos de Pydantic anidados. Puede definir esquemas profundamente anidados con listas, subobjetos opcionales y uniones discriminadas. El modelo recibe el esquema JSON completo y debe rellenar todos los campos obligatorios, por lo que resulta ideal para extraer objetos estructurados como facturas o currículos con varias secciones.

from pydantic import BaseModel
from typing import List

class LineItem(BaseModel):
    description: str
    quantity: int
    unit_price: float

class Invoice(BaseModel):
    vendor: str
    invoice_number: str
    total_amount: float
    line_items: List[LineItem]

result = client.chat.completions.create(
    model='gpt-4o',
    response_model=Invoice,
    messages=[{'role': 'user', 'content': invoice_text}]
)

Extracciones parciales en streaming

Para trabajos de extracción grandes, instructor admite el streaming parcial mediante instructor.Partial[YourModel]. A medida que el modelo genera tokens, recibe en tiempo real instancias del modelo parcialmente rellenadas. Esto resulta útil para mostrar el progreso en una interfaz de usuario o procesar los campos en cuanto llegan, en lugar de esperar a la respuesta completa.

import instructor
from openai import OpenAI

client = instructor.from_openai(OpenAI())

for partial in client.chat.completions.create_partial(
    model='gpt-4o-mini',
    response_model=PersonExtract,
    messages=[{'role': 'user', 'content': long_text}]
):
    print(partial.name, partial.email)

Extracción de listas de objetos

Cuando necesite extraer varias entidades de un solo documento, envuelva su modelo en List[YourModel]. Instructor gestiona el esquema de la matriz JSON y deserializa cada elemento en un objeto de Python tipado. Este patrón funciona bien para extraer todas las personas mencionadas en un artículo, todas las transacciones de un extracto o todas las fechas de un contrato.

from pydantic import BaseModel
from typing import List

class Mention(BaseModel):
    entity: str
    entity_type: str  # PERSON, ORG, DATE, LOCATION
    context: str

result = client.chat.completions.create(
    model='gpt-4o-mini',
    response_model=List[Mention],
    messages=[{'role': 'user', 'content': article_text}]
)
for mention in result:
    print(f'{mention.entity} ({mention.entity_type})')

Elección del modelo adecuado para la extracción

No todas las extracciones requieren GPT-4o. Para esquemas planos sencillos con menos de 10 campos, gpt-4o-mini produce resultados casi idénticos por una décima parte del coste. Use GPT-4o para esquemas anidados complejos, documentos largos o casos en los que sea importante la cobertura. Antes de elegir un modelo para producción, haga siempre una evaluación comparativa con una muestra de sus datos reales.

# Cost comparison for 1000 extractions
# GPT-4o-mini: ~$0.002 per call = $2.00 total
# GPT-4o: ~$0.015 per call = $15.00 total
# Test both on 50 samples and compare F1 score
# before committing to the expensive model

Registro y depuración de extracciones

Instructor ofrece un sistema de hooks para la observabilidad. Registre una función de retorno de llamada on_completion para guardar la respuesta sin procesar de la API, el uso de tokens y el número de reintentos de cada extracción. Esto le ayuda a identificar qué tipos de documentos provocan más fallos y a ajustar sus esquemas o prompts en consecuencia.

import instructor
from openai import OpenAI

client = instructor.from_openai(OpenAI())

@client.on('completion:response')
def log_usage(response):
    usage = response.usage
    print(f'Tokens: {usage.prompt_tokens}+{usage.completion_tokens}')

result = client.chat.completions.create(
    model='gpt-4o-mini',
    response_model=PersonExtract,
    messages=[{'role': 'user', 'content': text}]
)

Comprobación rápida

Compruebe su comprensión de la biblioteca instructor para la extracción tipada.

Resumen de la lección

En esta lección ha aprendido que instructor adapta el cliente de OpenAI para aceptar un parámetro response_model que impone esquemas de Pydantic; que el reintento automático tras un fallo de validación hace que la extracción sea sólida sin gestionar manualmente los errores; y que los modelos anidados y la extracción de listas permiten analizar documentos complejos con varias entidades y convertirlos en objetos de Python totalmente tipados. A continuación, gestionaremos los datos parciales y ausentes en los esquemas extraídos.

Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
30
Lecciones
120

Preguntas frecuentes

¿La lección «Instructor: extracción tipada con Pydantic» es gratis?

Sí — el texto completo de «Instructor: extracción tipada con Pydantic» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Engineering Academy, actualiza a CoddyKit PRO. El curso de AI Engineering Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Instructor: extracción tipada con Pydantic»?

Use la biblioteca instructor para adaptar el cliente de OpenAI de modo que reintente y valide automáticamente las respuestas frente a su esquema de Pydantic hasta que la extracción se complete correc… Practicas AI Engineering Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Engineering Academy?

No se requiere experiencia previa. AI Engineering Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Instructor: extracción tipada con Pydantic»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Engineering Academy?

Sí. Cada lección de AI Engineering Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Instructor: extracción tipada con Pydantic
  2. Gestión de datos parciales y ausentes
  3. Procesamiento por lotes con asincronía y colas
  4. Evolución de esquemas y compatibilidad con versiones anteriores
← Volver a AI Engineering Academy