---
title: "Haystack : OpenAIChatGenerator avec une api_base_url"
description: "Pointez l’OpenAIChatGenerator de Haystack vers BroadNet Inference avec api_base_url, un ID BroadNet et un Secret : pipelines, outils, streaming et agents."
url: https://broadrouter.com/fr/guides/haystack-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/haystack-openai-compatible/) (mis à jour le 2026-11-16).

# Utiliser les pipelines et agents Haystack avec BroadNet Inference

Mis à jour 2026-11-16

Installez haystack-ai et créez un OpenAIChatGenerator avec api\_base\_url réglé sur https://inference.broadnet.ai/v1, api\_key sur un Secret lu dans BROADNET\_API\_KEY et model sur un ID BroadNet comme broadnet/glm-5.3. Utilisez-le dans des pipelines ou un Agent Haystack. Passez max\_tokens dans generation\_kwargs, et prenez GLM 5.3 ou Qwen3.8 27B quand le générateur a des outils.

Haystack est le framework open source de deepset pour les pipelines RAG et les agents. Son `OpenAIChatGenerator` dialogue avec n’importe quel serveur compatible OpenAI via `api_base_url`. BroadNet Inference sert des chat completions standard à `https://inference.broadnet.ai/v1` : c’est donc le composant à utiliser. BroadRouter est le site de BroadNet ; ce guide suit la documentation de Haystack 3.5.

## Installation

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

## Connexion

```python
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.utils import Secret

generator = OpenAIChatGenerator(
    api_base_url="https://inference.broadnet.ai/v1",
    api_key=Secret.from_env_var("BROADNET_API_KEY"),
    model="broadnet/glm-5.3",
    generation_kwargs={"max_tokens": 4000},
)

reply = generator.run([ChatMessage.from_user("Name three uses of a RAG pipeline.")])
print(reply["replies"][0].text)
```

-   **`model`** est envoyé tel quel. Utilisez l’ID BroadNet avec son préfixe `broadnet/`.
-   **`api_key`** est un `Secret` Haystack. Sans lui, Haystack cherche `OPENAI_API_KEY`.
-   **`generation_kwargs`** est transmis dans la requête chat completion. Réglez `max_tokens` assez haut pour le raisonnement (voir plus bas).

## Streamer la réponse

```python
from haystack.components.generators.utils import print_streaming_chunk

generator = OpenAIChatGenerator(
    api_base_url="https://inference.broadnet.ai/v1",
    api_key=Secret.from_env_var("BROADNET_API_KEY"),
    model="broadnet/glm-5.3",
    streaming_callback=print_streaming_chunk,
)
```

Haystack envoie alors `stream: true` avec `stream_options.include_usage`, si bien que le décompte des tokens arrive dans le dernier chunk. La documentation de BroadNet décrit la même option.

## Outils et agents

```python
from haystack.components.agents import Agent
from haystack.tools import Tool

def get_weather(city: str) -> str:
    return f"21C in {city}"

weather = Tool(
    name="get_weather",
    description="Get the weather for a city",
    parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    function=get_weather,
)

chat = OpenAIChatGenerator(
    api_base_url="https://inference.broadnet.ai/v1",
    api_key=Secret.from_env_var("BROADNET_API_KEY"),
    model="broadnet/glm-5.3",
    tools=[weather],
)
agent = Agent(chat_generator=chat, tools=[weather])
result = agent.run(messages=[ChatMessage.from_user("What's the weather in Riyadh?")])
print(result["messages"][-1].text)
```

La documentation de BroadNet indique les outils et la sortie structurée pour `broadnet/glm-5.3` et `broadnet/qwen3.8-27b` uniquement. Laissez `tools_strict` à sa valeur par défaut, `False`, tant que vous n’avez pas testé les schémas stricts.

## Quel modèle choisir ?

| Pipeline | Modèle |
| --- | --- |
| Agents et appels d’outils | `broadnet/glm-5.3` |
| RAG sur des pages scannées ou du texte arabe, avec outils | `broadnet/qwen3.8-27b` |
| Réponses sur long contexte avec un forfait à prix fixe | `broadnet/deepseek-v4.1-flash` |
| Essai avec le crédit de départ gratuit | `broadnet/gemma-4-26b-a4b` (contexte de 32 768 tokens) |

