IA: Lenguaje natural a SQL

La cita "Just because you can't mean you should" es una guía útil al pensar en las funcionalidades de inteligencia artificial. Por ejemplo, la característica lenguaje natural de Azure OpenAI a SQL permite a los usuarios realizar consultas de base de datos en inglés sin formato, lo que puede ser una herramienta eficaz para mejorar su productividad. Sin embargo, la potencia no siempre significa adecuada o segura. En este ejercicio se muestra cómo usar esta característica de IA, al tiempo que se describen consideraciones importantes que se deben tener en cuenta antes de decidir implementarla.

Este es un ejemplo de una consulta de lenguaje natural que se puede usar para recuperar datos de una base de datos:

Get the the total revenue for all companies in London.

Con las indicaciones adecuadas, Azure OpenAI convertirá esta consulta en SQL que se puede usar para devolver los resultados de la base de datos. Como resultado, los usuarios no técnicos, incluidos los analistas de negocios, los vendedores y los ejecutivos, pueden recuperar más fácilmente información valiosa de bases de datos sin lidiar con una sintaxis SQL compleja o confiar en las redes de datos y filtros restringidos. Este enfoque simplificado puede aumentar la productividad eliminando la necesidad de que los usuarios busquen asistencia de expertos técnicos.

En este ejercicio se proporciona un punto de partida que le ayudará a comprender cómo funciona el lenguaje natural a SQL, presentarle algunas consideraciones importantes, pensar en ventajas y desventajas y mostrar el código para empezar.

En este ejercicio, aprenderá a:

Use avisos de GPT para convertir lenguaje natural en SQL.
Experimente con diferentes avisos de GPT.
Use sql generado para consultar la base de datos postgreSQL iniciada anteriormente.
Devuelve los resultados de la consulta de PostgreSQL y los muestra en el explorador.

Comencemos experimentando con diferentes avisos gpT que se pueden usar para convertir lenguaje natural en SQL.

Uso de la característica Lenguaje natural a SQL

En el ejercicio anterior ha iniciado la base de datos, las API y la aplicación. También ha actualizado el .env archivo. Si no ha completado esos pasos, siga las instrucciones al final del ejercicio antes de continuar.
Vuelva al explorador (http://localhost:4200) y busque la sección Consulta personalizada de la página debajo de la datagrid. Observe que ya se incluye un valor de consulta de ejemplo: obtenga los ingresos totales de todos los pedidos. Agrupar por empresa e incluir la ciudad.
Seleccione el botón Ejecutar consulta . Esto pasará la consulta de lenguaje natural del usuario a Azure OpenAI que la convertirá en SQL. A continuación, la consulta SQL se usará para consultar la base de datos y devolver los posibles resultados.

Ejecute la siguiente consulta personalizada:

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

Vea la ventana de terminal que ejecuta el servidor de API en Visual Studio Code y observe que muestra la consulta SQL devuelta desde Azure OpenAI. Las API del lado servidor usan los datos JSON para consultar la base de datos postgreSQL. Los valores de cadena incluidos en la consulta se agregan como valores de parámetro para evitar ataques por inyección de código 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"] 
}
```
Vuelva al explorador y seleccione Restablecer datos para ver todos los clientes de nuevo en la datagrid.

Exploración del lenguaje natural en código SQL

Sugerencia

Si usa Visual Studio Code, puede abrir archivos directamente seleccionando:

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

A continuación, escriba el nombre del archivo que desea abrir.

Nota:

El objetivo de este ejercicio es mostrar lo que es posible con la funcionalidad de LENGUAJE natural a SQL y demostrar cómo empezar a usarlo. Como se mencionó anteriormente, es importante analizar si este tipo de inteligencia artificial es adecuado para su organización antes de continuar con cualquier implementación. También es imperativo planear las reglas de solicitud adecuadas y las medidas de seguridad de base de datos para evitar el acceso no autorizado y proteger los datos confidenciales.

Ahora que ha visto la característica de lenguaje natural a SQL en acción, vamos a examinar cómo se implementa.

Abra el archivo server/apiRoutes.ts y busque la generateSql ruta. La aplicación del lado cliente llama a esta ruta de API que se ejecuta en el explorador y se usa para generar SQL a partir de una consulta de lenguaje natural. Una vez recuperada la consulta SQL, se usa para consultar la base de datos y devolver 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 la funcionalidad siguiente en la generateSql ruta:

Recupera el valor de consulta de usuario de req.body.prompt y lo asigna a una variable denominada userPrompt. Este valor se usará en el símbolo del sistema GPT.
Llama a una getSQLFromNLP() función para convertir el lenguaje natural en SQL.
Pasa el CÓDIGO SQL generado a una función denominada queryDb que ejecuta la consulta SQL y devuelve los resultados de la base de datos.

Abra el archivo server/openAI.ts en el editor y busque la getSQLFromNLP() función. La ruta llama generatesql a esta función y se usa para convertir el lenguaje natural en 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;
}

Un userPrompt parámetro se pasa a la función . El userPrompt valor es la consulta de lenguaje natural escrita por el usuario en el explorador.
Un systemPrompt define el tipo de asistente de IA que se va a usar y las reglas que se deben seguir. Esto ayuda a Azure OpenAI a comprender la estructura de la base de datos, qué reglas aplicar y cómo devolver la consulta SQL generada y los parámetros.
Se llama a una función denominada callOpenAI() y los systemPrompt valores y userPrompt se le pasan.
Los resultados se comprueban para asegurarse de que no se incluyen valores prohibidos en la consulta SQL generada. Si se encuentran valores prohibidos, la consulta SQL se establece en una cadena vacía.

Veamos el símbolo del sistema con más detalle:

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"] 
  }
`;

