Ir al contenido principal
Español— Elegir un idioma
Menú

Extracción y validación con herramientas

Lección 10 de 12 Actualizado el 30 de julio de 2026 Desarrollador
En esta página
  1. Construcción de canalizaciones de extracción fiables
  2. Patrón: extracción enriquecida
  3. Patrón: validación cruzada
  4. Patrón: cálculo y estructuración
  5. Arquitectura de una canalización robusta
  6. Gestión de errores en producción
  7. Puntos clave

Construcción de canalizaciones de extracción fiables

Al combinar salidas estructuradas con herramientas (búsqueda web, ejecución de código), puedes construir canalizaciones de extracción y validación robustas. Esta lección muestra cómo arquitecturar estas canalizaciones para su uso en producción.

Patrón: extracción enriquecida

El patrón más común consiste en enriquecer la extracción de datos mediante búsqueda web. Comienzas con texto sin procesar; el modelo extrae las entidades y luego las enriquece con información encontrada en línea.

from pydantic import BaseModel

class EntrepriseEnrichie(BaseModel):
    nom: str
    secteur: str
    pays_siege: str
    site_web: str | None
    description_courte: str
    nombre_employes_estime: str | None
    technologies_utilisees: list[str]

class ExtractionEnrichie(BaseModel):
    entreprises: list[EntrepriseEnrichie]
    relations: list[str]
    contexte: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Extrae y enriquece las empresas mencionadas en este texto:

        'Mistral AI anunció una asociación con Scaleway para
        alojar sus modelos en Francia. Mientras tanto, Hugging Face
        continúa colaborando con OVHcloud en infraestructura de código
        abierto.'"""
    }],
    response_format=ExtractionEnrichie,
    tools=[{"type": "web_search"}]
)

Patrón: validación cruzada

La validación cruzada utiliza la búsqueda web para verificar la información extraída de un documento:

class FactCheck(BaseModel):
    affirmation: str
    verifie: bool
    source: str | None
    correction: str | None
    confiance: float

class RapportValidation(BaseModel):
    document_original: str
    verifications: list[FactCheck]
    fiabilite_globale: float
    resume: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Verifica los hechos de este texto:
        'Francia tiene 68 millones de habitantes. París es la
        ciudad más grande de Europa. El PIB de Francia es el 7.º
        mayor del mundo.'"""
    }],
    response_format=RapportValidation,
    tools=[{"type": "web_search"}]
)

for v in parsed.verifications:
    status = "Verificado" if v.verifie else "No verificado"
    print(f"[{status}] {v.affirmation}")
    if v.correction:
        print(f"  → Corrección: {v.correction}")

Patrón: cálculo y estructuración

Combina la ejecución de código para los cálculos y las salidas estructuradas para el formato:

class LigneFacture(BaseModel):
    description: str
    quantite: int
    prix_unitaire_ht: float
    montant_ht: float
    tva: float
    montant_ttc: float

class Facture(BaseModel):
    lignes: list[LigneFacture]
    total_ht: float
    total_tva: float
    total_ttc: float

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Calcula la factura:
        - 3x Licencia Pro a 299 EUR sin IVA (IVA 20 %)
        - 1x Formación a 1500 EUR sin IVA (IVA 20 %)
        - 12x Soporte mensual a 49 EUR sin IVA (IVA 20 %)"""
    }],
    response_format=Facture,
    tools=[{"type": "code_interpreter"}]
)

print(f"Total sin IVA: {parsed.total_ht} EUR")
print(f"Total con IVA: {parsed.total_ttc} EUR")

Arquitectura de una canalización robusta

Para su uso en producción, estructura tu canalización en pasos:

# Paso 1: Extracción bruta
class ExtractionBrute(BaseModel):
    entites: list[str]
    dates: list[str]
    montants: list[str]

# Paso 2: Enriquecimiento
class EntiteEnrichie(BaseModel):
    nom: str
    type: str
    details: str

# Paso 3: Validación
class ResultatValide(BaseModel):
    entites: list[EntiteEnrichie]
    score_qualite: float
    alertes: list[str]

Cada paso utiliza una llamada independiente con un esquema adaptado. Este enfoque modular simplifica la depuración y el monitoreo.

Gestión de errores en producción

try:
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema,
        tools=[{"type": "web_search"}]
    )
except Exception as e:
    # Alternativa sin búsqueda web
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema
    )

Puntos clave

  • La extracción enriquecida combina búsqueda web + salidas estructuradas para obtener datos completos
  • La validación cruzada verifica hechos mediante búsqueda web
  • La ejecución de código garantiza cálculos exactos en canalizaciones financieras
  • Estructura en pasos separados para lograr robustez y facilitar la depuración
  • Planifica siempre una alternativa por si fallan las herramientas