---
title: "DSPy : dspy.LM avec un api_base compatible OpenAI | BroadRouter"
description: "Configurez dspy.LM pour BroadNet Inference avec le préfixe openai/, api_base et model_type=\"chat\", car DSPy 3.5 envoie les modèles OpenAI vers la Responses API."
url: https://broadrouter.com/fr/guides/dspy-openai-compatible/
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/dspy-openai-compatible/) (mis à jour le 2026-11-16).

# Utiliser DSPy avec BroadNet Inference (définir model\_type="chat")

Mis à jour 2026-11-16

Créez dspy.LM avec le modèle "openai/broadnet/glm-5.3", model\_type="chat", api\_base défini sur https://inference.broadnet.ai/v1 et votre api\_key BroadNet, puis passez-le à dspy.configure. model\_type="chat" est essentiel : DSPy 3.5 envoie par défaut les modèles OpenAI vers la Responses API, que BroadNet ne sert pas. Lors de notre test sur un serveur fictif, son absence a envoyé l’appel vers /v1/responses, qui a reçu un 404, et l’endpoint réel de BroadNet répond lui aussi à ce chemin par un 404.

DSPy est un framework Python pour programmer des modèles de langage avec des signatures et des modules, et pour optimiser les prompts qui les sous-tendent. On le connecte à un modèle avec `dspy.LM`. La documentation de DSPy présente les serveurs compatibles OpenAI comme un modèle `openai/` avec `api_base`. Pour BroadNet Inference, qui sert les chat completions à l’adresse `https://inference.broadnet.ai/v1`, il faut aussi `model_type="chat"`. BroadRouter est le site de BroadNet ; ce guide suit la documentation de DSPy 3.5.

## Installation

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

## Connexion

```python
import os
import dspy

lm = dspy.LM(
    "openai/broadnet/glm-5.3",
    model_type="chat",
    api_base="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
    max_tokens=4000,
)
dspy.configure(lm=lm)

qa = dspy.Predict("question -> answer")
print(qa(question="What is the capital of Saudi Arabia?").answer)
```

-   **`openai/`** indique à DSPy d’utiliser son client OpenAI. Le reste de la chaîne, `broadnet/glm-5.3`, est l’ID de modèle envoyé à BroadNet.
-   **`model_type="chat"`** maintient DSPy sur `/v1/chat/completions`. La référence LM de DSPy indique que la valeur par défaut, `'auto'`, fait que les modèles OpenAI « use Responses » (traduction : « utilisent Responses »).
-   **`max_tokens`** laisse de la place au raisonnement. DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B réfléchissent avant de répondre, et cette réflexion compte dans la limite.

## Ce qui se passe sans model\_type

L’exemple de la page d’installation de DSPy pour un serveur compatible OpenAI omet `model_type`. Dans notre test avec DSPy 3.5.0, la requête est alors partie vers `/v1/responses` avec `max_output_tokens`, et l’appel a échoué :

```text
dspy.utils.exceptions.LMInvalidRequestError: [openai/broadnet/glm-5.3] /v1/responses not served
```

Cette erreur venait de notre serveur fictif. L’endpoint réel de BroadNet a lui aussi répondu à `/v1/responses` par un 404 lors de notre vérification du 16 novembre 2026. Ajouter `model_type="chat"` a réglé le problème.

## Modules et modèles

```python
cot = dspy.ChainOfThought("question -> answer")
print(cot(question="A train leaves at 9:40 and arrives at 13:05. How long is the trip?").answer)
```

| Usage dans DSPy | Modèle |
| --- | --- |
| `Predict`, `ChainOfThought`, exécutions d’optimiseur | `broadnet/deepseek-v4.1-flash` (prix par token bas ; forfaits à prix fixe) |
| `ReAct` et autres modules qui appellent des outils | `broadnet/glm-5.3` ou `broadnet/qwen3.8-27b` |
| Essayer DSPy avec le crédit de départ | `broadnet/gemma-4-26b-a4b` (contexte de 32 768 tokens) |