Se define el tipo de asistente de IA que se va a usar. En este caso, un "lenguaje natural para el bot de SQL".
Se definen los nombres de tabla y las columnas de la base de datos. El esquema de alto nivel incluido en el símbolo del sistema se puede encontrar en el archivo server/db.schema y tiene el aspecto siguiente.
```
- 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)
```
Sugerencia

Puede considerar la posibilidad de crear vistas de solo lectura que solo contengan los datos que los usuarios pueden consultar mediante lenguaje natural a SQL.
Se define una regla para convertir los valores de cadena en un valor de consulta con parámetros para evitar ataques por inyección de código SQL.
Una regla se define para devolver siempre un objeto JSON con la consulta SQL y los valores de parámetro en él.
Se proporcionan mensajes de usuario de ejemplo y los valores de parámetro y consulta SQL esperados. Esto se conoce como aprendizaje de "pocos disparos". Aunque las MÁQUINAS VIRTUALES se entrenan en grandes cantidades de datos, se pueden adaptar a nuevas tareas con solo unos pocos ejemplos. Un enfoque alternativo es el aprendizaje de "disparo cero", donde no se proporciona ningún ejemplo y se espera que el modelo genere los valores de parámetro y consulta SQL correctos.

La getSQLFromNLP() función envía los mensajes del sistema y del usuario a una función denominada callOpenAI() que también se encuentra en el archivo server/openAI.ts . La función callOpenAI() determina si se debe invocar a la función de Azure OpenAI dentro de los modelos de Foundry o al servicio de OpenAI, comprobando las variables de entorno. Si hay una clave, un punto de conexión y un modelo disponibles en las variables de entorno, se llama a Azure OpenAI; de lo contrario, se llama a OpenAI.
```
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);
}
```
Nota:

Aunque nos centraremos en Azure OpenAI en este tutorial, si solo proporciona un OPENAI_API_KEY valor en el archivo .env , la aplicación usará OpenAI en su lugar. Si decide usar OpenAI en lugar de Azure OpenAI, puede ver resultados diferentes en algunos casos.
Busque la getAzureOpenAICompletion() función .
```
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 función hace lo siguiente:
- Parámetros:
  - systemPrompt, userPrompty temperature son los parámetros principales.
    - systemPrompt: informa al modelo de Azure OpenAI de su rol y de las reglas que se deben seguir.
    - userPrompt: contiene la información proporcionada por el usuario, como la entrada de lenguaje natural o las reglas para generar la salida.
    - temperature: dicta el nivel de creatividad de la respuesta del modelo. Un valor más alto da como resultado salidas más creativas, mientras que los valores más bajos (por ejemplo, 0) producen respuestas más deterministas.
- Generación de finalización:
  - La función llama a createAzureOpenAICompletion() con systemPrompt, userPrompty temperature para generar una finalización.
  - Extrae el contenido de la primera opción en la finalización, recortando cualquier espacio en blanco adicional.
  - Si el contenido contiene estructuras similares a JSON (indicadas por la presencia de { y }), extrae el contenido JSON.
- Registro y valor devuelto:
  - La función registra la salida de Azure OpenAI en la consola.
  - Devuelve el contenido procesado como una cadena.
Busque la createAzureOpenAICompletion() función .
```
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 función hace lo siguiente:
- Parámetros:
  - systemPrompt, userPrompty temperature son los parámetros principales descritos anteriormente.
  - Un parámetro opcional dataSources admite la característica "Azure Bring Your Own Data", que se tratará más adelante en este tutorial.
