Semantische Operatoren in der Azure AI Erweiterung (Vorschau)

Die Azure AI-Erweiterung führt semantische Operatoren ein, ein Feature, das erweiterte generative AI-Funktionen (GenAI) direkt in PostgreSQL SQL integriert. Mithilfe dieser Operatoren, die Modelle wie Chatabschluss und andere Azure AI-Bereitstellungen verwenden, können Entwickler genAI-gesteuerte Anwendungen direkt in ihren Datenbanken erstellen. Diese Integration erschließt neue Möglichkeiten zum Verständnis von Texten, logischem Denken und dem Generieren strukturierter Ergebnisse.

Wichtigste Funktionen

Die semantischen Operatoren bieten Benutzern vier Kern-SQL-Funktionen, die generative KI-Funktionen verwenden:

• azure_ai.generate(): Generiert Text oder strukturierte Ausgaben mit Large Language Models (LLMs).
• azure_ai.is_true(): Evaluiert die Wahrscheinlichkeit, dass eine bestimmte Aussage wahr ist.
• azure_ai.extract(): Extrahiert strukturierte Funktionen oder Entitäten aus Text.
• azure_ai.rank(): Ordnet eine Liste von Dokumenten neu, basierend auf der Relevanz für eine gegebene Anfrage.

Jede Funktion arbeitet über Microsoft Foundry-Endpunkte, die mithilfe der azure_ai.set_setting Funktion registriert sind, und stellt eine nahtlose Integration und Benutzersteuerung sicher.

Grundlegendes zu semantischen Operatoren

Semantische Operatoren in der Azure AI-Erweiterung vereinfachen komplexe KI-gesteuerte Aufgaben direkt in Ihrer PostgreSQL-Datenbank. Mithilfe dieser Operatoren können Sie generative KI-Funktionen nahtlos in Ihre SQL-Workflows integrieren. Sie können erweiterte Textgenerierung, Wahrheitsauswertung, Entitätsextraktion und Dokumentbewertung durchführen. Jeder Operator ist für benutzerfreundlichkeit und Flexibilität optimiert, sodass Sie intelligente Anwendungen mit minimalem Aufwand erstellen können.

azure_ai.generate()

Verwenden Sie diesen Operator, um Text oder strukturierte Ausgabe mithilfe von LLMs zu generieren.

Es unterstützt die folgenden Eingabeparameter:

Standardmäßig gibt der Operator einen text Wert zurück, der die generierte Antwort enthält. Wenn Sie das json_schema Argument angeben, gibt der Operator die Ausgabe als strukturiertes JsonB Objekt zurück, das dem angegebenen Schema entspricht.

Beispiel für die Verwendung:

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

Dieser Operator wertet die Wahrscheinlichkeit aus, dass eine bestimmte Aussage wahr ist. Es gibt einen boolean Wert zurück oder NULL wenn das Ergebnis nicht eindeutig ist.

Es unterstützt die folgenden Eingabeparameter:

Beispiel für die Verwendung:

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

Verwenden Sie diesen Operator, um strukturierte Features oder Entitäten basierend auf benutzerdefinierten Bezeichnungen aus Text zu extrahieren.

Es unterstützt die folgenden Eingabeparameter:

Der Operator gibt ein JsonB-Objekt zurück, das die extrahierten Entitäten enthält, die den entsprechenden Bezeichnungen zugeordnet sind.

Beispielverwendung:

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

Verwenden Sie diesen Operator, um Dokumente basierend auf ihrer Relevanz für eine bestimmte Abfrage neu zu reranken. Er unterstützt Cross-Encoder- und GPT-Modelle.

Es unterstützt die folgenden Eingabeparameter:

Der Operator gibt ein table zurück, das die ID des Dokuments, seinen Rang und den zugehörigen Score für die Relevanz enthält.

Beispiel für die Verwendung:

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;

Einstieg

Um semantische Operatoren in Ihrer PostgreSQL-Datenbank zu verwenden, gehen Sie wie folgt vor:

Einrichtung für .generate(), .extract() und .is_true() Operatoren

Diese Operatoren unterstützen Modelle zur Chat-Vervollständigung und sind standardmäßig auf gpt-4.1 eingestellt.

1. Aktivieren Sie die azure_ai Erweiterung in Ihrer Azure-Datenbank für flexible Serverinstanz von PostgreSQL.

