---
title: "LlamaIndex avec des modèles hébergés en Europe"
description: "Connectez 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."
canonical: "https://inference.eu/fr/integrations/llamaindex/"
language: "fr"
---

Frameworks · LlamaIndex

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

LlamaIndex est un framework pour construire des pipelines de génération augmentée par la recherche et des agents sur vos propres documents. Sa classe \`OpenAILike\` se connecte à toute API compatible OpenAI : moteurs de requête, moteurs de chat et agents tournent alors 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 l’intégration avec `pip install llama-index-llms-openai-like`.

3.  3

    Créez `OpenAILike` avec `api_base` réglé sur l’URL de base d’inference.eu, votre clé et un identifiant inference.eu dans `model`.

4.  4

    Réglez `is_chat_model=True`, `is_function_calling_model=True` et un `context_window` adapté au modèle.

5.  5

    Assignez le modèle à `Settings.llm` ou passez-le à votre moteur de requête ou à votre agent, puis lancez une requête de test.

python

```
import os
from llama_index.core import Settings
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="glm-5.3",
    api_base="https://api.inference.eu/v1",
    api_key=os.environ["INFERENCE_EU_API_KEY"],
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=131072,
)

Settings.llm = llm
print(llm.complete("Summarise GDPR Article 28 in two sentences."))
```

## Qu’est-ce que LlamaIndex

LlamaIndex est un framework de données open source pour les applications de modèles de langage. Il charge et analyse les documents, les découpe en nœuds, construit des index et retrouve le bon contexte pour chaque question. Il propose par-dessus des moteurs de requête, des moteurs de chat, des agents et des workflows pilotés par événements.

LlamaIndex sépare le modèle de langage du reste du pipeline. Chaque composant peut utiliser un objet LLM, et `OpenAILike` est la classe prévue pour les API tierces au format OpenAI. Définissez-la une fois dans `Settings.llm` et tous les index et moteurs de votre application utilisent inference.eu.

## Comment fonctionne la configuration

`OpenAILike` prend `api_base` (l’URL de base d’inference.eu terminée par `/v1`), `api_key` et `model`. Contrairement à la classe `OpenAI`, elle ne présume pas des capacités du modèle : trois réglages comptent donc. `is_chat_model=True` envoie les requêtes au point d’accès de chat ; par défaut, c’est l’ancien point d’accès de complétion qui est utilisé.

`is_function_calling_model=True` permet aux agents d’utiliser les appels d’outils natifs ; sinon, ils se rabattent sur un raisonnement textuel. `context_window` vaut 3 900 jetons par défaut, bien en dessous des capacités actuelles : indiquez la vraie fenêtre du modèle. LlamaIndex s’en sert pour savoir combien de passages récupérés tiennent dans un prompt.

## Quels modèles choisir

Pour répondre à des questions sur des documents, `gpt-oss-120b` donne des réponses rapides et fondées, avec une faible latence. Pour les longs documents ou les questions qui exigent de synthétiser de nombreux passages, `glm-5.3` et `kimi-k3` gèrent bien les grands contextes et le raisonnement soigné.

Pour `FunctionAgent` et les workflows qui appellent plusieurs outils, choisissez un modèle aux appels d’outils fiables, comme `glm-5.3`, `kimi-k3` ou `qwen3-coder-480b-a35b-instruct`. Vous pouvez aussi combiner plusieurs modèles dans une application, par exemple un modèle rapide pour reformuler les requêtes et un plus puissant pour la réponse finale.

## Dépannage

Une erreur 401 signifie que la clé est absente ou erronée. Une erreur 404 vient le plus souvent d’un chemin en trop dans `api_base`, ou de `is_chat_model` resté à `False`, si bien que LlamaIndex appelle l’ancien point d’accès de complétion. Passez-le à `True`.

Si un agent n’appelle jamais d’outils et répond en texte libre, réglez `is_function_calling_model=True`. Si les réponses ignorent l’essentiel du contexte ou si des erreurs de longueur apparaissent, vérifiez `context_window` : trop bas, LlamaIndex tronque le contexte ; trop haut, les requêtes dépassent la limite du modèle. La classe `OpenAI` simple refuse les identifiants qu’elle ne connaît pas.

## Garder les données dans l’UE

Avec `OpenAILike` pointant vers inference.eu, les questions et passages de documents que LlamaIndex envoie 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 RAG complet comprend aussi des embeddings, une base vectorielle et parfois un analyseur de documents ou un outil d’observabilité. Chacun traite également 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.

## LlamaIndex

Catégorie

Frameworks

Éditeur

LlamaIndex

Format d'API

OpenAI

Traitement

Centres de données dans l'UE

Site web

[www.llamaindex.ai](https://www.llamaindex.ai/)

Documentation

[developers.llamaindex.ai](https://developers.llamaindex.ai/python/framework-api-reference/llms/openai_like/)

## LlamaIndex : 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.

Installez \`llama-index-llms-openai-like\` et créez \`OpenAILike\` avec \`api\_base\`, \`api\_key\` et \`model\`. Réglez \`is\_chat\_model=True\` et un \`context\_window\` réaliste, puis assignez l’objet à \`Settings.llm\` pour que tous les index, moteurs et agents de l’application l’utilisent.

La classe \`OpenAI\` vérifie les noms de modèles par rapport à la liste d’OpenAI et en déduit leurs capacités. \`OpenAILike\` accepte n’importe quel identifiant et vous laisse déclarer les capacités vous-même, ce dont ont besoin les API tierces comme inference.eu.

gpt-oss-120b donne des réponses rapides et fondées pour la plupart des questions sur des documents. GLM-5.3 et Kimi K3 conviennent aux longs documents et à la synthèse de nombreux passages, et fonctionnent aussi très bien pour les agents à appels d’outils en plusieurs étapes.

Indiquez la fenêtre de contexte du modèle utilisé, telle qu’annoncée chez inference.eu. La valeur par défaut de 3 900 jetons est bien trop faible et pousse LlamaIndex à écarter du contexte récupéré. Une valeur supérieure à la limite réelle provoque des erreurs de longueur.

\`OpenAILike\` règle \`is\_function\_calling\_model\` sur \`False\` par défaut, et les agents se rabattent alors sur un raisonnement textuel. Passez-le à \`True\` et choisissez un modèle aux appels d’outils fiables, comme GLM-5.3, Kimi K3 ou Qwen3 Coder 480B.

Le plus souvent, \`is\_chat\_model\` est resté à \`False\` et LlamaIndex appelle l’ancien point d’accès \`/completions\`. Passez-le à \`True\`. Sinon, vérifiez que \`api\_base\` se termine par \`/v1\` et que l’identifiant du modèle existe chez inference.eu.

Oui. Utilisez \`stream\_complete\`, \`stream\_chat\` ou un moteur de requête créé avec \`streaming=True\`. Les jetons arrivent au fil de leur génération, ce qui garde les interfaces de chat réactives pour les longues réponses sur de gros documents.

Cette page porte sur le modèle de langage. Pour les embeddings, choisissez un modèle dont l’hébergement répond à vos exigences, idéalement dans l’UE ou auto-hébergé, et définissez-le dans \`Settings.embed\_model\` pour que documents et requêtes restent en Europe avec vos requêtes de modèle.

LlamaIndex n’envoie de données qu’aux services que vous configurez. Fournisseurs d’embeddings, bases vectorielles hébergées, analyseurs de documents en ligne et outils d’observabilité reçoivent chacun des données selon leurs propres conditions. Vérifiez-les tous pour garder votre pipeline en Europe.

Oui. Les workflows et \`FunctionAgent\` utilisent le même objet LLM : dès que \`Settings.llm\` désigne \`OpenAILike\` avec inference.eu, chaque étape tourne sur le modèle choisi. Vous pouvez toujours passer un autre modèle à certaines étapes si nécessaire.

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

## Pages liées

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

-   [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/)
-   [HaystackPointez 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.Frameworks](https://inference.eu/fr/integrations/haystack/)
-   [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