- Comprobación de variables de entorno:
  - La función comprueba la presencia de variables de entorno esenciales, lo que produce un error si falta alguno.
- Objeto de configuración:
  - Un config objeto se crea mediante valores del .env archivo (OPENAI_API_KEY, OPENAI_ENDPOINT, OPENAI_API_VERSION, OPENAI_MODEL). Estos valores se usan para construir la dirección URL para llamar a Azure OpenAI.
- Instancia de AzureOpenAI:
  - Se crea una instancia de AzureOpenAI mediante el objeto config. El AzureOpenAI símbolo forma parte del openai paquete, que se debe importar en la parte superior del archivo.
- Generación de una finalización:
  - Se llama a la chat.completions.create() función con las siguientes propiedades:
    - model: especifica el modelo GPT (por ejemplo, gpt-4o, gpt-3.5-turbo) tal como se define en el .env archivo.
    - max_tokens: define el número máximo de tokens para la finalización.
    - temperature: establece la temperatura de muestreo. Los valores más altos (por ejemplo, 0,9) producen respuestas más creativas, mientras que los valores más bajos (por ejemplo, 0) producen respuestas más deterministas.
    - response_format: define el formato de respuesta. Aquí, se establece para devolver un objeto JSON. Puede encontrar más detalles sobre el modo JSON en la documentación de referencia de Azure OpenAI.
    - messages: contiene los mensajes para generar finalizaciones de chat. En este ejemplo se incluyen dos mensajes: uno del sistema (definir el comportamiento y las reglas) y otro del usuario (que contiene el texto del mensaje).
- Valor devuelto:
  - La función devuelve el objeto de finalización generado por Azure OpenAI.

Comente las líneas siguientes de la getSQLFromNLP() función:

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

Guarde openAI.ts. El servidor de API recompilará automáticamente el código typeScript y reiniciará el servidor.
Vuelva al explorador y escriba Seleccionar todos los nombres de tabla de la base de datos en la entrada Consulta personalizada . Seleccione Ejecutar consulta. ¿Se muestran los nombres de tabla?
Vuelva a la getSQLFromNLP() función en el servidor o openAI.ts y agregue la siguiente regla a la Rules: sección del símbolo del sistema y, a continuación, guarde el archivo.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Vuelva al explorador y realice las siguientes tareas:
- Escriba Seleccionar todos los nombres de tabla de la base de datos en la entrada Consulta personalizada . Seleccione Ejecutar consulta. ¿Se muestran los nombres de tabla?
- Escriba Seleccionar todos los nombres de función de la base de datos. En la entrada Consulta personalizada y vuelva a seleccionar Ejecutar consulta . ¿Se muestran los nombres de función?
PREGUNTA: ¿Un modelo siempre seguirá las reglas que defina en el mensaje?

RESPUESTA: ¡No! Es importante tener en cuenta que los modelos de OpenAI pueden devolver resultados inesperados en ocasiones que no coincidan con las reglas que haya definido. Es importante planearlo en el código.
Vuelva al servidor o openAI.ts y busque la isProhibitedQuery() función. Este es un ejemplo de código posterior al procesamiento que se puede ejecutar después de que Azure OpenAI devuelva resultados. Observe que establece la sql propiedad en una cadena vacía si se devuelven palabras clave prohibidas en la consulta SQL generada. Esto garantiza que, si se devuelven resultados inesperados desde Azure OpenAI, la consulta SQL no se ejecutará en la base de datos.
```
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));
}
```
Nota:

Es importante tener en cuenta que esto es solo código de demostración. Puede haber otras palabras clave prohibidas necesarias para cubrir los casos de uso específicos si decide convertir lenguaje natural a SQL. Se trata de una característica que debe planear y usar con cuidado para asegurarse de que solo se devuelven y ejecutan consultas SQL válidas en la base de datos. Además de las palabras clave prohibidas, también tendrá que tener en cuenta la seguridad.
Vuelva al servidor o openAI.ts y quite la marca de comentario del código siguiente en la getSQLFromNLP() función . Guarde el archivo.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Quite la siguiente regla de systemPrompt y guarde el archivo.

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

