---
title: "Instructor avec une base_url compatible OpenAI (Pydantic)"
description: "Extrayez des objets Pydantic de BroadNet Inference avec Instructor, via from_openai ou from_provider et une base_url personnalisée, et choisissez le bon Mode."
url: https://broadrouter.com/fr/guides/instructor-structured-output/
lang: fr
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/guides/instructor-structured-output/) (mis à jour le 2026-11-16).

# Obtenir une sortie structurée avec Instructor sur BroadNet Inference

Mis à jour 2026-11-16

Enveloppez avec instructor.from\_openai un client OpenAI configuré avec la base\_url https://inference.broadnet.ai/v1 et votre clé BroadNet, puis appelez chat.completions.create avec response\_model réglé sur votre classe Pydantic et model sur broadnet/glm-5.3 ou broadnet/qwen3.8-27b. Ce sont les deux modèles que BroadNet liste avec outils et sortie structurée. Mode.TOOLS est le mode par défaut ; Mode.JSON\_SCHEMA fonctionne aussi.

Instructor est une bibliothèque Python qui transforme les réponses d’un LLM en objets Pydantic validés et peut relancer la requête quand la validation échoue. Elle modifie le client OpenAI, et sa documentation couvre les serveurs compatibles OpenAI via `base_url`. BroadNet Inference sert les chat completions à `https://inference.broadnet.ai/v1` et indique les outils et la sortie structurée pour GLM 5.3 et Qwen3.8 27B. BroadRouter est le site de BroadNet ; ce guide suit la documentation d’Instructor dans sa version 1.17.0.

## Installation

```bash
pip install instructor
export BROADNET_API_KEY='your-broadnet-key'
```

## Extraire un objet

```python
import os
import instructor
from openai import OpenAI
from pydantic import BaseModel

class Invoice(BaseModel):
    vendor: str
    total: float
    currency: str

client = instructor.from_openai(
    OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"]),
    mode=instructor.Mode.TOOLS,
)

invoice = client.chat.completions.create(
    model="broadnet/glm-5.3",
    response_model=Invoice,
    max_tokens=4000,
    messages=[{"role": "user", "content": "Acme Trading invoice, total 1,250.00 SAR"}],
)
print(invoice)
```

Instructor transforme `Invoice` en schéma d’outil, oblige le modèle à l’appeler via `tool_choice` et valide les arguments. Passez `max_retries` pour fixer combien de fois il redemande, en joignant l’erreur de validation, quand l’objet n’est pas valide.

## Ou utiliser from\_provider

```python
pclient = instructor.from_provider(
    "openai/broadnet/glm-5.3",
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
invoice = pclient.create(response_model=Invoice, max_tokens=4000,
                         messages=[{"role": "user", "content": "Acme Trading, 1,250.00 SAR"}])
```

La partie `openai/` choisit le client. Le reste, `broadnet/glm-5.3`, est envoyé comme ID de modèle.

## Quel mode ?

| Mode | Ce qu’il envoie | Avec BroadNet |
| --- | --- | --- |
| `Mode.TOOLS` (par défaut) | Un appel d’outil forcé avec votre schéma | Oui, sur GLM 5.3 ou Qwen3.8 27B |
| `Mode.JSON_SCHEMA` | Un `response_format` de type `json_schema` | Oui, sur GLM 5.3 ou Qwen3.8 27B |
| `Mode.MD_JSON` | Une requête simple ; JSON extrait du texte | Solution de repli pour les autres modèles ; à tester d’abord |
| `Mode.RESPONSES_TOOLS` | L’API Responses | Non : BroadNet sert chat completions |

## Images

Qwen3.8 27B accepte les images en plus des outils et peut donc lire une photo ou un scan directement dans votre modèle :

```python
import base64
img = base64.b64encode(open("invoice.jpg", "rb").read()).decode()
invoice = client.chat.completions.create(
    model="broadnet/qwen3.8-27b",
    response_model=Invoice,
    max_tokens=4000,
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "Extract the invoice fields."},
        {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + img}},
    ]}],
)
```

Avec une clé à l’usage, une image compte comme des tokens d’entrée. Voir [lire des factures arabes avec la vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/).

## Comment nous l’avons testé

