---
title: "Appeler des modèles d'IA en SQL avec les fonctions IA de Trino"
description: "Le consommateur Trino AI functions connecte votre projet à un grand modèle de langage pour que vous puissiez appeler des fonctions d'IA directement en SQL"
url: https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/connectors-consumers-trino-ai-functions
lang: fr
lastUpdated: 2026-11-05
---
> For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt.

# Appeler des modèles d'IA en SQL avec les fonctions IA de Trino

## Objectif

Le consommateur **Trino AI functions** connecte votre projet à un grand modèle de langage pour que vous puissiez appeler des fonctions IA directement en SQL. Vous lui indiquez un fournisseur, une clé d'API et un modèle, et Data Platform crée un **catalogue Trino** dédié qui expose les [fonctions IA de Trino](https://trino.io/docs/current/functions/ai.html) : classer des tickets de support, traduire des descriptions de produits, extraire des champs d'avis clients rédigés librement ou masquer des données personnelles, le tout dans une requête.

Une fois le consommateur créé, les fonctions sont disponibles partout où une requête passe par Trino : l'[Explorer du Lakehouse Manager](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/lakehouse-manager-explorer.md), l'[éditeur SQL de l'Analytics Manager](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/analytics-manager-queries-sql-editor.md), l'[action SQL](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/dpe-actions-sql.md) et les outils externes connectés avec un [consommateur Trino](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/connectors-consumers-trino.md).

[OVHcloud AI Endpoints](https://www.ovhcloud.com/fr/public-cloud/ai-endpoints/) est le fournisseur par défaut. Tout fournisseur qui expose une API compatible OpenAI sur une adresse HTTPS publique convient également.

**Attention :** **Toute personne qui peut interroger le projet peut appeler les fonctions IA, avec votre clé.** Les appeler ne demande aucune permission au-delà du droit d'exécuter des requêtes : chaque utilisateur de l'Explorer, de l'Analytics Manager, des actions SQL ou d'un consommateur Trino peut envoyer des données au fournisseur et consommer des tokens facturés sur la clé d'API que vous avez configurée. Il vous revient de maîtriser cette dépense et les données envoyées.

**Les données que vous passez à une fonction quittent Data Platform.** Chaque appel envoie les valeurs qu'il reçoit, par exemple le contenu d'une colonne, à l'endpoint du fournisseur. Vérifiez que c'est autorisé pour les données que vous traitez.

## Prérequis

- Une clé d'API pour votre fournisseur. Pour OVHcloud AI Endpoints, suivez [Générer votre première clé d'accès API](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-getting-started.md#g%C3%A9n%C3%A9rer-votre-premi%C3%A8re-cl%C3%A9-dacc%C3%A8s-api).
- La permission d'écrire des consommateurs dans le projet (voir [Permissions](#permissions)).

## Instructions

### Créer le consommateur Trino AI functions

Dans le service Connectors, ouvrez l'onglet **Consumers**, cliquez sur **New consumer**, sélectionnez **Trino AI Functions** et cliquez sur **Select**.

Renseignez le champ **Name** du consommateur et, si besoin, les champs **Description** et **Tags**, puis remplissez la section _Trino AI functions configuration_.

1. Choisissez le **Provider** :

   | Fournisseur                            | Endpoint                                                                                                                                                                                                                                                                                  |
   | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
   | **OVHcloud AI Endpoints** (par défaut) | Renseigné pour vous et en lecture seule : `https://oai.endpoints.kepler.ai.cloud.ovh.net`                                                                                                                                                                                                 |
   | **OpenAI-compatible endpoint**         | Saisissez l'adresse de base de l'API du fournisseur, sans `/v1`, par exemple `https://api.openai.com`. Elle doit utiliser `https://` et pointer vers une adresse publique : les adresses privées, locales et en `http://` sont refusées. Le fournisseur doit répondre à `GET /v1/models`. |

2. Saisissez votre **API key**.

3. Cliquez sur **Test connection**. Data Platform appelle le fournisseur avec votre clé. Si le test réussit, un sélecteur **Model** apparaît, avec tous les modèles que le fournisseur propose pour cette clé.

4. Choisissez le modèle (**Model**) qu'utiliseront les fonctions IA.

5. Cliquez sur **Create**.

Data Platform crée le catalogue `db_<project_id>_ai`.

Un projet ne peut contenir qu'**un seul consommateur Trino AI functions**.

### Appeler les fonctions IA en SQL

Ouvrez le consommateur et allez dans son onglet **Usage** : il présente un exemple de requête pour chaque fonction IA, avec le nom du catalogue de votre projet déjà renseigné, prêt à copier.

Les fonctions se trouvent dans le schéma `ai` du catalogue : vous les appelez donc par leur nom complet, `db_<project_id>_ai.ai.<function>`. Sept fonctions sont disponibles :

| Fonction                       | Ce qu'elle renvoie                                                         |
| ------------------------------ | -------------------------------------------------------------------------- |
| `ai_analyze_sentiment(text)`   | Le sentiment du texte : positif, négatif, neutre ou mitigé                 |
| `ai_classify(text, labels)`    | Le libellé du tableau qui correspond le mieux au texte                     |
| `ai_extract(text, labels)`     | Les valeurs trouvées dans le texte pour chaque libellé                     |
| `ai_fix_grammar(text)`         | Le texte avec sa grammaire corrigée                                        |
| `ai_gen(prompt)`               | Un texte généré à partir du prompt                                         |
| `ai_mask(text, labels)`        | Le texte dont les valeurs de chaque libellé sont remplacées par `[MASKED]` |
| `ai_translate(text, language)` | Le texte traduit dans la langue indiquée                                   |

Classer des tickets de support par catégorie :

```sql
SELECT
  ticket_id,
  db_<project_id>_ai.ai.ai_classify(
    description,
    ARRAY['billing', 'technical', 'refund', 'sales']
  ) AS category
FROM db_<project_id>_<dataset>.<schema>.support_tickets
LIMIT 20
```

Traduire des descriptions de produits en anglais :

```sql
SELECT
  product_id,
  db_<project_id>_ai.ai.ai_translate(description, 'en') AS description_en
FROM db_<project_id>_<dataset>.<schema>.products
LIMIT 20
```

Extraire des champs structurés d'avis clients :

```sql
SELECT
  review_id,
  db_<project_id>_ai.ai.ai_extract(review, ARRAY['product', 'sentiment', 'issue']) AS fields
FROM db_<project_id>_<dataset>.<schema>.reviews
LIMIT 20
```

### Tester sur quelques lignes, puis enrichir la table avec une action

Une fonction IA envoie **une requête au fournisseur pour chaque ligne** qu'elle traite, et chaque requête attend la réponse du modèle. Une requête simple traite les lignes l'une après l'autre : sur une table entière, elle est lente. Lors de nos tests, `ai_analyze_sentiment` sur une table de 500 lignes a pris 5 à 6 minutes en requête.

Procédez en 2 temps :

1. **Testez avec `LIMIT`.** Exécutez la requête sur quelques lignes, comme dans les exemples ci-dessus, et vérifiez le résultat avant d'aller plus loin.
2. **Enrichissez la table avec l'action d'enrichissement IA.** Pour traiter une table entière, exécutez la fonction depuis une [action Custom](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/dpe-actions-custom.md) avec le script décrit dans [Enrichir une table entière avec l'action d'enrichissement IA](#enrichir-une-table-entière-avec-laction-denrichissement-ia). Il répartit les lignes en lots traités en parallèle, jusqu'à 16 à la fois, écrit les résultats dans une table et reprend là où il s'était arrêté lorsque vous le relancez. Les lots étant traités en parallèle, une table entière est traitée bien plus vite qu'avec une requête.

Les durées dépendent du modèle, de l'heure et de l'état de l'endpoint du fournisseur.

### Enrichir une table entière avec l'action d'enrichissement IA

L'_action d'enrichissement IA_ est un script d'action Custom qui applique une fonction IA aux lignes d'une table et écrit les résultats dans une table cible. À chaque exécution, il :

- sélectionne jusqu'à `ROW_LIMIT` lignes dont la colonne de texte n'est pas nulle et qui ne figurent pas encore dans la table cible : relancer l'action reprend donc là où la dernière exécution s'est arrêtée ;
- les répartit en `CHUNKS` lots selon un hachage de leur identifiant, et exécute un `INSERT ... SELECT` par lot, tous les lots en parallèle ;
- écrit l'identifiant, le texte source, le nom de la fonction et son résultat dans la table cible, créée dans le dataset source à la première exécution avec les colonnes `<id>`, `source_text`, `ai_operation` et `ai_output`.

Pour la mettre en place :

1. Téléchargez le script : <a className="rp-link" href="/images/public-cloud/data-platform/product/connectors/consumers/trino-ai-functions/resources/ai-enrichment-action.py" download>ai-enrichment-action.py</a>.

2. Dans le Data Processing Engine, ouvrez l'onglet _Actions_, cliquez sur **New Action** et choisissez le type _Custom_. Glissez-déposez le script dans la zone _Drag and drop_ et conservez `customfunc` comme nom de fonction.

3. Remplissez le bloc de configuration en haut du script :

   | Paramètre      | Valeur                                                                                                                                                                                                                          |
   | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
   | `SOURCE`       | Le dataset qui contient la table, sous forme de [chaîne de connexion](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/developers-python-sdk-connect-dataset.md) avec une barre oblique finale : `dwh/<dataset>/` |
   | `SOURCE_TABLE` | La table à enrichir                                                                                                                                                                                                             |
   | `ID_COLUMN`    | Une colonne unique et non nulle. Elle distingue les lignes déjà enrichies de celles qui restent à traiter                                                                                                                       |
   | `TEXT_COLUMN`  | La colonne de texte passée à la fonction                                                                                                                                                                                        |
   | `AI_EXPR`      | L'appel à appliquer, copié depuis l'onglet **Usage**, avec `{c}` à la place de la colonne de texte et sans le préfixe du catalogue, par exemple `ai_translate({c}, 'en')`. Le script ajoute le catalogue pour vous              |
   | `TARGET_TABLE` | La table qui reçoit les résultats. Si vide : `<table>_ai_<function>`                                                                                                                                                            |
   | `CHUNKS`       | Le nombre de lots traités en parallèle, de 1 à 16. 4 par défaut                                                                                                                                                                 |
   | `ROW_LIMIT`    | Le nombre de nouvelles lignes enrichies par exécution. 100 par défaut. C'est votre plafond de dépense : augmentez-le une fois le résultat validé                                                                                |
   | `AI_CATALOG`   | Le catalogue IA. Si vide : le catalogue `db_<project_id>_ai` de ce projet                                                                                                                                                       |

4. Exécutez l'action. La première exécution crée la table cible et enrichit les `ROW_LIMIT` premières lignes.

5. Vérifiez le résultat dans l'Explorer, puis augmentez `ROW_LIMIT` et relancez l'action. Les lignes déjà présentes dans la table cible sont ignorées.

Pour modifier un paramètre le temps d'une exécution sans toucher au script, déclenchez l'action avec un corps qui surcharge les clés en minuscules, par exemple `{"row_limit": 500, "chunks": 8}`. Consultez [Créer des actions de gestion d'événements](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/tutorials-custom-event-handling.md) pour savoir comment une action reçoit un corps.

Bon à savoir sur l'action :

- **Chaque ligne est un appel facturé**, comme dans une requête. Un lot en échec est relancé une fois, et ses lignes sont facturées à nouveau. Si la relance échoue aussi, l'exécution est marquée en échec, les lignes enrichies par les autres lots sont conservées, et relancer l'action traite le reste.
- **Plus il y a de lots, plus l'exécution est rapide, dans la limite du débit de votre fournisseur.** Chaque lot occupe un emplacement de requête Trino. Avec OVHcloud AI Endpoints, le plafond est de 400 requêtes par minute et par modèle, quel que soit le nombre de lots : si une exécution échoue avec des erreurs `429`, réduisez `CHUNKS`.
- **N'exécutez pas deux instances à la fois.** Elles sélectionneraient les mêmes lignes et les factureraient deux fois.
- **Une table cible contient les résultats d'une seule fonction.** Une exécution avec une autre fonction sur la même `TARGET_TABLE` est refusée : indiquez-en une autre, ou laissez-la vide.
- **`ai_extract` renvoie une map.** Stockez-la sous forme de texte JSON avec `json_format(cast(ai_extract({c}, ARRAY['price']) AS json))`.
- **Gardez le script sous 10 Ko** si vous l'adaptez : la plateforme refuse les fichiers plus lourds.

### Changer de modèle

Ouvrez le consommateur, choisissez un autre modèle dans le sélecteur **Model** et enregistrez avec le bouton situé en dessous. Data Platform recrée le catalogue avec le nouveau modèle, sous le même nom.

Le modèle est le seul paramètre modifiable. Le fournisseur, l'endpoint et la clé d'API sont figés une fois le consommateur créé : pour changer l'un d'eux, supprimez le consommateur et créez-en un nouveau.

### Supprimer le consommateur

**Attention :** Supprimer le consommateur supprime le catalogue `db_<project_id>_ai`. Toute requête, action SQL ou tableau de bord qui appelle une fonction IA échoue jusqu'à ce que vous créiez un nouveau consommateur Trino AI functions. La clé d'API enregistrée est supprimée avec lui.

Dans le service Connectors, ouvrez l'onglet _Consumers_ et supprimez le consommateur de la liste.

### Permissions

La gestion du consommateur relève des permissions _Consumer_ de l'[Identity Access Manager](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/iam-roles-conditions.md). L'appel des fonctions, non : toute personne qui peut exécuter des requêtes dans le projet peut les appeler.

| Pour                                        | Il vous faut                                    |
| ------------------------------------------- | ----------------------------------------------- |
| Voir le consommateur et ses modèles         | _Consumer_ en lecture                           |
| Créer le consommateur ou changer son modèle | _Consumer_ en écriture                          |
| Supprimer le consommateur                   | _Consumer_ en suppression                       |
| Appeler les fonctions IA                    | Le droit d'exécuter des requêtes dans le projet |

### Bon à savoir

- **Votre fournisseur facture les appels.** Les fonctions IA utilisent votre clé d'API : les tokens qu'elles consomment sont facturés sur votre compte chez le fournisseur, par exemple votre projet OVHcloud AI Endpoints (voir [la facturation d'AI Endpoints](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-billing.md)). Comme l'indique la documentation de Trino, le coût dépend de la fonction, de la longueur de l'entrée et de celle de la sortie.
- **Votre fournisseur limite le débit des requêtes.** Avec OVHcloud AI Endpoints, une clé d'API autorise 400 requêtes par minute par projet Public Cloud et par modèle, et les appels au-delà échouent avec une erreur `429`. Voir [Limite de débit des modèles](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-getting-started.md#limite-de-d%C3%A9bit-des-mod%C3%A8les).
- **Les arguments doivent être du texte.** Les fonctions prennent des arguments `varchar`. Convertissez les autres types au préalable, par exemple `CAST(order_total AS varchar)`. Voir [Types de données et casts Trino](https://docs.ovhcloud.com/fr/guides/public-cloud/data-platform/tutorials-trino-types-and-casts.md).
- **Les résultats dépendent du modèle.** La qualité, la vitesse et le coût varient selon le fournisseur et le modèle choisis. Vérifiez un échantillon du résultat avant de vous y fier.
- **La clé d'API est en écriture seule.** Data Platform la stocke chiffrée et ne la renvoie jamais, ni dans l'interface ni dans l'API.

### Dépannage

| Symptôme                                                             | Cause et solution                                                                                                                                                                                          |
| -------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| « Test connection échoue avec une erreur de clé »                    | Le fournisseur a refusé la clé d'API. Vérifiez qu'elle est valide et qu'elle correspond à l'endpoint saisi.                                                                                                |
| « L'endpoint est refusé »                                            | L'endpoint doit utiliser `https://` et pointer vers une adresse publique. Les adresses locales, privées et en `http://` sont refusées à dessein.                                                           |
| « Aucun modèle n'apparaît après le test »                            | Le fournisseur doit répondre à `GET /v1/models`. Les fournisseurs sans cette route ne peuvent pas être utilisés.                                                                                           |
| « Impossible de créer un second consommateur »                       | Un projet ne peut contenir qu'un seul consommateur Trino AI functions. Changez le modèle du consommateur existant, ou supprimez-le d'abord.                                                                |
| « Impossible de changer la clé d'API, le fournisseur ou l'endpoint » | Seul le modèle peut changer. Supprimez le consommateur et créez-en un nouveau.                                                                                                                             |
| « La requête dure plusieurs minutes »                                | La fonction envoie une requête par ligne. Ajoutez un `LIMIT` pour tester, et traitez les tables entières avec l'[action d'enrichissement IA](#enrichir-une-table-entière-avec-laction-denrichissement-ia). |
| « Une requête échoue avec une erreur 429 »                           | La limite de débit du fournisseur est atteinte. Traitez moins de lignes à la fois, réduisez `CHUNKS` dans l'action d'enrichissement IA, ou demandez une limite plus élevée à votre fournisseur.            |
| « Une requête échoue avec une erreur de type »                       | Un argument n'est pas un `varchar`. Convertissez-le en `varchar`.                                                                                                                                          |
| « Le catalogue est introuvable »                                     | Vérifiez son nom avec `SHOW CATALOGS` dans l'Explorer. S'il n'apparaît pas, le consommateur a été supprimé.                                                                                                |

## Aller plus loin

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page [Professional Services](https://www.ovhcloud.com/fr/professional-services/) pour obtenir un devis et faire analyser votre projet par nos experts.

Posez vos questions, faites-nous part de vos commentaires et interagissez directement avec l’équipe qui développe la Data Platform sur le [canal Discord](https://discord.gg/ovhcloud) dédié.

Si vous avez besoin d'une assistance concernant vos services OVHcloud, créez une demande depuis notre [centre d'aide](https://help.ovhcloud.com/csm?id=csm_get_help).

Rejoignez notre [communauté d'utilisateurs](https://community.ovhcloud.com/).