Vuelva al explorador, escriba Seleccionar todos los nombres de tabla de la base de datos en la entrada Consulta personalizada de nuevo y seleccione el botón Ejecutar consulta .
¿Se muestran los resultados de la tabla? Incluso sin la regla en vigor, el isProhibitedQuery código posterior al procesamiento prohíbe que ese tipo de consulta se ejecute en la base de datos.
Como se ha explicado anteriormente, la integración del lenguaje natural en SQL en aplicaciones de línea de negocio puede ser bastante beneficiosa para los usuarios, pero viene con su propio conjunto de consideraciones.

Ventajas:
- Facilidad de uso: esta característica puede hacer que la interacción de la base de datos sea más accesible para los usuarios sin conocimientos técnicos, lo que reduce la necesidad de conocimientos de SQL y puede acelerar las operaciones.
- Mayor productividad: los analistas de negocios, los vendedores, los ejecutivos y otros usuarios no técnicos pueden recuperar información valiosa de las bases de datos sin tener que confiar en expertos técnicos, lo que aumenta la eficacia.
- Aplicación amplia: mediante el uso de modelos de lenguaje avanzados, las aplicaciones se pueden diseñar para satisfacer una amplia gama de usuarios y casos de uso.
Consideraciones:
- Seguridad: una de las mayores preocupaciones es la seguridad. Si los usuarios pueden interactuar con bases de datos mediante lenguaje natural, debe haber medidas de seguridad sólidas para evitar el acceso no autorizado o las consultas malintencionadas. Puede considerar la posibilidad de implementar un modo de solo lectura para evitar que los usuarios modifiquen los datos.
- Privacidad de los datos: es posible que ciertos datos sean confidenciales y no deben ser fácilmente accesibles, por lo que deberá asegurarse de que están en vigor las medidas de seguridad adecuadas y los permisos de usuario.
- Precisión: aunque el procesamiento del lenguaje natural ha mejorado significativamente, no es perfecto. La interpretación incorrecta de las consultas de usuario podría provocar resultados inexactos o un comportamiento inesperado. Deberá planear la forma en que se controlarán los resultados inesperados.
- Eficiencia: no hay ninguna garantía de que el CÓDIGO SQL devuelto desde una consulta de lenguaje natural sea eficaz. En algunos casos, es posible que se requieran llamadas adicionales a Azure OpenAI si las reglas posteriores al procesamiento detectan problemas con las consultas SQL.
- Entrenamiento y adaptación del usuario: los usuarios deben entrenarse para formular correctamente sus consultas. Aunque es más fácil que aprender SQL, todavía puede haber una curva de aprendizaje implicada.
Algunos puntos finales que se deben tener en cuenta antes de pasar al siguiente ejercicio:
- Recuerde que aquí se aplica "Just because you can't mean you should" (Solo porque no se puede decir que deberías) aquí. Use precaución extrema y planificación cuidadosa antes de integrar el lenguaje natural en SQL en una aplicación. Es importante comprender los posibles riesgos y planearlos.
- Antes de usar este tipo de tecnología, analice posibles escenarios con su equipo, administradores de bases de datos, equipo de seguridad, partes interesadas y cualquier otra parte pertinente para asegurarse de que es adecuado para su organización. Es importante analizar si el lenguaje natural para SQL cumple los requisitos de seguridad, privacidad y cualquier otro requisito que pueda tener su organización.
- La seguridad debe ser una preocupación principal e integrada en el proceso de planeación, desarrollo e implementación.
- Aunque el lenguaje natural para SQL puede ser muy eficaz, la planeación cuidadosa debe ir a ella para asegurarse de que las indicaciones tienen reglas necesarias y que se incluye la funcionalidad posterior al procesamiento. Planee tiempo adicional para implementar y probar este tipo de funcionalidad y tener en cuenta escenarios en los que se devuelven resultados inesperados.
- Con Azure OpenAI, los clientes obtienen las funcionalidades de seguridad de Microsoft Azure mientras ejecutan los mismos modelos que OpenAI. Azure OpenAI ofrece redes privadas, disponibilidad regional y filtrado de contenido de IA responsable. Obtenga más información sobre los datos, la privacidad y la seguridad de Azure OpenAI.
Ahora ha visto cómo usar Azure OpenAI para convertir lenguaje natural en SQL y ha aprendido sobre las ventajas y desventajas de implementar este tipo de funcionalidad. En el ejercicio siguiente, aprenderá cómo se pueden generar mensajes de correo electrónico y SMS mediante Azure OpenAI.

Paso siguiente

IA: Generación de finalizaciones

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-06-17