Semantiska operatorer i Azure AI-tillägget (förhandsversion)

Azure AI-tillägget introducerar semantiska operatörer, en banbrytande funktion som integrerar avancerade Generative AI-funktioner (GenAI) direkt i PostgreSQL SQL. Dessa operatorer, som drivs av modeller som chattavslut och andra Azure AI-distributioner, gör det möjligt för utvecklare att skapa GenAI-drivna program direkt i sina databaser. Detta låser upp nya funktioner för att förstå text, resonemang och generera strukturerade utdata.

Viktiga funktioner

Semantiska operatorer ger användarna fyra grundläggande SQL-funktioner som använder generativa AI-funktioner:

• azure_ai.generate(): Genererar text eller strukturerade utdata med hjälp av stora språkmodeller (LLM).
• azure_ai.is_true(): Utvärderar sannolikheten för att en viss instruktion är sann.
• azure_ai.extract(): Extraherar strukturerade funktioner eller entiteter från text.
• azure_ai.rank(): Rankar en lista över dokument baserat på relevans för en viss fråga.

Varje funktion fungerar via AI Foundry-slutpunkter som registrerats med hjälp av azure_ai.set_setting funktionen, vilket säkerställer sömlös integrering och användarkontroll.

Förstå semantiska operatorer

Semantiska operatörer i Azure AI-tillägget är utformade för att förenkla komplexa AI-drivna uppgifter direkt i din PostgreSQL-databas. Dessa operatorer gör det möjligt för användare att sömlöst integrera generativa AI-funktioner i sina SQL-arbetsflöden, vilket möjliggör avancerad textgenerering, sanningsutvärdering, entitetsextrahering och dokumentrankning. Varje operatör är optimerad för enkel användning och flexibilitet, vilket gör det möjligt för utvecklare att skapa intelligenta program med minimal ansträngning.

azure_ai.generate()

Den här operatorn använder LLM:er för att generera text eller strukturerade utdata.

Den stöder följande indataparametrar:

Som standard returnerar operatorn ett text värde som innehåller det genererade svaret. Om argumentet json_schema anges returneras utdata som ett strukturerat JsonB objekt som överensstämmer med det angivna schemat.

Användningsexempel:

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

Den här operatorn utvärderar sannolikheten för att en viss instruktion är sann, returnerar ett boolean värde eller NULL om resultatet är ofullständigt.

Den stöder följande indataparametrar:

Användningsexempel:

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

Den här operatorn extraherar strukturerade funktioner eller entiteter från text baserat på användardefinierade etiketter.

Den stöder följande indataparametrar:

Operatorn returnerar ett JsonB objekt som innehåller de extraherade entiteter som mappats till motsvarande etiketter.

Exempel på användning:

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

Den här operatorn rankar dokument på nytt baserat på deras relevans för en viss fråga. Den stöder korskodare och GPT-modeller.

Den stöder följande indataparametrar:

Operatorn returnerar ett table innehållande dokument-ID, dess rangordning och tillhörande relevanspoäng.

Användningsexempel:

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;

Så här kommer du igång

Följ dessa steg om du vill använda semantiska operatorer i PostgreSQL-databasen:

Installation för .generate()operatorer , .extract()och .is_true()

De här operatörerna stöder modeller för chattens slutförande och standardvärdet är gpt-4.1.

1. azure_ai Aktivera tillägget på din flexibla Azure Database for PostgreSQL-serverinstans.

2. Skapa en Azure OpenAI-tjänstresurs och distribuera en modell för chattens slutförande (till exempel gpt-4.1). Du kan också distribuera och hantera modeller via de intuitiva upplevelser som tillhandahålls av Azure AI Foundry.

3. Observera URL:en för Azure OpenAI-slutpunkten och API-nyckeln.

4. Konfigurera åtkomst:

   Om du vill aktivera azure_ai tillägget för att anropa den här modellen med hjälp av prenumerationsnyckelautentisering kör du följande SQL-kommandon:

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

   Om du vill använda hanterade identiteter i stället läser du den här artikeln för att utföra följande steg:

   • Aktivera systemtilldelad hanterad identitet för din flexibla Azure Database for PostgreSQL-serverinstans och starta om servern.
   • Tilldela rollen "Cognitive Services OpenAI User" till den hanterade identiteten för att interagera med Azure OpenAI-resursen.
   • azure_openai.auth_type Ange till "hanterad identitet".
   • azure_openai.endpoint Ange med slutpunkts-URL:en.

5. Nu är alla inställda på att anropa operatorerna .generate(), .is_true()och .extract() .

   Exempel på användning med gpt-4.1 (standard):

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

   Exempel på användning med andra modeller:

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

Installation för .rank() operator

Operatorn .rank() stöder både modeller för korskodare och chattens slutförande och standardvärdet för korskodaren Cohere-rerank-v3.5.

Använda Cohere-rerank-v3.5 korskodare:

1. azure_ai Aktivera tillägget på din Azure Database for PostgreSQL-instans.

2. Gå till Azure AI Foundry och distribuera Cohere-rerank-v3.5 modellen med köpalternativet Serverlöst API.

3. Observera modellens slutpunktsnyckel och Reranker API-vägen som bör se ut ungefär så här: https://<deployment name>.<region>.models.ai.azure.com/<v1 or v2>/rerank.

4. Konfigurera åtkomst:

   Om du vill aktivera azure_ai tillägget för att anropa den här modellen med hjälp av prenumerationsnyckelautentisering kör du följande SQL-kommandon:

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

   Om du vill använda hanterade identiteter i stället läser du den här artikeln för att utföra följande steg:

   • Aktivera systemtilldelad hanterad identitet för din flexibla Azure Database for PostgreSQL-serverinstans och starta om servern.
   • Tilldela rollen "Azure Machine Learning Data Scientist" till den hanterade identiteten för att interagera med Cohere-modellen.
   • azure_ml.auth_type Ange till "hanterad identitet".
   • azure_ml.serverless_ranking_endpoint Ange med cohere-reranker-API:et.

5. Nu är du redo att anropa operatorn .rank() med cohere reranker-modellen.

   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;
   

Om du vill använda operatorn .rank() med chattavslutsmodeller som gpt-4.1distribuerar du den önskade modellen i Azure OpenAI, konfigurerar azure_ai tillägget med modellens slutpunktsinformation och anger modellnamnet när operatorn anropas.

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;

Relaterat innehåll

• Generativ AI med Azure Database for PostgreSQL
• Azure AI-tillägg i Azure Database for PostgreSQL
• Vektorlager i Azure Database for PostgreSQL
• PostgreSQL-tillägg för Visual Studio Code
• GitHub Copilot-tillägg