Cette page a été traduite par l'API Cloud Translation.

Exécuter des requêtes SQL intelligentes à l'aide du moteur de requêtes AlloyDB AI

Cette page explique comment effectuer des requêtes à l'aide des opérateurs SQL optimisés par l'IA fournis par le moteur de requête AlloyDB/AI. Vous pouvez utiliser les opérateurs ai.if, ai.rank et ai.generate pour combiner le langage naturel avec les requêtes SQL.

Pour suivre les instructions de cette page, vous devez comprendre AlloyDB et connaître les concepts de l'IA générative.

AlloyDB/AI réserve et crée le schéma ai.

Avant de commencer

Avant d'utiliser le langage naturel dans les opérateurs SQL, procédez comme suit :

Intégrer Vertex AI et installer l'extension

Intégration à Vertex AI
Assurez-vous que la dernière version de google_ml_integration est installée.
1. Pour vérifier la version installée, exécutez la commande suivante :
```
        SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.3
        (1 row)
      
```
2. Si l'extension n'est pas installée ou si la version installée est antérieure à la version 1.4.3, mettez-la à jour en exécutant les commandes suivantes :
```
        CREATE EXTENSION IF NOT EXISTS google_ml_integration;
        ALTER EXTENSION google_ml_integration UPDATE;
      
```
  Si vous rencontrez des problèmes lors de l'exécution des commandes précédentes ou si l'extension n'est pas mise à jour vers la version 1.4.3 après l'exécution des commandes précédentes, contactez l'assistance AlloyDB.
3. Une fois que vous avez vérifié que la version est à jour, installez la fonctionnalité d'aperçu en exécutant la procédure upgrade_to_preview_version :
```
        CALL google_ml.upgrade_to_preview_version();
        SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.4
        (1 row)
      
```
  Remarque : La version attendue est la version 1.4.4 ou ultérieure.

Utiliser un modèle Gemini compatible dans votre région

Si votre cluster AlloyDB pour PostgreSQL se trouve dans une région où gemini-2.0-flash n'est pas disponible, vous pouvez utiliser l'un des autres modèles Gemini disponibles dans votre région à l'aide de model_id parameter.

Vous pouvez également enregistrer un point de terminaison de modèle Gemini et fournir cet ID de modèle aux opérateurs d'IA. Pour en savoir plus, consultez Enregistrer et appeler des modèles d'IA à distance à l'aide de la gestion des points de terminaison de modèle.

L'exemple suivant montre comment enregistrer un autre point de terminaison Gemini. Dans cet exemple, ce deuxième point de terminaison Gemini est le point de terminaison global pour gemini-2.0-flash. Vous pouvez utiliser ce modèle enregistré avec des opérateurs d'IA en transmettant model_id =>gemini-2.0-flash-global` comme argument supplémentaire.

CALL
  google_ml.create_model(
    model_id => 'gemini-2.0-flash-global',
    model_type => 'llm',
    model_provider => 'google',
    model_qualified_name => 'gemini-2.0-flash',
    model_request_url =>  'https://aiplatform.googleapis.com/v1/projects/<project_id>/locations/global/publishers/google/models/gemini-2.0-flash:generateContent',
    model_auth_type => 'alloydb_service_agent_iam'
);

Utiliser des filtres dans vos requêtes

AlloyDB AI propose plusieurs fonctions SQL optimisées par l'IA qui vous permettent d'utiliser le traitement du langage naturel et les LLM directement dans vos requêtes de base de données, y compris les opérateurs ai.if et ai.rank.

Filtres

Pour évaluer si une condition exprimée en langage naturel est remplie, utilisez l'opérateur ai.if/google_ml.if. La fonction renvoie une valeur booléenne "true" ou "false", et renvoie false si le résultat n'est pas clairement détecté.

- Function signature
FUNCTION ai.if(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS bool

L'exemple suivant montre comment utiliser l'opérateur ai.if comme filtre pour trouver les restaurants ayant reçu plus de 500 avis positifs et situés dans des villes de plus de 100 000 habitants. Cet exemple utilise restaurant_reviews et contient des données telles que les avis et la ville. L'opérateur ai.if vous aide à comprendre le sentiment des avis et à combiner les lieux de la base de données avec les connaissances générales de Gemini sur la population de ces lieux.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population OF more than 100,000 AND the following is a positive review; Review: ' || r.review)
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

L'exemple suivant montre la même chose en utilisant le modèle que vous avez enregistré dans Utiliser un modèle Gemini compatible dans votre région.

SELECT r.name, r.location_city
FROM restaurant_reviews r
WHERE
  AI.IF(r.location_city || ' has a population of more than 100,000 AND the following is a positive review; Review: ' || r.review, model_id => 'gemini-2.0-flash-global')
GROUP BY r.name, r.location_city
HAVING COUNT(*) > 500;

Effectuer une jointure sur une requête qui utilise l'opérateur "if"

Pour effectuer une opération de jointure, utilisez l'opérateur ai.if/google_ml.if avec la jointure. L'exemple de requête suivant permet de trouver le nombre d'avis mentionnant chaque plat du menu du restaurant.

    SELECT item_name, COUNT(*)
    FROM menu_items JOIN user_reviews
      ON ai.if(
        prompt => 'Does the following user review talk about the menu item mentioned ? review: ' || user_reviews.review_text || ' menu item: ' || item_name)
    GROUP BY item_name;

Génération et synthèse de texte

La fonction ai.generate génère du texte en combinant les données fournies avec la requête de l'utilisateur.

-- Function Signature
FUNCTION ai.generate(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS TEXT

Par exemple, vous pouvez utiliser la requête suivante pour générer un résumé concis de chaque avis d'utilisateur.

SELECT
  ai.generate(
    prompt => 'Summarize the review in 20 words or less. Review: ' || review) AS review_summary
FROM user_reviews

Évaluer les résultats de vos requêtes

Si vous devez trier les résultats d'une requête à l'aide d'instructions personnalisées en langage naturel, utilisez l'opérateur ai.rank. Cette fonction vous permet de fournir une requête décrivant les critères de classement et renvoie un score pour chaque élément.

-- Function signature
FUNCTION ai.rank(prompt TEXT, model_id VARCHAR(100) DEFAULT NULL) RETURNS real

Par exemple, la requête suivante récupère les 20 avis les plus positifs sur les restaurants, en utilisant les scores d'un LLM.

SELECT review AS top20
FROM user_reviews
ORDER BY ai.rank(
  'Score the following review according to these rules:
  (1) Score OF 8 to 10 IF the review says the food IS excellent.
  (2) 4 to 7 IF the review says the food is ok.
  (3) 1 to 3 IF the review says the food is not good. Here is the review:' || review) DESC
LIMIT 20;