La documentation de BroadNet n’indique les outils et la sortie structurée que pour GLM 5.3 et Qwen3.8 27B. Vous pouvez utiliser un modèle pour le programme et un autre pour un optimiseur, chacun avec son propre `dspy.LM`. [Prix de tous les modèles](https://broadrouter.com/fr/pricing/).

## Comment nous l’avons testé

Le 15 novembre 2026, nous avons installé dspy 3.5.0 dans un environnement virtuel vierge et exécuté `dspy.Predict` contre un serveur fictif local qui parle le format chat completions de BroadNet et répond à `/v1/responses` par un 404. Sans `model_type`, DSPy a appelé `/v1/responses` et a échoué. Avec `model_type="chat"`, il a appelé `/v1/chat/completions` avec l’ID de modèle `broadnet/glm-5.3` et une clé Bearer, puis a lu le champ de réponse. Nous avons constaté que DSPy envoyait la limite de sortie sous la forme `max_completion_tokens`. La référence de l’API de BroadNet décrit `max_tokens` et ne mentionne pas `max_completion_tokens` : nous ne pouvons donc pas confirmer que BroadNet applique une limite envoyée ainsi. Nous avons testé contre un serveur fictif, pas avec une clé BroadNet : nous n’avons donc pas vérifié de vraie sortie de modèle.

## Dépannage

-   **404 sur /v1/responses.** Ajoutez `model_type="chat"`.
-   **404 sur /v1/chat/completions.** `api_base` doit se terminer par `/v1`, et la chaîne du modèle doit être `openai/` suivi de l’ID BroadNet complet. Les modèles payants nécessitent une recharge ; le crédit de $5 ne couvre que `broadnet/gemma-4-26b-a4b` et les deux modèles Transcribe.
-   **« Expected to find output fields ».** La réponse était vide ou tronquée, souvent parce que le raisonnement a épuisé le budget de sortie. Augmentez `max_tokens`. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **429 pendant l’optimisation.** Une clé à l’usage autorise 30 requêtes par minute et 4 requêtes en cours. Réduisez le nombre de threads de l’optimiseur et consultez [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.

[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.

[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.

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

[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é.

## Questions fréquentes

### Pourquoi DSPy appelle-t-il /v1/responses chez BroadNet ?

Selon la référence de dspy.LM de DSPy 3.5, model\_type 'auto', la valeur par défaut, fait utiliser la Responses API aux modèles OpenAI. Un modèle openai/ avec un api\_base personnalisé est traité de la même façon. Passez model\_type="chat" pour utiliser les chat completions, ce que sert BroadNet.

### Comment écrire l’ID de modèle BroadNet dans DSPy ?

Placez openai/ devant l’ID BroadNet, par exemple openai/broadnet/glm-5.3. DSPy s’appuie sur openai/ pour choisir le client et, dans notre test, a envoyé broadnet/glm-5.3 comme modèle.

### Quel modèle BroadNet convient aux optimiseurs DSPy ?

Les optimiseurs font beaucoup d’appels : coût et limites de débit comptent. DeepSeek V4.1 Flash a un prix par token bas et c’est le modèle des forfaits à prix fixe de BroadNet, non décomptés au token. Utilisez GLM 5.3 ou Qwen3.8 27B pour les modules qui appellent des outils, comme ReAct.

### Le cache de DSPy a-t-il une importance avec BroadNet ?

DSPy met en cache les appels LM par défaut (cache=True) : répéter le même appel ne coûte rien. Réglez cache=False pendant que vous vérifiez la connexion, sinon vous risquez de lire une réponse en cache.

## Guides associés

-   [Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Router LiteLLM vers BroadNet Inference (SDK et proxy)](https://broadrouter.com/fr/guides/litellm-proxy-custom-provider/)
-   [Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [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-dspy-openai-compatible&utm_content=page-cta) ·

**Sources**

-   [Documentation DSPy, installation et configuration du modèle de langage (page datée du 2026-11-10, consultée le 2026-11-15)](https://dspy.ai/current/getting-started/installation/)
-   [Documentation DSPy, référence de l’API dspy.LM (model\_type) (consulté le 2026-11-15)](https://dspy.ai/current/api/models/LM/)
-   [PyPI, dspy 3.5.0 (consulté le 2026-11-15)](https://pypi.org/project/dspy/)
-   [Référence de l’API de BroadNet Inference (consulté le 2026-11-16) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-dspy-openai-compatible&utm_content=sources)