2. Erstellen Sie eine Azure OpenAI Service Ressource und stellen Sie ein Chat-Vervollständigungsmodell bereit (z.B. gpt-4.1). Alternativ können Sie Modelle über die intuitiven Funktionen von Foundry bereitstellen und verwalten.

3. Beachten Sie die Azure OpenAI Endpunkt-URL und API-Schlüssel.

4. Konfigurieren Sie den Zugriff:

   Um die azure_ai Erweiterung zum Aufrufen dieses Modells mithilfe der Abonnementschlüsselauthentifizierung zu aktivieren, führen Sie die folgenden SQL-Befehle aus:

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

   Wenn Sie stattdessen verwaltete Identitäten verwenden möchten, lesen Sie diesen Artikel , um die folgenden Schritte auszuführen:

   • Aktivieren Sie die vom System zugewiesene verwaltete Identität für Ihre Azure-Datenbank für flexible Serverinstanz von PostgreSQL, und starten Sie den Server neu.
   • Weisen Sie der verwalteten Identität die Rolle „Cognitive Services OpenAI User“ zu, um mit der Azure OpenAI Ressource zu interagieren.
   • Legen Sie azure_openai.auth_type auf ‚verwaltete Identität‘ fest.
   • Legen Sie azure_openai.endpoint auf die URL des Endpunkts fest.

5. Jetzt sind Sie bereit, die .generate(), .is_true() und .extract() Operatoren aufzurufen.

   Beispiel für die Verwendung mit gpt-4.1 (Standard):

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

   Beispiel für die Verwendung mit anderen Modellen:

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

Einrichtung für .rank() Operator

Der .rank() Operator unterstützt sowohl Cross-Encoder- als auch Chat-Vervollständigungsmodelle. Standardmäßig wird der Kreuz-Encoder Cohere-rerank-v3.5verwendet.

Verwenden Sie Cohere-rerank-v3.5 Cross-Encoder:

1. Aktivieren Sie die azure_ai Erweiterung in Ihrer Azure-Datenbank für Die PostgreSQL-Instanz.

2. Wechseln Sie zu Foundry, und stellen Sie das Cohere-rerank-v3.5 Modell mithilfe der Kaufoption "Serverless API" bereit.

3. Beachten Sie den Endpunktschlüssel des Modells und die Reranker-API-Route. Es sollte etwa wie folgt aussehen: https://<deployment name>.<region>.models.ai.azure.com/<v1 or v2>/rerank.

4. Konfigurieren Sie den Zugriff:

   Um die azure_ai Erweiterung zum Aufrufen dieses Modells mithilfe der Abonnementschlüsselauthentifizierung zu aktivieren, führen Sie die folgenden SQL-Befehle aus:

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

   Wenn Sie stattdessen verwaltete Identitäten verwenden möchten, lesen Sie diesen Artikel , um die folgenden Schritte auszuführen:

   • Aktivieren Sie die vom System zugewiesene verwaltete Identität für Ihre Azure-Datenbank für flexible Serverinstanz von PostgreSQL, und starten Sie den Server neu.
   • Weisen Sie der verwalteten Identität die Rolle „Azure Machine Learning Data Scientist“ zu, um mit dem Cohere-Modell zu interagieren.
   • Legen Sie azure_ml.auth_type auf ‚verwaltete Identität‘ fest.
   • Legen Sie azure_ml.serverless_ranking_endpoint mit der Cohere Reranker-API fest.

5. Jetzt sind Sie bereit, den .rank()-Operator mit dem Cohere Reranker-Modell aufzurufen.

   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;
   

Um den .rank()-Operator mit Chat-Vervollständigungsmodellen wie gpt-4.1 zu verwenden, stellen Sie das gewünschte Modell in Azure OpenAI bereit, konfigurieren Sie die azure_ai-Erweiterung mit den Endpunktdetails des Modells, und geben Sie den Modellnamen an, wenn Sie den Operator aufrufen.

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;

Verwandte Inhalte

• Generative KI mit Azure-Datenbank für PostgreSQL
• Azure AI-Erweiterung in Azure Database for PostgreSQL
• Vektor-Stores in Azure Database for PostgreSQL
• PostgreSQL-Erweiterung für Visual Studio Code
• GitHub Copilot-Erweiterung