KI-Funktionen in der azure_ai-Erweiterung (Vorschau)

Die azure_ai Erweiterung führt KI-Funktionen ein, ein Feature, das erweiterte generative KI-Funktionen (GenAI) direkt in PostgreSQL SQL integriert. Mithilfe dieser Funktionen mit Modellen wie Chat-Abschluss, Einbettungen und anderen Bereitstellungen von Foundry-Modellen können Entwickler GenAI-gesteuerte Anwendungen direkt innerhalb ihrer Datenbanken erstellen. Diese Integration ermöglicht neue Funktionen für die Generierung von Vektoreinbettungen, Textverständnis, Reasoning und Erzeugen strukturierter Ausgaben.

Wichtigste Funktionen

Die KI-Funktionen bieten Benutzern fünf Kern-SQL-Funktionen, die generative KI-Funktionen verwenden:

• azure_ai.generate(): Generiert Text oder strukturierte Ausgabe mithilfe großer Sprachmodelle (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.
• Generieren Sie Vektoreinbettungen mit Azure OpenAI in Azure Database for PostgreSQL: Erstellt Vektoreinbettungen für einen bestimmten Eingabetext.

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 KI-Funktionen

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

azure_ai.generate()

Verwenden Sie diese Funktion, um Text oder strukturierte Ausgabe mithilfe von LLMs zu generieren.

Es unterstützt die folgenden Eingabeparameter:

Standardmäßig gibt die Funktion einen text Wert zurück, der die generierte Antwort enthält. Wenn Sie das json_schema Argument angeben, gibt die Funktion 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()

Diese Funktion bewertet die Wahrscheinlichkeit, dass eine gegebene 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 diese Funktion, um strukturierte Features oder Entitäten aus Text basierend auf benutzerdefinierten Bezeichnungen zu extrahieren.

Es unterstützt die folgenden Eingabeparameter:

Die Funktion gibt ein JsonB Objekt zurück, das die extrahierten Entitäten enthält, die ihren 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 diese Funktion, 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:

Die Funktion gibt eine table enthaltende Dokument-ID, deren Rang und die zugeordnete Relevanzbewertung zurück.

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;

Wie man anfängt

Führen Sie die folgenden Schritte aus, um KI-Funktionen in Ihrer PostgreSQL-Datenbank zu verwenden:

Setup für .generate(), .extract() und .is_true()-Funktionen

Diese Funktionen unterstützen Chat-Vervollständigungsmodelle und verwenden standardmäßig gpt-4.1.

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 in Foundry Models endpoint 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. Sie sind jetzt bereit, die Funktionen .generate(), .is_true() und .extract() 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;
   

Setup für .rank() funktion

Die .rank() Funktion unterstützt sowohl Cross-Encoder- als auch Chat-Abschlussmodelle. Standardmäßig wird der Kreuz-Encoder Cohere-rerank-v3.5verwendet.

So verwenden Sie den 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 Wissenschaftliche Fachkraft für Daten“ 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. Sie sind jetzt bereit, die .rank() Funktion mit dem Cohere-Rerankermodell 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 die funktion .rank() mit Chat-Vervollständigungsmodellen wie gpt-4.1 zu verwenden, stellen Sie das gewünschte Modell auf Azure OpenAI bereit, konfigurieren Sie die Erweiterung azure_ai mit den Endpunktdetails des Modells, und geben Sie den Modellnamen beim Aufrufen der Funktion an.

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 der Azure-Datenbank für PostgreSQL
• Vektor-Stores in Azure Database for PostgreSQL
• PostgreSQL-Erweiterung für Visual Studio Code
• GitHub Copilot-Erweiterung