---
title: "Haystack avec des modèles hébergés en Europe"
description: "Pointez l’OpenAIChatGenerator de Haystack vers inference.eu avec api_base_url et faites tourner RAG et agents sur des modèles open-weight traités dans l’UE."
canonical: "https://inference.eu/fr/integrations/haystack/"
language: "fr"
---

Frameworks · Haystack

# Utiliser Haystack avec des modèles open source hébergés dans l’UE

Haystack, le framework open source de deepset, construit des pipelines de recherche, de RAG et d’agents à partir de composants assemblables. Son \`OpenAIChatGenerator\` accepte une \`api\_base\_url\` personnalisée : chaque pipeline qui génère du texte peut alors tourner sur les modèles open-weight d’inference.eu, traités dans des centres de données européens.

[Contacter l'équipe](https://inference.eu/fr/contact/)[Configuration](#setup)

1.  01Format d'API: OpenAI
2.  02Centres de données dans l'UE
3.  03Couvert par un seul DPA

## Configuré en quelques minutes

1.  1

    Créez une clé API dans votre compte inference.eu et enregistrez-la sous `INFERENCE_EU_API_KEY`.

2.  2

    Installez Haystack avec `pip install haystack-ai`.

3.  3

    Créez `OpenAIChatGenerator` avec `api_key=Secret.from_env_var("INFERENCE_EU_API_KEY")`, `api_base_url` réglé sur l’URL de base d’inference.eu et un identifiant inference.eu dans `model`.

4.  4

    Ajoutez le générateur à votre pipeline, relié à un `ChatPromptBuilder` ou utilisé dans un `Agent`.

5.  5

    Exécutez une fois le pipeline avec une question de test pour vérifier la connexion.

python

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

generator = OpenAIChatGenerator(
    api_key=Secret.from_env_var("INFERENCE_EU_API_KEY"),
    api_base_url="https://api.inference.eu/v1",
    model="gpt-oss-120b",
)

result = generator.run([ChatMessage.from_user("Summarise GDPR Article 28 in two sentences.")])
print(result["replies"][0].text)
```

## Qu’est-ce que Haystack

Haystack est un framework Python open source de deepset pour construire des pipelines de production autour des modèles de langage. Vous reliez des composants comme des retrievers, des rankers, des constructeurs de prompts et des générateurs en un graphe, sérialisable en YAML, versionnable et déployable. Le composant `Agent` ajoute des boucles d’appels d’outils à n’importe quel générateur de chat.

Les générateurs sont les composants qui appellent un modèle de langage. `OpenAIChatGenerator` parle le format OpenAI Chat Completions et accepte un point d’accès personnalisé via `api_base_url` : c’est la méthode documentée pour le pointer vers une API compatible comme inference.eu.

## Comment fonctionne la configuration

Créez `OpenAIChatGenerator` avec `api_base_url` réglé sur l’URL de base d’inference.eu terminée par `/v1` et `model` sur un identifiant inference.eu. Passez la clé sous la forme `Secret.from_env_var("INFERENCE_EU_API_KEY")` : Haystack la résout à l’exécution et n’écrit jamais sa valeur dans les pipelines sérialisés.

Dans les définitions YAML, les mêmes réglages figurent sous les `init_parameters` du générateur, avec `api_key` en secret de type `env_var`. Les paramètres du modèle comme `temperature` ou `max_completion_tokens` vont dans `generation_kwargs`. Pour le streaming, passez un `streaming_callback`, par exemple `print_streaming_chunk` fourni par Haystack.

## Quels modèles choisir

Pour les pipelines RAG qui répondent à partir de documents récupérés, `gpt-oss-120b` est un choix par défaut rapide qui reste fidèle au contexte fourni. Pour les longs documents, les nombreux passages ou les réponses qui demandent une synthèse soignée, `glm-5.3` et `kimi-k3` sont de bonnes options.

Pour le composant `Agent` et les pipelines avec outils, choisissez un modèle aux appels d’outils fiables, comme `qwen3-coder-480b-a35b-instruct`, `glm-5.3` ou `kimi-k3`. Un pipeline peut contenir plusieurs générateurs : utilisez par exemple un modèle rapide pour reformuler ou classer les requêtes et un modèle plus puissant pour la réponse finale.

## Dépannage

Une erreur 401 signifie que le secret a donné une clé vide ou erronée. Vérifiez que `INFERENCE_EU_API_KEY` est définie dans le processus qui exécute le pipeline ; `Secret.from_env_var` lève une erreur à l’exécution si la variable manque. Une erreur 404 vient le plus souvent d’un chemin en trop dans `api_base_url` ou d’un identifiant inconnu.

Si la sortie structurée échoue, simplifiez le modèle Pydantic passé dans `response_format` au sein de `generation_kwargs` et validez le résultat. Si un agent tourne en boucle sans appeler d’outils, vérifiez que le modèle les prend en charge. Un pipeline sérialisé qui référence encore `OPENAI_API_KEY` enverra la mauvaise clé : mettez le YAML à jour.

## Garder les données dans l’UE

