Opérateurs sémantiques dans l’extension Azure AI (préversion)

L’extension Azure AI introduit des opérateurs sémantiques, une fonctionnalité qui intègre des fonctionnalités avancées d’INTELLIGENCE artificielle (GenAI) directement dans PostgreSQL SQL. En utilisant ces opérateurs, qui sont des modèles tels que la saisie semi-automatique des conversations et d’autres déploiements Azure AI, les développeurs peuvent créer des applications basées sur GenAI directement dans leurs bases de données. Cette intégration déverrouille de nouvelles fonctionnalités pour comprendre le texte, le raisonnement et générer des sorties structurées.

Fonctionnalités clés

Les opérateurs sémantiques fournissent aux utilisateurs quatre fonctions SQL principales qui utilisent des fonctionnalités d’IA génératives :

• azure_ai.generate() : génère du texte ou une sortie structurée à l’aide de modèles de langage volumineux (LLMs).
• azure_ai.is_true() : évalue la probabilité qu’une instruction donnée soit vraie.
• azure_ai.extract() : extrait des caractéristiques structurées ou des entités à partir du texte.
• azure_ai.rank() : reclasse une liste de documents en fonction de la pertinence d’une requête donnée.

Chaque fonction fonctionne via les points de terminaison Microsoft Foundry inscrits à l’aide de la fonction azure_ai.set_setting, garantissant ainsi une intégration transparente et un contrôle utilisateur.

Présentation des opérateurs sémantiques

Les opérateurs sémantiques dans l’extension Azure AI simplifient les tâches complexes basées sur l’IA directement dans votre base de données PostgreSQL. À l’aide de ces opérateurs, vous pouvez intégrer en toute transparence des fonctionnalités d’IA générative dans vos flux de travail SQL. Vous pouvez effectuer une génération de texte avancée, l’évaluation de la vérité, l’extraction d’entités et le classement des documents. Chaque opérateur est optimisé pour faciliter l’utilisation et la flexibilité, ce qui vous permet de créer des applications intelligentes avec un effort minimal.

azure_ai.generate()

Utilisez cet opérateur pour générer du texte ou une sortie structurée à l’aide de LLMs.

Il prend en charge les paramètres d’entrée suivants :

Par défaut, l’opérateur retourne une valeur text contenant la réponse générée. Si vous fournissez l’argument json_schema , l’opérateur retourne la sortie en tant qu’objet structuré JsonB conforme au schéma spécifié.

Exemple d'utilisation :

SELECT azure_ai.generate(
  'Rewrite the following comment to be more polite: ' comment_text
) AS polite_comment
FROM user_comments;

SELECT review, azure_ai.generate(
    prompt        => 'Rewrite the following comment to be more polite and return the number of products mentioned:' || review,
    json_schema   => '{
                        "name": "generate_response",
                        "description": "Generate a response to the user",
                        "strict": true,
                        "schema": {
                          "type": "object",
                          "properties": {
                            "comment": { "type": "string" },
                            "num_products": { "type": "integer" }
                          },
                          "required": ["comment", "num_products"],
                          "additionalProperties": false
                          }
                        }',
     model  => 'gpt-4.1-mini'
) as polite_comment_with_count
FROM
    Reviews;

azure_ai.is_true()

Cet opérateur évalue la probabilité qu’une instruction donnée soit vraie. Elle retourne une boolean valeur ou NULL si le résultat est inconclusif.

Il prend en charge les paramètres d’entrée suivants :

Exemple d'utilisation :

SELECT azure_ai.is_true(
  'The review talks about the product: '
  product_name
  ' Review: '
  review_text
) AS is_relevant_review
FROM product_reviews;

azure_ai.extract()

Utilisez cet opérateur pour extraire des fonctionnalités structurées ou des entités à partir de texte en fonction des étiquettes définies par l’utilisateur.

Il prend en charge les paramètres d’entrée suivants :

L’opérateur retourne un objet JsonB contenant les entités extraites mappées à leurs étiquettes correspondantes.

Exemple d’utilisation :

SELECT azure_ai.extract(
   'The headphones are not great. They have a good design, but the sound quality is poor and the battery life is short.',
   ARRAY[ 'product', 'sentiment']
);

-- Output: {"product": "headphones", "sentiment": "negative"}

SELECT azure_ai.extract(
    'The music quality is good, though the call quality could have been better. The design is sleek, but still slightly heavy for convenient travel.',
    ARRAY[
        'design: string - comma separated list of design features of the product',
        'sound: string - sound quality (e.g., music, call, noise cancellation) of the product',
        'sentiment: number - sentiment score of the review; 1 (lowest) to 5 (highest)'
    ]
);

-- Output: {"sound": "music quality is good, call quality could have been better", "design": "sleek, slightly heavy", "sentiment": 3}

azure_ai.rank()

Utilisez cet opérateur pour reclasser des documents en fonction de leur pertinence pour une requête donnée. Il prend en charge les modèles d’encodeur croisé et GPT.

Il prend en charge les paramètres d’entrée suivants :

L’opérateur retourne un table contenant l’ID de document, son classement et le score de pertinence associé.

Exemple d'utilisation :

SELECT azure_ai.rank(
    'Best headphones for travel',
    ARRAY[
        'The headphones are lightweight and foldable, making them easy to carry.',
        'Bad battery life, not so great for long trips.',
        'The sound quality is excellent, with good noise isolation.'
    ]
)

SELECT azure_ai.rank(
  query => 'Clear calling capability that blocks out background noise',
  document_contents => ARRAY[
                        'The product has a great battery life, good design, and decent sound quality.',
                        'These headphones are perfect for long calls and music.',
                        'Best headphones for music lovers. Call quality could have been better.',
                        'The product has a good design, but it is a bit heavy. Not recommended for travel.'
                      ],
  document_ids => ARRAY['Review1', 'Review2', 'Review3', 'Review4'],
  model => 'gpt-4.1'
) AS ranked_reviews;

