Semantische operators in de Azure AI-extensie (preview)

De Azure AI-extensie introduceert Semantic Operators, een functie die geavanceerde AI-mogelijkheden (GenAI) rechtstreeks integreert in PostgreSQL SQL. Door deze operators te gebruiken, die modellen zoals chatvoltooiing en andere Azure AI-implementaties gebruiken, kunnen ontwikkelaars genAI-gestuurde toepassingen rechtstreeks in hun databases bouwen. Deze integratie biedt nieuwe mogelijkheden voor het begrijpen van tekst, redenering en het genereren van gestructureerde uitvoer.

Belangrijkste kenmerken

De Semantische operators bieden gebruikers vier kernfuncties voor SQL die gebruikmaken van generatieve AI-mogelijkheden:

• azure_ai.generate(): genereert tekst of gestructureerde uitvoer met behulp van LLM's (Large Language Models).
• azure_ai.is_true(): Evalueert de kans dat een gegeven verklaring waar is.
• azure_ai.extract(): extraheert gestructureerde functies of entiteiten uit tekst.
• azure_ai.rank(): hiermee wordt een lijst met documenten opnieuw geherrankt op basis van relevantie voor een bepaalde query.

Elke functie werkt via Microsoft Foundry-eindpunten die zijn geregistreerd met behulp van de azure_ai.set_setting functie, waardoor naadloze integratie en gebruikersbeheer mogelijk zijn.

Begrijpen van semantische operatoren

Semantische operators in de Azure AI-extensie vereenvoudigen complexe AI-gestuurde taken rechtstreeks in uw PostgreSQL-database. Door deze operators te gebruiken, kunt u naadloos generatieve AI-mogelijkheden integreren in uw SQL-werkstromen. U kunt geavanceerde tekstgeneratie, waarheidsevaluatie, entiteitextractie en documentclassificatie uitvoeren. Elke operator is geoptimaliseerd voor gebruiksgemak en flexibiliteit, zodat u intelligente toepassingen met minimale inspanning kunt bouwen.

azure_ai.generate()

Gebruik deze operator om tekst of gestructureerde uitvoer te genereren met behulp van LLM's.

Het ondersteunt de volgende invoerparameters:

De operator retourneert standaard een text waarde die het gegenereerde antwoord bevat. Als u het json_schema argument opgeeft, retourneert de operator de uitvoer als een gestructureerd JsonB object dat voldoet aan het opgegeven schema.

Voorbeeldgebruik:

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()

Deze operator evalueert de kans dat een bepaalde stelling waar is. Het retourneert een boolean waarde of NULL als het resultaat niet overtuigend is.

Het ondersteunt de volgende invoerparameters:

Voorbeeldgebruik:

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()

Gebruik deze operator om gestructureerde functies of entiteiten uit tekst te extraheren op basis van door de gebruiker gedefinieerde labels.

Het ondersteunt de volgende invoerparameters:

De operator retourneert een JsonB object met de geëxtraheerde entiteiten die zijn toegewezen aan de bijbehorende labels.

Voorbeeldgebruik:

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()

Gebruik deze operator om documenten opnieuw in te stellen op basis van hun relevantie voor een bepaalde query. Het biedt ondersteuning voor cross-encoder- en GPT-modellen.

Het ondersteunt de volgende invoerparameters:

De operator retourneert een table met de document-id, de rang en de bijbehorende relevantiescore.

Voorbeeldgebruik:

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;

Aan de slag

Als u Semantic Operators in uw PostgreSQL-database wilt gebruiken, voert u de volgende stappen uit:

Instellen voor .generate(), .extract(), en .is_true() operators

Deze operators ondersteunen chatvoltooiingsmodellen en staan standaard op gpt-4.1.

1. Schakel de azure_ai extensie in op uw flexibele Azure Database for PostgreSQL-serverinstantie.

2. Maak een Azure OpenAI-serviceresource en implementeer een voltooiingsmodel voor chats (bijvoorbeeld gpt-4.1). U kunt ook modellen implementeren en beheren via de intuïtieve ervaringen van Foundry.

3. Noteer de AZURE OpenAI-eindpunt-URL en API-sleutel.

4. Toegang configureren:

   Voer de volgende SQL-opdrachten uit om de azure_ai extensie in te schakelen om dit model aan te roepen met behulp van verificatie met abonnementssleutels:

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

   Als u in plaats daarvan beheerde identiteiten wilt gebruiken, raadpleegt u dit artikel om de volgende stappen uit te voeren:

   • Schakel door het systeem toegewezen beheerde identiteit in voor uw exemplaar van flexibele Azure Database for PostgreSQL-server en start de server opnieuw op.
   • Wijs de rol Cognitive Services OpenAI-gebruiker toe aan de beheerde identiteit om te communiceren met de Azure OpenAI-resource.
   • Stel de azure_openai.auth_type in op 'managed-identity'.
   • Stel de azure_openai.endpoint in met de eindpunt-URL.

5. U bent nu klaar om de .generate(), .is_true(), en .extract() operatoren aan te roepen.

   Voorbeeldgebruik met gpt-4.1 (standaard):

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

   Voorbeeld van gebruik met andere modellen:

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

Instelling voor .rank() operator

De .rank() operator ondersteunt zowel cross encoders als modellen voor het invullen van chat. Deze wordt standaard ingesteld op de cross-encoder Cohere-rerank-v3.5.

Met behulp van Cohere-rerank-v3.5 cross-encoder:

1. Schakel de azure_ai extensie in op uw Azure Database for PostgreSQL-exemplaar.

2. Ga naar Foundry en implementeer het Cohere-rerank-v3.5 model met behulp van de optie voor het aanschaffen van een serverloze API.

3. Noteer de eindpuntsleutel van het model en de Route van de Reranker-API. Het ziet er ongeveer als volgt uit: https://<deployment name>.<region>.models.ai.azure.com/<v1 or v2>/rerank.

4. Toegang configureren:

   Voer de volgende SQL-opdrachten uit om de azure_ai extensie in te schakelen om dit model aan te roepen met behulp van verificatie met abonnementssleutels:

   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>');
   

   Als u in plaats daarvan beheerde identiteiten wilt gebruiken, raadpleegt u dit artikel om de volgende stappen uit te voeren:

   • Schakel door het systeem toegewezen beheerde identiteit in voor uw exemplaar van flexibele Azure Database for PostgreSQL-server en start de server opnieuw op.
   • Wijs de rol 'Azure Machine Learning Data Scientist' toe aan de beheerde identiteit om te communiceren met het Cohere-model.
   • Stel de azure_ml.auth_type in op 'managed-identity'.
   • Stel de azure_ml.serverless_ranking_endpoint in met de Cohere-reranker-API.

5. U bent nu helemaal klaar om de .rank() operator aan te roepen door het Cohere terugranking-model te gebruiken.

   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;
   

Als u de .rank() operator wilt gebruiken met modellen voor chatvoltooiing, zoals gpt-4.1, implementeert u het gewenste model in Azure OpenAI, configureert u de azure_ai extensie met de eindpuntgegevens van het model en geeft u de modelnaam op bij het aanroepen van de operator.

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;

Verwante inhoud

• Generatieve AI met Azure Database for PostgreSQL
• Azure AI-extensie in Azure Database for PostgreSQL
• Vectoropslag in Azure Database for PostgreSQL
• PostgreSQL-extensie voor Visual Studio Code
• GitHub Copilot-extensie