IA: Linguagem natural para SQL

A citação "Só porque você pode, não significa que deveria" é um guia útil ao pensar em recursos de IA. Por exemplo, o recurso de linguagem natural para SQL do Azure OpenAI permite que os usuários façam consultas ao banco de dados em inglês simples, o que pode ser uma ferramenta poderosa para aumentar sua produtividade. No entanto, poderoso nem sempre significa apropriado ou seguro. Este exercício demonstrará como usar esse recurso de IA e, ao mesmo tempo, discutirá considerações importantes a serem lembradas antes de decidir implementá-lo.

Aqui está um exemplo de uma consulta de linguagem natural que pode ser usada para recuperar dados de um banco de dados:

Get the the total revenue for all companies in London.

Com os prompts adequados, o Azure OpenAI converterá essa consulta em SQL que pode ser usada para retornar resultados do banco de dados. Como resultado, usuários não técnicos, incluindo analistas de negócios, profissionais de marketing e executivos, podem recuperar mais facilmente informações valiosas de bancos de dados sem lidar com a sintaxe SQL complexa ou depender de grades de dados e filtros restritos. Essa abordagem simplificada pode aumentar a produtividade, eliminando a necessidade de os usuários buscarem assistência de especialistas técnicos.

Este exercício fornece um ponto de partida que ajudará você a entender como funciona a linguagem natural para SQL, apresentará algumas considerações importantes, fará você pensar sobre prós e contras e mostrará o código para começar.

Neste exercício, você vai:

Use prompts da GPT para converter linguagem natural em SQL.
Experimente diferentes prompts da GPT.
Use o SQL gerado para consultar o banco de dados PostgreSQL iniciado anteriormente.
Retorne os resultados da consulta do PostgreSQL e exiba-os no navegador.

Vamos começar experimentando diferentes prompts GPT que podem ser usados para converter linguagem natural em SQL.

Usando o recurso de linguagem natural para SQL