Le contexte récupéré peut être volumineux. GLM 5.3 et DeepSeek V4.1 Flash acceptent 1 048 576 tokens de contexte ; les 32 768 de Gemma se remplissent vite. [Les prix de chaque modèle](https://broadrouter.com/fr/pricing/).

## Comment nous l’avons testé

Le 15 novembre 2026, nous avons installé haystack-ai 3.5.0 dans un environnement virtuel vierge et exécuté les exemples ci-dessus (simple, streaming, outils et Agent) contre un serveur fictif local qui parle le format chat completions de BroadNet. Nous avons lu les requêtes journalisées. Toutes sont arrivées sur `/v1/chat/completions` avec l’ID de modèle inchangé, une clé Bearer, le `max_tokens` issu de `generation_kwargs` et, pour les outils, le schéma de la fonction. Haystack envoie aussi `n: 1`. Faute de clé BroadNet, nous n’avons pas testé de vraie sortie de modèle.

## Dépannage

-   **401.** La clé est erronée, a expiré ou a épuisé son allocation, ou `BROADNET_API_KEY` n’est pas défini dans le processus qui exécute le pipeline.
-   **404.** `api_base_url` doit se terminer par `/v1`, et l’ID de modèle doit correspondre exactement à celui de BroadNet. 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.
-   **Réponses vides.** DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et ce raisonnement est décompté de `max_tokens`. Augmentez-le. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **429 pendant une indexation par lots ou une évaluation.** Une clé à l’usage autorise 30 requêtes par minute et 4 requêtes en cours. Utilisez le `max_retries` du générateur et consultez [codes d’erreur et nouvelles tentatives](https://broadrouter.com/fr/guides/errors-and-retries/).

## Termes de ce guide

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

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

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

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

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

[RAG (génération augmentée par récupération)](https://broadrouter.com/fr/glossary/rag/)

Le RAG (retrieval-augmented generation, génération augmentée par récupération) est une approche dans laquelle une application récupère d’abord, dans une source externe comme un index de recherche ou un index vectoriel, les passages pertinents pour une question, puis les ajoute au prompt pour qu’un modèle de langage réponde à partir de ce texte et pas seulement de sa mémoire.

[Streaming](https://broadrouter.com/fr/glossary/streaming/)

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

## Questions fréquentes

### Quel paramètre de Haystack définit l’URL de BroadNet ?

api\_base\_url sur OpenAIChatGenerator. La documentation de Haystack le présente comme le moyen d’atteindre des déploiements personnalisés. Réglez-le sur https://inference.broadnet.ai/v1.

### Faut-il utiliser OpenAIResponsesChatGenerator avec BroadNet ?

Non. Ce composant appelle l’API Responses d’OpenAI, que BroadNet ne liste pas. Utilisez OpenAIChatGenerator, qui appelle chat completions.

### Pourquoi Haystack échoue-t-il faute d’OPENAI\_API\_KEY ?

La valeur par défaut d’api\_key est Secret.from\_env\_var("OPENAI\_API\_KEY"). Passez api\_key=Secret.from\_env\_var("BROADNET\_API\_KEY") pour que Haystack lise votre clé BroadNet à la place.

### Un Agent Haystack peut-il appeler des outils sur BroadNet ?

Oui, avec un modèle que BroadNet liste avec les outils : GLM 5.3 ou Qwen3.8 27B. Lors de notre test sur serveur fictif, l’Agent a envoyé le schéma de l’outil via chat completions et a reçu l’appel d’outil en retour.

## Guides associés

-   [Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Utiliser LlamaIndex avec BroadNet Inference via OpenAILike](https://broadrouter.com/fr/guides/llamaindex-openailike/)
-   [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-haystack-openai-compatible&utm_content=page-cta) ·

**Sources**

-   [Documentation Haystack 3.5, OpenAIChatGenerator (consulté le 2026-11-15)](https://docs.haystack.deepset.ai/docs/openaichatgenerator)
-   [PyPI, haystack-ai 3.5.0, Python 3.11+ (consulté le 2026-11-15)](https://pypi.org/project/haystack-ai/)
-   [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-haystack-openai-compatible&utm_content=sources)
