Semantische operators in de Azure AI-extensie (preview)

De Azure AI-extensie introduceert Semantic Operators, een baanbrekende functie waarmee geavanceerde GenAI-mogelijkheden (Ative AI) rechtstreeks worden geïntegreerd in PostgreSQL SQL. Met deze operators, die worden mogelijk gemaakt door modellen zoals chatten en andere Azure AI-implementaties, kunnen ontwikkelaars genAI-gestuurde toepassingen rechtstreeks in hun databases bouwen. Hiermee ontgrendelt u 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 bepaalde instructie 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 AI 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 zijn ontworpen om complexe AI-gestuurde taken rechtstreeks in uw PostgreSQL-database te vereenvoudigen. Met deze operators kunnen gebruikers generatieve AI-mogelijkheden naadloos integreren in hun SQL-werkstromen, waardoor geavanceerde tekstgeneratie, waarheidsevaluatie, entiteitsextractie en documentclassificatie mogelijk is. Elke operator is geoptimaliseerd voor gebruiksgemak en flexibiliteit, zodat ontwikkelaars intelligente toepassingen met minimale inspanning kunnen bouwen.

azure_ai.generate()

Deze operator maakt gebruik van LLM's om tekst of gestructureerde uitvoer te genereren.

Het ondersteunt de volgende invoerparameters:

De operator retourneert standaard een text waarde die het gegenereerde antwoord bevat. Als het json_schema argument wordt opgegeven, wordt de uitvoer geretourneerd 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 instructie waar is, een boolean waarde retourneert 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()

Deze operator extraheert gestructureerde functies of entiteiten uit tekst 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()

Met deze operator worden documenten opnieuw geherrankt 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 standaard .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 Azure AI 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 in op azure_openai.auth_type 'beheerde identiteit'.
   • Stel de azure_openai.endpoint url in met de eindpunt-URL.

5. U bent nu klaar om de .generate()operatoren en .is_true().extract() operators 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;
   

Installatie voor .rank() operator

De .rank() operator ondersteunt zowel cross encoder- als chatvoltooiingsmodellen en standaardwaarden voor de kruiscoderingsprogramma Cohere-rerank-v3.5.

Met behulp van kruiscoderingsprogramma's Cohere-rerank-v3.5 :

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

2. Navigeer naar Azure AI Foundry en implementeer het Cohere-rerank-v3.5 model met behulp van de optie voor het aanschaffen van serverloze API's.

3. Noteer de eindpuntsleutel van het model en de Route van de Reranker-API die er ongeveer als volgt uit moet zien: 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 in op azure_ml.auth_type 'beheerde identiteit'.
   • Stel de azure_ml.serverless_ranking_endpoint api in met de Cohere-reranker-API.

5. U bent nu klaar om de operator aan te roepen met behulp van het .rank() cohere-herrankermodel.

   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
• Vectorarchieven in Azure Database for PostgreSQL
• PostgreSQL-extensie voor Visual Studio Code
• GitHub Copilot-extensie