Avec `api_base_url` pointant vers inference.eu, les prompts et documents récupérés que vos pipelines envoient au modèle sont traités dans des centres de données de l’UE et ne servent jamais à l’entraînement. Nous signons un accord de sous-traitance au titre de l’article 28 du RGPD, publions la liste de nos sous-traitants et facturons en euros.

Un pipeline Haystack comprend généralement plus qu’un générateur : des embedders, un document store, des convertisseurs et parfois du traçage. Chacun traite aussi vos documents. Choisissez pour eux des solutions hébergées dans l’UE ou auto-hébergées, afin que documents, embeddings et requêtes de modèle restent en Europe.

## Haystack

Catégorie

Frameworks

Éditeur

deepset

Format d'API

OpenAI

Traitement

Centres de données dans l'UE

Site web

[haystack.deepset.ai](https://haystack.deepset.ai/)

Documentation

[docs.haystack.deepset.ai](https://docs.haystack.deepset.ai/docs/openaichatgenerator)

## Haystack : questions fréquentes

Les questions que nous posent le plus les achats, les développeurs et les juristes. Il en manque une ? Posez-la-nous directement.

Créez \`OpenAIChatGenerator\` avec \`api\_base\_url\`, \`api\_key\` et \`model\`. Haystack documente \`api\_base\_url\` pour les déploiements personnalisés ; chaque pipeline ou agent qui utilise ce générateur envoie alors ses requêtes à ce point d’accès.

Utilisez \`Secret.from\_env\_var("INFERENCE\_EU\_API\_KEY")\`. Haystack lit la valeur à l’exécution et ne sérialise que le nom de la variable : la clé ne se retrouve jamais dans les fichiers YAML, les journaux ou le gestionnaire de versions.

gpt-oss-120b est un choix par défaut rapide pour des réponses RAG fondées sur les documents récupérés. GLM-5.3 et Kimi K3 conviennent aux longs documents et à la synthèse soignée, et Qwen3 Coder 480B, GLM-5.3 et Kimi K3 fonctionnent bien avec le composant \`Agent\` et les outils.

Oui. Passez un \`streaming\_callback\`, comme \`print\_streaming\_chunk\` de Haystack ou votre propre fonction, à la création du générateur ou lors de l’appel à \`run\`. Chaque fragment est transmis au callback dès son arrivée depuis inference.eu.

Oui. Passez à l’agent un \`OpenAIChatGenerator\` configuré pour inference.eu comme \`chat\_generator\`, avec vos outils. Choisissez un modèle aux appels d’outils fiables pour que la boucle de l’agent se termine proprement.

Oui. Passez un modèle Pydantic ou un schéma JSON comme \`response\_format\` dans \`generation\_kwargs\`. Le respect du schéma dépend du modèle : validez donc la réponse et gardez des schémas simples pour obtenir les résultats les plus fiables.

Sous les \`init\_parameters\` du générateur, réglez \`api\_base\_url\` sur l’URL de base d’inference.eu, \`model\` sur l’identifiant du modèle et \`api\_key\` sur un secret \`env\_var\` qui désigne \`INFERENCE\_EU\_API\_KEY\`. Chargez ensuite le pipeline comme d’habitude avec \`Pipeline.loads\`.

Le secret a donné une mauvaise clé, ou aucune. Vérifiez que la variable est définie dans l’environnement qui exécute le pipeline, et que les pipelines sérialisés ne désignent plus \`OPENAI\_API\_KEY\` comme nom de secret.

Cette page porte sur la génération de texte. Pour les embedders, choisissez un modèle dont l’hébergement répond à vos exigences, idéalement dans l’UE ou auto-hébergé, pour que documents et requêtes restent en Europe avec les requêtes de votre générateur.

Haystack envoie les données aux composants configurés. Il collecte aussi par défaut une télémétrie d’usage anonyme, sans documents ni prompts ; réglez \`HAYSTACK\_TELEMETRY\_ENABLED=False\` pour la désactiver. Vérifiez où vos document stores et outils de traçage conservent les données.

[Poser une question](https://inference.eu/fr/contact/)

## Pages liées

[Toutes les intégrations](https://inference.eu/fr/integrations/)

-   [LlamaIndexConnectez LlamaIndex à inference.eu avec la classe OpenAILike et faites tourner vos pipelines RAG et agents sur des modèles open-weight traités dans l’UE.Frameworks](https://inference.eu/fr/integrations/llamaindex/)
-   [LangChainConnectez ChatOpenAI de LangChain à inference.eu avec base\_url et faites tourner chaînes, agents et LangGraph sur des modèles open-weight traités dans l’UE.Frameworks](https://inference.eu/fr/integrations/langchain/)
-   [Pydantic AIConnectez vos agents Pydantic AI à inference.eu avec OpenAICompatibleProvider et obtenez des sorties typées de modèles open-weight traités dans l’UE.Frameworks](https://inference.eu/fr/integrations/pydantic-ai/)

## Faites passer vos charges IA sur une infrastructure européenne

Dites-nous quels modèles vous utilisez et votre volume approximatif. Nous répondons sous un jour ouvré avec un tarif et la suite.

-   Réponse sous un jour ouvré
-   Tarif adapté à votre volume
-   DPA prêt à signer