Comment commencer

Pour utiliser des opérateurs sémantiques dans votre base de données PostgreSQL, procédez comme suit :

Configuration pour des opérateurs .generate(), .extract() et .is_true()

Ces opérateurs prennent en charge les modèles d’achèvement de conversation et la valeur par défaut est gpt-4.1.

1. Activez l’extension azure_ai sur votre instance de serveur flexible Azure Database pour PostgreSQL.

2. Créez une ressource de service Azure OpenAI et déployez un modèle d’achèvement de conversation (par exemple, gpt-4.1). Vous pouvez également déployer et gérer des modèles via les expériences intuitives fournies par Foundry.

3. Notez l’URL du point de terminaison Azure OpenAI et la clé API.

4. Configurer l’accès :

   Pour activer l’extension pour appeler ce modèle à l’aide de l’authentification azure_ai par clé d’abonnement, exécutez les commandes SQL suivantes :

   SELECT azure_ai.set_setting('azure_openai.endpoint', 'https://<endpoint>.openai.azure.com/');
   SELECT azure_ai.set_setting('azure_openai.subscription_key', '<API Key>');
   

   Si vous souhaitez utiliser des identités managées à la place, reportez-vous à cet article pour effectuer les étapes suivantes :

   • Activez l’identité managée affectée par le système pour votre instance de serveur flexible Azure Database pour PostgreSQL et redémarrez le serveur.
   • Attribuez le rôle « Utilisateur OpenAI Cognitive Services » à l’identité managée pour interagir avec la ressource Azure OpenAI.
   • Définissez la valeur azure_openai.auth_type pour « managed-identity ».
   • Définissez azure_openai.endpoint avec l’URL du point de terminaison.

5. Vous êtes maintenant tous définis pour appeler les opérateurs .generate(),.is_true() et .extract().

   Exemple d’utilisation avec gpt-4.1 (par défaut) :

   SELECT name, azure_ai.generate(
     'Generate a description for the product: ' || name
   ) AS description
   FROM products;
   

   Exemple d’utilisation avec d’autres modèles :

   SELECT name, azure_ai.generate(
     'Generate a description for the product: ' || name , 'gpt-4.1-mini'
   ) AS description
   FROM products;
   

Configuration de l’opérateur .rank()

L’opérateur .rank() prend en charge à la fois les modèles d’encodeur croisé et les modèles de complétion de chat. Par défaut, il utilise l’encodeur croisé Cohere-rerank-v3.5.

Utilisation de l’encodeur croisé Cohere-rerank-v3.5 :

1. Activez l’extension azure_ai sur votre instance Azure Database pour PostgreSQL.

2. Accédez à Foundry et déployez le Cohere-rerank-v3.5 modèle à l’aide de l’option d’achat de l’API serverless.

3. Notez la clé de point de terminaison du modèle et l’itinéraire de l’API Reranker. Il doit ressembler à ceci : https://<deployment name>.<region>.models.ai.azure.com/<v1 or v2>/rerank.

4. Configurer l’accès :

   Pour activer l’extension pour appeler ce modèle à l’aide de l’authentification azure_ai par clé d’abonnement, exécutez les commandes SQL suivantes :

   SELECT azure_ai.set_setting('azure_ml.serverless_ranking_endpoint', '<Cohere reranker API>');
   SELECT azure_ai.set_setting('azure_ml.serverless_ranking_endpoint_key', '<API Key>');
   

   Si vous souhaitez utiliser des identités managées à la place, reportez-vous à cet article pour effectuer les étapes suivantes :

   • Activez l’identité managée affectée par le système pour votre instance de serveur flexible Azure Database pour PostgreSQL et redémarrez le serveur.
   • Attribuez le rôle « Scientifique des données Azure Machine Learning » à l’identité managée pour interagir avec le modèle Cohere.
   • Définissez la valeur azure_ml.auth_type pour « managed-identity ».
   • Définissez azure_ml.serverless_ranking_endpoint avec l’API de reranker Cohere.

5. Vous êtes désormais prêt à invoquer l’opérateur .rank() à l’aide du modèle de reclassement Cohere.

   SELECT azure_ai.rank(
     'Best headphones for travel',
     ARRAY[
         'The headphones are lightweight and foldable, making them easy to carry.',
         'Bad battery life, not so great for long trips.',
         'The sound quality is excellent, with good noise isolation.'
     ]
   ) AS ranked_reviews;
   

Pour utiliser l’opérateur .rank() avec des modèles de complétion de chat comme gpt-4.1, déployez le modèle souhaité sur Azure OpenAI, configurez l’extension azure_ai avec les détails du point de terminaison du modèle et spécifiez le nom du modèle lors de l’appel de l’opérateur.

SELECT azure_ai.set_setting('azure_openai.endpoint', 'https://<endpoint>.openai.azure.com/');
SELECT azure_ai.set_setting('azure_openai.subscription_key', '<API Key>');

SELECT azure_ai.rank(
 'Best headphones for travel',
  ARRAY[
      'The headphones are lightweight and foldable, making them easy to carry.',
      'Bad battery life, not so great for long trips.',
      'The sound quality is excellent, with good noise isolation.'
  ],
  'gpt-4.1'
) AS ranked_reviews;

Contenu connexe

• IA générative avec Azure Database pour PostgreSQL
• Extension Azure AI dans Azure Database pour PostgreSQL
• Magasins vectoriels dans Azure Database pour PostgreSQL
• Extension PostgreSQL pour Visual Studio Code
• Extension GitHub Copilot