AI: Linguagem Natural para SQL

2025-06-13

A citação "Só porque você pode não significa que deveria" é um guia útil quando se pensa em recursos de IA. Por exemplo, o recurso de linguagem natural para SQL do Azure OpenAI permite que os usuários façam consultas de 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 ter em mente 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 sintaxe SQL intrincada ou depender de grades de dados e filtros restritos. Essa abordagem simplificada pode aumentar a produtividade, eliminando a necessidade de os usuários procurarem assistência de especialistas técnicos.

Este exercício fornece um ponto de partida que irá ajudá-lo a entender como a linguagem natural para SQL funciona, apresentá-lo a algumas considerações importantes, levá-lo a pensar sobre prós e contras e mostrar-lhe o código para começar.

Neste exercício, você irá:

Use prompts GPT para converter linguagem natural em SQL.
Experimente diferentes prompts GPT.
Use o SQL gerado para consultar o banco de dados PostgreSQL iniciado anteriormente.
Retornar resultados de consulta do PostgreSQL e exibi-los 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 grade de dados. Observe que um valor de consulta de exemplo já está incluído: Obtenha a receita total para todos os pedidos. Grupo 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á então usada para consultar o banco de dados e retornar quaisquer resultados potenciais.

Execute a seguinte consulta personalizada:

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

Exiba a janela do terminal que executa o servidor de API no Visual Studio Code e observe que ele 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 visualizar todos os clientes novamente na grade de dados.

Explorando a linguagem natural para o código SQL

Sugestão

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 rápidas adequadas e medidas de segurança de banco de dados para evitar 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 server/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 GPT.
Ele chama uma função para converter linguagem getSQLFromNLP() natural para 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 server/openAI.ts em seu editor e localize a getSQLFromNLP() função. Esta 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 em 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 valores e systemPrompt são passados userPrompt 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 percorrer 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)
```
Sugestão

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 nela.
Exemplos de prompts do usuário e a consulta SQL esperada e os valores de parâmetro são fornecidos. Isso é conhecido como aprendizagem de "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 é a aprendizagem "zero-shot", onde nenhum exemplo é fornecido e espera-se que o modelo gere a consulta SQL correta e os valores de parâmetro.

A getSQLFromNLP() função envia o sistema e os prompts do usuário para uma função chamada callOpenAI() que também está localizada no arquivo server/openAI.ts . A função callOpenAI() determina, através da verificação das variáveis de ambiente, se deve chamar o Azure OpenAI nos Modelos de Fundição ou o serviço OpenAI. Se uma chave, ponto de extremidade e modelo estiverem disponíveis nas variáveis de ambiente, o Azure OpenAI 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á o OpenAI em vez disso. 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;
}
```
Esta função faz o seguinte:
- Parâmetros:
  - systemPrompt, userPrompte temperature são os principais parâmetros.
    - systemPrompt: Informa o modelo OpenAI do Azure sobre o seu papel e as regras a seguir.
    - userPrompt: Contém as informações fornecidas pelo usuário, como entrada em 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 resultados mais criativos, enquanto valores mais baixos (por exemplo, 0) produzem respostas mais deterministas.
- Geração de conclusão:
  - A função chama createAzureOpenAICompletion() com systemPrompt, userPrompte 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 extrai o conteúdo JSON.
- Valor de registro e retorno:
  - A função registra a saída do Azure OpenAI 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.`);
        }
    }
}
```
Esta 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 mais adiante neste tutorial.
- Verificação de variáveis de ambiente:
  - A função verifica a presença de variáveis de ambiente essenciais, lançando um erro se alguma estiver faltando.
- Objeto de configuração:
  - 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 config objeto. O AzureOpenAI símbolo faz parte do openai pacote, que deve ser importado na parte superior do 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 no seu .env ficheiro.
    - 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 de resposta. Aqui, ele é 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 a conclusão do chat. Este exemplo inclui duas mensagens: uma do sistema (definindo comportamento e regras) e outra do usuário (contendo o texto do prompt).
- Valor de retorno:
  - A função retorna o objeto de conclusão gerado pelo Azure OpenAI.

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

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

Salve openAI.ts. O servidor de API reconstruirá automaticamente o código TypeScript e reiniciará o servidor.
Volte para o navegador e digite 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 em server/openAI.ts e adicione a seguinte regra na seção do prompt do sistema e, em Rules: seguida, salve o arquivo.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Volte ao 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?
- Digite Selecione todos os nomes de funções 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 notar que os modelos OpenAI podem retornar resultados inesperados em ocasiões 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 notar 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 para 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 de palavras-chave proibidas, você também precisará levar em conta a segurança.
Volte para server/openAI.ts e descomente o seguinte código na getSQLFromNLP() função. Salve o arquivo.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Remova a seguinte regra e systemPrompt salve o arquivo.

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

Volte para o navegador, digite Selecionar todos os nomes de tabela do banco de dados na entrada Consulta personalizada novamente e selecione o botão Executar consulta .
Os resultados de alguma tabela são exibidos? 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.
Como discutido anteriormente, a integração de 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 do banco de dados mais acessível para usuários sem conhecimento técnico, reduzindo a necessidade de conhecimento SQL e potencialmente acelerando as operações.
- Aumento da 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 ter que confiar em especialistas técnicos, aumentando assim a eficiência.
- Aplicação ampla: 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, precisa haver medidas de segurança robustas em vigor 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 proteções adequadas e permissões de usuário estejam em vigor.
- Precisão: Embora o processamento de linguagem natural tenha melhorado significativamente, 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 detetarem 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 considerar antes de passar para o próximo exercício:
- Lembre-se de que "Só porque você pode não significa que deve" se aplica aqui. Tenha muito cuidado e planejamento cuidadoso antes de integrar linguagem natural ao SQL em um aplicativo. É importante compreender os riscos potenciais e planeá-los.
- Antes de usar esse tipo de tecnologia, discuta cenários potenciais com sua equipe, administradores de banco de dados, equipe de segurança, partes interessadas e quaisquer outras partes relevantes para garantir que ela seja apropriada para sua organização. É importante discutir se a linguagem natural para SQL atende à segurança, privacidade e quaisquer outros requisitos que sua organização possa ter em vigor.
- A segurança deve ser uma preocupação primordial e incorporada no 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 regras necessárias e que a funcionalidade de pós-processamento esteja incluída. Planeje tempo adicional para implementar e testar esse tipo de funcionalidade e para levar em conta cenários em que resultados inesperados são retornados.
- Com o Azure OpenAI, os clientes obtêm os recursos de segurança do Microsoft Azure enquanto executam os mesmos modelos do OpenAI. O Azure OpenAI oferece rede privada, disponibilidade regional e filtragem responsável de conteúdo de IA. 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 da implementação desse tipo de funcionalidade. No próximo exercício, você aprenderá como as mensagens de email e SMS podem ser geradas usando o Azure OpenAI.

Próximo Passo

AI: Gerando conclusões

Partilhar via

AI: Linguagem Natural para SQL

Usando o recurso de linguagem natural para SQL

Explorando a linguagem natural para o código SQL

Próximo Passo

Comentários

Recursos adicionais