Le 15 novembre 2026, nous avons installé instructor 1.17.0 avec openai 3.3.0 dans un environnement virtuel vierge et exécuté les exemples ci-dessus contre un serveur fictif local qui parle le format chat completions de BroadNet. Nous avons lu les requêtes journalisées. `Mode.TOOLS` a envoyé le schéma comme outil avec un `tool_choice` forcé, `Mode.JSON_SCHEMA` a envoyé un format de réponse `json_schema`, et les deux ont renvoyé un `Invoice` valide. `from_provider` a envoyé l’ID de modèle inchangé. Notre serveur fictif n’écrit pas de JSON en texte libre : nous n’avons donc pas testé `Mode.MD_JSON`, ni envoyé l’exemple d’image. Faute de clé BroadNet, nous n’avons pas testé de vraie sortie de modèle.

## Dépannage

-   **Des relances de validation qui n’aboutissent jamais.** Sur GLM 5.3 et Qwen3.8 27B, le raisonnement est décompté de `max_tokens`. Une limite basse peut tronquer les arguments de l’outil. Augmentez-la. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **400 sur la requête.** Vérifiez que vous utilisez GLM 5.3 ou Qwen3.8 27B. Si un `tool_choice` forcé est refusé, essayez `Mode.JSON_SCHEMA`.
-   **401.** La clé est erronée, a expiré ou a épuisé son allocation.
-   **404.** `base_url` doit se terminer par `/v1`. GLM 5.3 et Qwen3.8 27B nécessitent une recharge ; le crédit de $5 ne les couvre pas.
-   **429 en extraction par lots.** Une clé à l’usage autorise 30 requêtes par minute et 4 requêtes en cours. Chaque relance de validation est une requête de plus. Voir [codes d’erreur et nouvelles tentatives](https://broadrouter.com/fr/guides/errors-and-retries/).

## Termes de ce guide

[API Chat Completions](https://broadrouter.com/fr/glossary/chat-completions-api/)

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Crédit prépayé (prepaid credit)](https://broadrouter.com/fr/glossary/prepaid-credit/)

Le crédit prépayé est de l’argent versé sur un compte API avant utilisation. Chaque requête déduit son coût du solde, et quand le solde est épuisé, les requêtes facturées s’arrêtent jusqu’à la prochaine recharge. Les dépenses sont ainsi plafonnées à ce que vous avez versé.

[Sortie structurée (structured output)](https://broadrouter.com/fr/glossary/structured-output/)

La sortie structurée est une fonction des API LLM qui contraint la réponse d’un modèle à un format défini par le développeur, en général un JSON Schema, pour que le code puisse l’analyser de façon fiable. Elle est plus stricte que le mode JSON, qui garantit un JSON valide mais pas une structure précise.

## Questions fréquentes

### Quel mode d’Instructor utiliser avec BroadNet ?

Mode.TOOLS, le mode par défaut, sur GLM 5.3 ou Qwen3.8 27B, que BroadNet liste avec outils et sortie structurée. Mode.JSON\_SCHEMA envoie à la place un response\_format de type json\_schema. Les deux ont produit des objets valides lors de notre test sur serveur fictif.

### Puis-je utiliser Mode.RESPONSES\_TOOLS ?

Non. La documentation d’Instructor conseille de ne le choisir que si le serveur implémente l’API Responses. BroadNet ne sert que chat completions.

### Instructor fonctionne-t-il avec DeepSeek V4.1 Flash ou Gemma sur BroadNet ?

BroadNet n’indique ni outils ni sortie structurée pour ces modèles. Mode.MD\_JSON demande du JSON en texte brut puis l’analyse ; cela peut marcher, mais testez-le sur vos propres données avant de vous y fier.

### Comment écrire la chaîne de modèle pour from\_provider ?

Utilisez openai/broadnet/glm-5.3. Instructor détache le premier segment comme fournisseur, et lors de notre test il a envoyé broadnet/glm-5.3 au serveur sans modification.

## Guides associés

-   [Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Pydantic AI avec BroadNet Inference (OpenAICompatibleProvider)](https://broadrouter.com/fr/guides/pydantic-ai-openai-compatible/)
-   [Lire des factures et reçus arabes avec un modèle de vision](https://broadrouter.com/fr/guides/read-arabic-invoices-with-vision/)
-   [Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Tous les outils compatibles avec BroadNet Inference (en anglais)](https://broadrouter.com/integrations/) : SDK, agents de code, interfaces de chat et outils d’automatisation, avec les réglages exacts pour chacun

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-instructor-structured-output&utm_content=page-cta) ·

**Sources**

-   [Documentation d’Instructor, OpenAI et serveurs compatibles OpenAI (consulté le 2026-11-15)](https://python.useinstructor.com/integrations/openai/)
-   [PyPI, instructor 1.17.0 (consulté le 2026-11-15)](https://pypi.org/project/instructor/)
-   [Référence de l’API de BroadNet Inference (consulté le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-instructor-structured-output&utm_content=sources)
