Operadores semânticos na extensão Azure AI (Pré-visualização)

A extensão Azure AI introduz os Operadores Semânticos, uma funcionalidade que integra capacidades avançadas de IA Generativa (GenAI) diretamente no PostgreSQL SQL. Ao utilizar estes operadores, que são modelos como o chat completion e outras implementações de IA Azure, os programadores podem construir aplicações baseadas em GenAI diretamente nas suas bases de dados. Esta integração desbloqueia novas capacidades para compreender texto, raciocínio e gerar resultados estruturados.

Principais características

Os Operadores Semânticos fornecem aos usuários quatro funções SQL principais que usam recursos de IA generativa:

• azure_ai.generate(): Gera texto ou saída estruturada usando Large Language Models (LLMs).
• azure_ai.is_true(): Avalia a probabilidade de uma determinada afirmação ser verdadeira.
• azure_ai.extract(): Extrai recursos estruturados ou entidades do texto.
• azure_ai.rank(): Reclassifica uma lista de documentos com base na relevância para uma determinada consulta.

Cada função opera através de endpoints Microsoft Foundry registados através da função azure_ai.set_setting, garantindo uma integração sem falhas e controlo do utilizador.

Noções básicas sobre operadores semânticos

Os Operadores Semânticos na extensão Azure AI simplificam tarefas complexas orientadas por IA diretamente na sua base de dados PostgreSQL. Ao utilizar estes operadores, pode integrar de forma fluida capacidades de IA generativa nos seus fluxos de trabalho SQL. Pode realizar geração avançada de texto, avaliação da verdade, extração de entidades e classificação de documentos. Cada operador está otimizado para facilidade de utilização e flexibilidade, permitindo construir aplicações inteligentes com o mínimo de esforço.

azure_ai.generate()

Use este operador para gerar texto ou saída estruturada utilizando LLMs.

Ele suporta os seguintes parâmetros de entrada:

Por padrão, o operador retorna um text valor que contém a resposta gerada. Se fornecer o json_schema argumento, o operador devolve a saída como um objeto estruturado JsonB que segue o esquema especificado.

Exemplo de utilização:

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

Este operador avalia a probabilidade de que uma determinada afirmação seja verdadeira. Devolve um boolean valor ou NULL se o resultado for inconclusivo.

Ele suporta os seguintes parâmetros de entrada:

Exemplo de utilização:

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

Use este operador para extrair características ou entidades estruturadas do texto com base em rótulos definidos pelo utilizador.

Ele suporta os seguintes parâmetros de entrada:

O operador retorna um JsonB objeto contendo as entidades extraídas mapeadas para seus rótulos correspondentes.

Exemplo de uso:

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

Use este operador para reclassificar documentos com base na sua relevância para uma determinada consulta. Suporta modelos cross-encoder e GPT.

Ele suporta os seguintes parâmetros de entrada:

O operador retorna um table contendo o ID do documento, sua classificação e a pontuação de relevância associada.

Exemplo de utilização:

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;

Como começar

Para usar operadores semânticos em seu banco de dados PostgreSQL, execute estas etapas:

Configuração para .generate(), .extract()e .is_true() operadores

Esses operadores suportam modelos de conclusão de bate-papo e definem-se por padrão como gpt-4.1.

1. Habilite a azure_ai extensão em seu Banco de Dados do Azure para instância de servidor flexível PostgreSQL.

2. Crie um recurso de serviço OpenAI do Azure e implante um modelo de conclusão de chat (por exemplo, gpt-4.1). Em alternativa, pode implementar e gerir modelos através das experiências intuitivas proporcionadas pelo Foundry.

3. Anote o URL do ponto de extremidade do Azure OpenAI e a chave da API.

4. Configure o acesso:

   Para permitir que a azure_ai extensão invoque este modelo usando autenticação por chave de subscrição, execute os seguintes comandos SQL:

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

   Se quiser usar identidades geridas, consulte este artigo para realizar os seguintes passos:

   • Habilite a identidade gerenciada atribuída pelo sistema para sua instância de servidor flexível do Banco de Dados do Azure para PostgreSQL e reinicie o servidor.
   • Atribua a função "Usuário OpenAI dos Serviços Cognitivos" à identidade gerenciada para interagir com o recurso OpenAI do Azure.
   • Configure o azure_openai.auth_type para 'identidade gerida'.
   • Defina o azure_openai.endpoint com o URL do ponto final.

5. Agora está pronto para invocar os operadores .generate(), .is_true(), e .extract().

   Exemplo de uso com gpt-4.1 (padrão):

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

   Exemplo de utilização com outros modelos:

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

Configuração do operador .rank()

O .rank() operador suporta tanto modelos cross-encoder como de conclusão de conversação. Por defeito, usa o codificador cruzado Cohere-rerank-v3.5.

Usando Cohere-rerank-v3.5 codificador cruzado:

1. Habilite a azure_ai extensão em seu Banco de Dados do Azure para a instância do PostgreSQL.

2. Vai ao Foundry e implementa o Cohere-rerank-v3.5 modelo usando a opção de compra da API Serverless.

3. Anote a chave do ponto de extremidade do modelo e a rota da API do Reranker. Deveria parecer algo assim: https://<deployment name>.<region>.models.ai.azure.com/<v1 or v2>/rerank.

4. Configure o acesso:

   Para permitir que a azure_ai extensão invoque este modelo usando autenticação por chave de subscrição, execute os seguintes comandos SQL:

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

   Se quiser usar identidades geridas, consulte este artigo para realizar os seguintes passos:

   • Habilite a identidade gerenciada atribuída pelo sistema para sua instância de servidor flexível do Banco de Dados do Azure para PostgreSQL e reinicie o servidor.
   • Atribua a função "Cientista de Dados do Azure Machine Learning" à identidade gerenciada para interagir com o modelo Cohere.
   • Configure o azure_ml.auth_type para 'managed-identity'.
   • Defina o azure_ml.serverless_ranking_endpoint com a API de reclassificação Cohere.

5. Agora está tudo pronto para invocar o .rank() operador usando o modelo de reclassificação do Cohere.

   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;
   

Para usar o .rank() operador com modelos de conclusão de chat como gpt-4.1, implemente o modelo desejado no Azure OpenAI, configure a azure_ai extensão com os detalhes do endpoint do modelo e especifique o nome do modelo ao invocar o operador.

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;

Conteúdo relacionado

• IA generativa com o Banco de Dados do Azure para PostgreSQL
• Extensão Azure AI no Banco de Dados do Azure para PostgreSQL
• Repositórios de vetores no Banco de Dados do Azure para PostgreSQL
• Extensão PostgreSQL para Visual Studio Code
• Extensão do Copilot do GitHub