No exercício anterior , você iniciou o banco de dados, as APIs e o aplicativo. Você também atualizou o .env arquivo. Se você não concluiu essas etapas, siga as instruções no final do exercício antes de continuar.
Volte para o navegador (http://localhost:4200) e localize a seção Consulta Personalizada da página abaixo da datagrid. Observe que um valor de consulta de exemplo já está incluído: obtenha a receita total de todos os pedidos. Agrupar por empresa e incluir a cidade.
Selecione o botão Executar Consulta . Isso passará a consulta de linguagem natural do usuário para o Azure OpenAI, que a converterá em SQL. A consulta SQL será usada para consultar o banco de dados e retornar possíveis resultados.

Execute a seguinte Consulta Personalizada:

Get the total revenue for Adventure Works Cycles. Include the contact information as well.

Exiba a janela de terminal que executa o servidor de API no Visual Studio Code e observe que ela exibe a consulta SQL retornada do Azure OpenAI. Os dados JSON são usados pelas APIs do lado do servidor para consultar o banco de dados PostgreSQL. Todos os valores de cadeia de caracteres incluídos na consulta são adicionados como valores de parâmetro para evitar ataques de injeção de SQL:
```
{ 
    "sql": "SELECT c.company, c.city, c.email, SUM(o.total) AS revenue FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE c.company = $1 GROUP BY c.company, c.city, c.email", 
    "paramValues": ["Adventure Works Cycles"] 
}
```
Volte para o navegador e selecione Redefinir Dados para exibir todos os clientes novamente no datagrid.

Explorando a linguagem natural para o código SQL

Dica

Se você estiver usando o Visual Studio Code, poderá abrir arquivos diretamente selecionando:

Windows/Linux: Ctrl + P
Mac: Cmd + P

Em seguida, digite o nome do arquivo que deseja abrir.

Observação

O objetivo deste exercício é mostrar o que é possível com a funcionalidade de linguagem natural para SQL e demonstrar como começar a usá-la. Como mencionado anteriormente, é importante discutir se esse tipo de IA é apropriado para sua organização antes de prosseguir com qualquer implementação. Também é imperativo planejar regras de prompt adequadas e medidas de segurança de banco de dados para impedir o acesso não autorizado e proteger dados confidenciais.

Agora que você viu o recurso de linguagem natural para SQL em ação, vamos examinar como ele é implementado.

Abra o arquivo de servidor/apiRoutes.ts e localize a generateSql rota. Essa rota de API é chamada pelo aplicativo do lado do cliente em execução no navegador e usada para gerar SQL a partir de uma consulta de linguagem natural. Depois que a consulta SQL é recuperada, ela é usada para consultar o banco de dados e retornar resultados.

router.post('/generateSql', async (req, res) => {
    const userPrompt = req.body.prompt;

    if (!userPrompt) {
        return res.status(400).json({ error: 'Missing parameter "prompt".' });
    }

    try {
        // Call Azure OpenAI to convert the user prompt into a SQL query
        const sqlCommandObject = await getSQLFromNLP(userPrompt);

        let result: any[] = [];
        // Execute the SQL query
        if (sqlCommandObject && !sqlCommandObject.error) {
            result = await queryDb(sqlCommandObject) as any[];
        }
        else {
            result = [ { query_error : sqlCommandObject.error } ];
        }
        res.json(result);
    } catch (e) {
        console.error(e);
        res.status(500).json({ error: 'Error generating or running SQL query.' });
    }
});

Observe a seguinte funcionalidade na generateSql rota:

Ele recupera o valor de consulta do req.body.prompt usuário e o atribui a uma variável chamada userPrompt. Esse valor será usado no prompt da GPT.
Ele chama uma getSQLFromNLP() função para converter linguagem natural em SQL.
Ele passa o SQL gerado para uma função chamada queryDb que executa a consulta SQL e retorna resultados do banco de dados.

Abra o arquivo de servidor/openAI.ts em seu editor e localize a getSQLFromNLP() função. Essa função é chamada pela generatesql rota e é usada para converter linguagem natural em SQL.

async function getSQLFromNLP(userPrompt: string): Promise<QueryData> {
    // Get the high-level database schema summary to be used in the prompt.
    // The db.schema file could be generated by a background process or the 
    // schema could be dynamically retrieved.
    const dbSchema = await fs.promises.readFile('db.schema', 'utf8');

    const systemPrompt = `
    Assistant is a natural language to SQL bot that returns a JSON object with the SQL query and 
    the parameter values in it. The SQL will query a PostgreSQL database.

    PostgreSQL tables with their columns:    

    ${dbSchema}

    Rules:
    - Convert any strings to a PostgreSQL parameterized query value to avoid SQL injection attacks.
    - Return a JSON object with the following structure: { "sql": "", "paramValues": [] }

    Examples:

    User: "Display all company reviews. Group by company."      
    Assistant: { "sql": "SELECT * FROM reviews", "paramValues": [] }

    User: "Display all reviews for companies located in cities that start with 'L'."
    Assistant: { "sql": "SELECT r.* FROM reviews r INNER JOIN customers c ON r.customer_id = c.id WHERE c.city LIKE 'L%'", "paramValues": [] }

    User: "Display revenue for companies located in London. Include the company name and city."
    Assistant: { 
        "sql": "SELECT c.company, c.city, SUM(o.total) AS revenue FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE c.city = $1 GROUP BY c.company, c.city", 
        "paramValues": ["London"] 
    }

    User: "Get the total revenue for Adventure Works Cycles. Include the contact information as well."
    Assistant: { 
        "sql": "SELECT c.company, c.city, c.email, SUM(o.total) AS revenue FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE c.company = $1 GROUP BY c.company, c.city, c.email", 
        "paramValues": ["Adventure Works Cycles"] 
    }
    `;

    let queryData: QueryData = { sql: '', paramValues: [], error: '' };
    let results = '';

    try {
        results = await callOpenAI(systemPrompt, userPrompt);
        if (results) {
            console.log('results', results);
            const parsedResults = JSON.parse(results);
            queryData = { ...queryData, ...parsedResults };
            if (isProhibitedQuery(queryData.sql)) {
                queryData.sql = '';
                queryData.error = 'Prohibited query.';
            }
        }
    } catch (error) {
        console.log(error);
        if (isProhibitedQuery(results)) {
            queryData.sql = '';
            queryData.error = 'Prohibited query.';
        } else {
            queryData.error = results;
        }
    }

    return queryData;
}

Um userPrompt parâmetro é passado para a função. O userPrompt valor é a consulta de linguagem natural inserida pelo usuário no navegador.
A systemPrompt define o tipo de assistente de IA a ser usado e as regras que devem ser seguidas. Isso ajuda o Azure OpenAI a entender a estrutura do banco de dados, quais regras aplicar e como retornar a consulta SQL e os parâmetros gerados.
Uma função chamada callOpenAI() é chamada e os systemPrompt valores e userPrompt são passados para ela.
Os resultados são verificados para garantir que nenhum valor proibido seja incluído na consulta SQL gerada. Se valores proibidos forem encontrados, a consulta SQL será definida como uma cadeia de caracteres vazia.

Vamos examinar o prompt do sistema com mais detalhes:

const systemPrompt = `
  Assistant is a natural language to SQL bot that returns a JSON object with the SQL query and 
  the parameter values in it. The SQL will query a PostgreSQL database.

  PostgreSQL tables with their columns:    

  ${dbSchema}

  Rules:
  - Convert any strings to a PostgreSQL parameterized query value to avoid SQL injection attacks.
  - Return a JSON object with the following structure: { "sql": "", "paramValues": [] }

  Examples:

  User: "Display all company reviews. Group by company."      
  Assistant: { "sql": "SELECT * FROM reviews", "paramValues": [] }

  User: "Display all reviews for companies located in cities that start with 'L'."
  Assistant: { "sql": "SELECT r.* FROM reviews r INNER JOIN customers c ON r.customer_id = c.id WHERE c.city LIKE 'L%'", "paramValues": [] }

  User: "Display revenue for companies located in London. Include the company name and city."
  Assistant: { 
    "sql": "SELECT c.company, c.city, SUM(o.total) AS revenue FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE c.city = $1 GROUP BY c.company, c.city", 
    "paramValues": ["London"] 
  }

  User: "Get the total revenue for Adventure Works Cycles. Include the contact information as well."
  Assistant: { 
    "sql": "SELECT c.company, c.city, c.email, SUM(o.total) AS revenue FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE c.company = $1 GROUP BY c.company, c.city, c.email", 
    "paramValues": ["Adventure Works Cycles"] 
  }
`;

O tipo de assistente de IA a ser usado é definido. Neste caso, um "bot de linguagem natural para SQL".
Os nomes das tabelas e as colunas no banco de dados são definidos. O esquema de alto nível incluído no prompt pode ser encontrado no arquivo server/db.schema e se parece com o seguinte.
```
- customers (id, company, city, email)
- orders (id, customer_id, date, total)
- order_items (id, order_id, product_id, quantity, price)
- reviews (id, customer_id, review, date, comment)
```
Dica

Você pode considerar a criação de exibições somente leitura que contenham apenas os dados que os usuários têm permissão para consultar usando linguagem natural para SQL.
Uma regra é definida para converter quaisquer valores de cadeia de caracteres em um valor de consulta parametrizado para evitar ataques de injeção de SQL.
Uma regra é definida para sempre retornar um objeto JSON com a consulta SQL e os valores de parâmetro nele.
Exemplos de prompts de usuário e os valores esperados de consulta SQL e parâmetro são fornecidos. Isso é chamado de aprendizado "poucos tiros". Embora os LLMs sejam treinados em grandes quantidades de dados, eles podem ser adaptados a novas tarefas com apenas alguns exemplos. Uma abordagem alternativa é o aprendizado "zero-shot", em que nenhum exemplo é fornecido e espera-se que o modelo gere os valores corretos de consulta SQL e parâmetro.

A getSQLFromNLP() função envia o sistema e os prompts do usuário para uma função nomeada callOpenAI() que também está localizada no arquivo de servidor/openAI.ts . A função callOpenAI() determina se o Azure OpenAI em Modelos Foundry ou serviço OpenAI deve ser chamado, verificando as variáveis de ambiente. Se uma chave, um ponto de extremidade e um modelo estiverem disponíveis nas variáveis de ambiente, o OpenAI do Azure será chamado, caso contrário, o OpenAI será chamado.
```
function callOpenAI(systemPrompt: string, userPrompt: string, temperature = 0, useBYOD = false) {
    const isAzureOpenAI = OPENAI_API_KEY && OPENAI_ENDPOINT && OPENAI_MODEL;

    if (isAzureOpenAI) {
        if (useBYOD) {
            return getAzureOpenAIBYODCompletion(systemPrompt, userPrompt, temperature);
        }
        return getAzureOpenAICompletion(systemPrompt, userPrompt, temperature);
    }

    return getOpenAICompletion(systemPrompt, userPrompt, temperature);
}
```
Observação

Embora nos concentremos no Azure OpenAI ao longo deste tutorial, se você fornecer apenas um OPENAI_API_KEY valor no arquivo .env , o aplicativo usará OpenAI. Se você optar por usar o OpenAI em vez do Azure OpenAI, poderá ver resultados diferentes em alguns casos.
Localize a getAzureOpenAICompletion() função.
```
async function getAzureOpenAICompletion(systemPrompt: string, userPrompt: string, temperature: number): Promise<string> {
    const completion = await createAzureOpenAICompletion(systemPrompt, userPrompt, temperature);
    let content = completion.choices[0]?.message?.content?.trim() ?? '';
    console.log('Azure OpenAI Output: \n', content);
    if (content && content.includes('{') && content.includes('}')) {
        content = extractJson(content);
    }
    return content;
}
```
Essa função faz o seguinte:
- Parâmetros:
  - systemPrompt, userPrompte temperature são os principais parâmetros.
    - systemPrompt: informa o modelo OpenAI do Azure sobre sua função e as regras a serem seguidas.
    - userPrompt: Contém as informações fornecidas pelo usuário, como entrada de linguagem natural ou regras para gerar a saída.
    - temperature: Dita o nível de criatividade da resposta do modelo. Um valor mais alto resulta em saídas mais criativas, enquanto valores mais baixos (por exemplo, 0) produzem respostas mais determinísticas.
- Geração de conclusão:
  - A função chama createAzureOpenAICompletion() com systemPrompt, userPrompt, e temperature para gerar uma conclusão.
  - Ele extrai o conteúdo da primeira escolha na conclusão, cortando qualquer espaço em branco extra.
  - Se o conteúdo contiver estruturas semelhantes a JSON (indicadas pela presença de { e }), ele extrairá o conteúdo JSON.
- Registro em log e valor retornado:
  - A função registra a saída do OpenAI do Azure no console.
  - Ele retorna o conteúdo processado como uma cadeia de caracteres.
Localize a createAzureOpenAICompletion() função.
```
async function createAzureOpenAICompletion(systemPrompt: string, userPrompt: string, temperature: number, dataSources?: any[]): Promise<any> {
    const baseEnvVars = ['OPENAI_API_KEY', 'OPENAI_ENDPOINT', 'OPENAI_MODEL'];
    const byodEnvVars = ['AZURE_AI_SEARCH_ENDPOINT', 'AZURE_AI_SEARCH_KEY', 'AZURE_AI_SEARCH_INDEX'];
    const requiredEnvVars = dataSources ? [...baseEnvVars, ...byodEnvVars] : baseEnvVars;
    checkRequiredEnvVars(requiredEnvVars);

    const config = { 
        apiKey: OPENAI_API_KEY,
        endpoint: OPENAI_ENDPOINT,
        apiVersion: OPENAI_API_VERSION,
        deployment: OPENAI_MODEL
    };
    const aoai = new AzureOpenAI(config);
    const completion = await aoai.chat.completions.create({
        model: OPENAI_MODEL, // gpt-4o, gpt-3.5-turbo, etc. Pulled from .env file
        max_tokens: 1024,
        temperature,
        response_format: {
            type: "json_object",
        },
        messages: [
            { role: 'system', content: systemPrompt },
            { role: 'user', content: userPrompt }
        ],
        // @ts-expect-error data_sources is a custom property used with the "Azure Add Your Data" feature
        data_sources: dataSources
    });
    return completion;
}

function checkRequiredEnvVars(requiredEnvVars: string[]) {
    for (const envVar of requiredEnvVars) {
        if (!process.env[envVar]) {
            throw new Error(`Missing ${envVar} in environment variables.`);
        }
    }
}
```
Essa função faz o seguinte:
- Parâmetros:
  - systemPrompt, userPrompte temperature são os principais parâmetros discutidos anteriormente.
  - Um parâmetro opcional dataSources dá suporte ao recurso "Azure Bring Your Own Data", que será abordado posteriormente neste tutorial.
- Verificação de variáveis de ambiente:
  - A função verifica a presença de variáveis de ambiente essenciais, gerando um erro se alguma estiver faltando.
- Objeto configuration:
  - Um config objeto é criado usando valores do .env arquivo (OPENAI_API_KEY, OPENAI_ENDPOINT, OPENAI_API_VERSION, OPENAI_MODEL). Esses valores são usados para construir a URL para chamar o Azure OpenAI.
- Instância do AzureOpenAI:
  - Uma instância de AzureOpenAI é criada usando o objeto config. O AzureOpenAI símbolo faz parte do openai pacote, que deve ser importado na parte superior do seu arquivo.
- Gerando uma conclusão:
  - A chat.completions.create() função é chamada com as seguintes propriedades:
    - model: Especifica o modelo GPT (por exemplo, gpt-4o, gpt-3.5-turbo) conforme definido em seu .env arquivo.
    - max_tokens: Define o número máximo de tokens para a conclusão.
    - temperature: Define a temperatura de amostragem. Valores mais altos (por exemplo, 0,9) produzem respostas mais criativas, enquanto valores mais baixos (por exemplo, 0) produzem respostas mais determinísticas.
    - response_format: Define o formato da resposta. Aqui, ele está definido para retornar um objeto JSON. Mais detalhes sobre o modo JSON podem ser encontrados na documentação de referência do Azure OpenAI.
    - messages: contém as mensagens para gerar conclusões de bate-papo. Este exemplo inclui duas mensagens: uma do sistema (definindo comportamento e regras) e outra do usuário (contendo o texto do prompt).
- Valor retornado:
  - A função retorna o objeto de conclusão gerado pelo OpenAI do Azure.

Comente as seguintes linhas na getSQLFromNLP() função:

// if (isProhibitedQuery(queryData.sql)) { 
//     queryData.sql = '';
// }

Salve openAI.ts. O servidor de API recompilará automaticamente o código TypeScript e reiniciará o servidor.
Volte para o navegador e insira Selecionar todos os nomes de tabela do banco de dados na entrada consulta personalizada . Selecione Executar Consulta. Os nomes das tabelas são exibidos?
Volte para a getSQLFromNLP() função no servidor/openAI.ts e adicione a regra a Rules: seguir na seção do prompt do sistema e salve o arquivo.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Volte para o navegador e execute as seguintes tarefas:
- Insira Selecionar todos os nomes de tabela do banco de dados na entrada consulta personalizada. Selecione Executar Consulta. Os nomes das tabelas são exibidos?
- Insira Selecionar todos os nomes de função do banco de dados. Na entrada consulta personalizada e selecione Executar Consulta novamente. Os nomes das funções são exibidos?
PERGUNTA: Um modelo sempre seguirá as regras definidas no prompt?

RESPOSTA: Não! É importante observar que os modelos OpenAI podem retornar resultados inesperados ocasionalmente que podem não corresponder às regras que você definiu. É importante planejar isso em seu código.
Volte para o servidor/openAI.ts e localize a isProhibitedQuery() função. Este é um exemplo de código de pós-processamento que pode ser executado depois que o Azure OpenAI retorna resultados. Observe que ele define a sql propriedade como uma cadeia de caracteres vazia se palavras-chave proibidas forem retornadas na consulta SQL gerada. Isso garante que, se resultados inesperados forem retornados do Azure OpenAI, a consulta SQL não será executada no banco de dados.
```
function isProhibitedQuery(query: string): boolean {
    if (!query) return false;

    const prohibitedKeywords = [
        'insert', 'update', 'delete', 'drop', 'truncate', 'alter', 'create', 'replace',
        'information_schema', 'pg_catalog', 'pg_tables', 'pg_proc', 'pg_namespace', 'pg_class',
        'table_schema', 'table_name', 'column_name', 'column_default', 'is_nullable',
        'data_type', 'udt_name', 'character_maximum_length', 'numeric_precision',
        'numeric_scale', 'datetime_precision', 'interval_type', 'collation_name',
        'grant', 'revoke', 'rollback', 'commit', 'savepoint', 'vacuum', 'analyze'
    ];
    const queryLower = query.toLowerCase();
    return prohibitedKeywords.some(keyword => queryLower.includes(keyword));
}
```
Observação

É importante observar que este é apenas um código de demonstração. Pode haver outras palavras-chave proibidas necessárias para cobrir seus casos de uso específicos se você optar por converter linguagem natural em SQL. Esse é um recurso que você deve planejar e usar com cuidado para garantir que apenas consultas SQL válidas sejam retornadas e executadas no banco de dados. Além das palavras-chave proibidas, você também precisará levar em consideração a segurança.
Volte para o servidor/openAI.ts e descompacte o código a getSQLFromNLP() seguir na função. Salve o arquivo.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Remova a regra a systemPrompt seguir e salve o arquivo.

- Do not allow the SELECT query to return table names, function names, or procedure names.

Volte para o navegador, insira Selecionar todos os nomes de tabela do banco de dados na entrada consulta personalizada novamente e selecione o botão Executar Consulta .
Algum resultado da tabela é exibido? Mesmo sem a regra em vigor, o isProhibitedQuery código de pós-processamento proíbe que esse tipo de consulta seja executado no banco de dados.
Conforme discutido anteriormente, a integração da linguagem natural ao SQL em aplicativos de linha de negócios pode ser bastante benéfica para os usuários, mas vem com seu próprio conjunto de considerações.

Vantagens:
- Facilidade de uso: esse recurso pode tornar a interação com o banco de dados mais acessível a usuários sem conhecimento técnico, reduzindo a necessidade de conhecimento de SQL e potencialmente acelerando as operações.
- Maior produtividade: analistas de negócios, profissionais de marketing, executivos e outros usuários não técnicos podem recuperar informações valiosas de bancos de dados sem precisar depender de especialistas técnicos, aumentando assim a eficiência.
- Ampla aplicação: usando modelos de linguagem avançados, os aplicativos podem ser projetados para atender a uma ampla gama de usuários e casos de uso.
Considerações:
- Segurança: Uma das maiores preocupações é a segurança. Se os usuários podem interagir com bancos de dados usando linguagem natural, é necessário que haja medidas de segurança robustas para evitar acesso não autorizado ou consultas maliciosas. Você pode considerar a implementação de um modo somente leitura para impedir que os usuários modifiquem dados.
- Privacidade de dados: Certos dados podem ser confidenciais e não devem ser facilmente acessíveis, portanto, você precisará garantir que as proteções adequadas e as permissões do usuário estejam em vigor.
- Precisão: Embora o processamento de linguagem natural tenha melhorado significativamente, ele não é perfeito. A interpretação incorreta das consultas do usuário pode levar a resultados imprecisos ou comportamento inesperado. Você precisará planejar como os resultados inesperados serão tratados.
- Eficiência: não há garantias de que o SQL retornado de uma consulta de linguagem natural será eficiente. Em alguns casos, chamadas adicionais para o Azure OpenAI podem ser necessárias se as regras de pós-processamento detectarem problemas com consultas SQL.
- Treinamento e adaptação do usuário: Os usuários precisam ser treinados para formular suas consultas corretamente. Embora seja mais fácil do que aprender SQL, ainda pode haver uma curva de aprendizado envolvida.
Alguns pontos finais a serem considerados antes de passar para o próximo exercício:
- Lembre-se de que "Só porque você pode, não significa que você deve" se aplica aqui. Tenha muito cuidado e planejamento cuidadoso antes de integrar a linguagem natural ao SQL em um aplicativo. É importante entender os riscos potenciais e se planejar para eles.
- Antes de usar esse tipo de tecnologia, discuta possíveis cenários com sua equipe, administradores de banco de dados, equipe de segurança, partes interessadas e quaisquer outras partes relevantes para garantir que seja apropriado para sua organização. É importante discutir se a linguagem natural para SQL atende aos requisitos de segurança, privacidade e quaisquer outros requisitos que sua organização possa ter.
- A segurança deve ser uma preocupação principal e incorporada ao processo de planejamento, desenvolvimento e implantação.
- Embora a linguagem natural para SQL possa ser muito poderosa, um planejamento cuidadoso deve ser feito para garantir que os prompts tenham as regras necessárias e que a funcionalidade de pós-processamento seja incluída. Planeje mais tempo para implementar e testar esse tipo de funcionalidade e levar em conta cenários em que resultados inesperados são retornados.
- Com o OpenAI do Azure, os clientes obtêm os recursos de segurança do Microsoft Azure enquanto executam os mesmos modelos que o OpenAI. O OpenAI do Azure oferece rede privada, disponibilidade regional e filtragem de conteúdo de IA responsável. Saiba mais sobre dados, privacidade e segurança para o Azure OpenAI.
Agora você viu como usar o Azure OpenAI para converter linguagem natural em SQL e aprendeu sobre os prós e contras de implementar esse tipo de funcionalidade. No próximo exercício, você aprenderá como mensagens de email e SMS podem ser geradas usando o Azure OpenAI.

Próxima Etapa

IA: Gerando conclusões

Comentários

Esta página foi útil?

Last updated on 2025-06-13