IA : Langage naturel vers SQL

2025-06-13

La citation « Juste parce que vous ne pouvez pas signifier que vous devez » est un guide utile lors de la réflexion sur les fonctionnalités d’IA. Par exemple, la fonctionnalité de langage naturel d’Azure OpenAI pour SQL permet aux utilisateurs d’effectuer des requêtes de base de données en anglais brut, qui peuvent être un outil puissant pour améliorer leur productivité. Toutefois, puissant ne signifie pas toujours approprié ou sûr. Cet exercice montre comment utiliser cette fonctionnalité IA tout en discutant des considérations importantes à prendre en compte avant de décider de l’implémenter.

Voici un exemple de requête en langage naturel qui peut être utilisée pour récupérer des données à partir d’une base de données :

Get the the total revenue for all companies in London.

Avec les invites appropriées, Azure OpenAI convertit cette requête en SQL qui peut être utilisée pour retourner les résultats de la base de données. Par conséquent, les utilisateurs non techniques, y compris les analystes d’entreprise, les spécialistes du marketing et les cadres, peuvent récupérer plus facilement des informations précieuses à partir de bases de données sans grappler avec une syntaxe SQL complexe ou s’appuyer sur des datagrids et des filtres limités. Cette approche simplifiée peut améliorer la productivité en éliminant la nécessité pour les utilisateurs de demander de l’aide à des experts techniques.

Cet exercice fournit un point de départ qui vous aidera à comprendre comment fonctionne le langage naturel pour SQL, vous présenter quelques considérations importantes, vous aider à réfléchir aux avantages et inconvénients, et à vous montrer le code pour commencer.

Dans cet exercice, vous allez :

Utilisez des invites GPT pour convertir le langage naturel en LANGAGE SQL.
Expérimentez des invites GPT différentes.
Utilisez le sql généré pour interroger la base de données PostgreSQL démarrée précédemment.
Retournez les résultats de la requête à partir de PostgreSQL et affichez-les dans le navigateur.

Commençons par expérimenter différentes invites GPT qui peuvent être utilisées pour convertir le langage naturel en SQL.

Utilisation de la fonctionnalité Langage naturel vers SQL

Dans l’exercice précédent, vous avez démarré la base de données, les API et l’application. Vous avez également mis à jour le .env fichier. Si vous n’avez pas effectué ces étapes, suivez les instructions à la fin de l’exercice avant de continuer.
Revenez au navigateur (http://localhost:4200) et recherchez la section Requête personnalisée de la page sous la grille de données. Notez qu’un exemple de valeur de requête est déjà inclus : obtenez le chiffre d’affaires total de toutes les commandes. Regrouper par entreprise et inclure la ville.
Sélectionnez le bouton Exécuter la requête . Cela transmet la requête en langage naturel de l’utilisateur à Azure OpenAI, qui la convertit en SQL. La requête SQL sera ensuite utilisée pour interroger la base de données et retourner les résultats potentiels.

Exécutez la requête personnalisée suivante :

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

Affichez la fenêtre de terminal exécutant le serveur d’API dans Visual Studio Code et notez qu’elle affiche la requête SQL retournée par Azure OpenAI. Les données JSON sont utilisées par les API côté serveur pour interroger la base de données PostgreSQL. Toutes les valeurs de chaîne incluses dans la requête sont ajoutées en tant que valeurs de paramètre pour empêcher les attaques par injection 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"] 
}
```
Revenez au navigateur et sélectionnez Réinitialiser les données pour afficher à nouveau tous les clients dans le datagrid.

Exploration du langage naturel vers le code SQL

Conseil / Astuce

Si vous utilisez Visual Studio Code, vous pouvez ouvrir des fichiers directement en sélectionnant :

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

Tapez ensuite le nom du fichier que vous souhaitez ouvrir.

Remarque

L’objectif de cet exercice est de montrer ce qui est possible avec le langage naturel avec les fonctionnalités SQL et de montrer comment commencer à l’utiliser. Comme mentionné précédemment, il est important de discuter si ce type d’IA est approprié pour votre organisation avant de poursuivre toute implémentation. Il est également impératif de planifier les règles d’invite appropriées et les mesures de sécurité de base de données pour empêcher l’accès non autorisé et protéger les données sensibles.

Maintenant que vous avez vu la fonctionnalité de langage naturel vers SQL en action, examinons comment elle est implémentée.
Ouvrez le fichier serveur/apiRoutes.ts et recherchez l’itinéraire generateSql . Cet itinéraire d’API est appelé par l’application côté client s’exécutant dans le navigateur et utilisée pour générer SQL à partir d’une requête en langage naturel. Une fois la requête SQL récupérée, elle est utilisée pour interroger la base de données et retourner les résultats.
```
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.' });
    }
});
```
Notez les fonctionnalités suivantes dans l’itinéraire generateSql :
- Il récupère la valeur de requête de l’utilisateur et req.body.prompt l’affecte à une variable nommée userPrompt. Cette valeur sera utilisée dans l’invite GPT.
- Il appelle une fonction pour convertir le getSQLFromNLP() langage naturel en LANGAGE SQL.
- Il transmet le sql généré à une fonction nommée queryDb qui exécute la requête SQL et retourne les résultats de la base de données.

Ouvrez le fichier serveur/openAI.ts dans votre éditeur et recherchez la getSQLFromNLP() fonction. Cette fonction est appelée par l’itinéraire et est utilisée pour convertir le generatesql langage naturel en LANGAGE 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 paramètre est passé dans la fonction. La userPrompt valeur est la requête en langage naturel entrée par l’utilisateur dans le navigateur.
A systemPrompt définit le type d’assistant IA à utiliser et les règles qui doivent être suivies. Cela aide Azure OpenAI à comprendre la structure de base de données, les règles à appliquer et comment retourner la requête et les paramètres SQL générés.
Une fonction nommée callOpenAI() est appelée et les systemPromptuserPrompt valeurs sont passées à celui-ci.
Les résultats sont vérifiés pour vérifier qu’aucune valeur interdite n’est incluse dans la requête SQL générée. Si des valeurs interdites sont trouvées, la requête SQL est définie sur une chaîne vide.

Passons en détail à l’invite système :

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

Le type d’assistant IA à utiliser est défini. Dans ce cas, un « langage naturel vers un bot SQL ».
Les noms de tables et les colonnes de la base de données sont définis. Le schéma de haut niveau inclus dans l’invite se trouve dans le fichier serveur/db.schema et ressemble à ce qui suit.
```
- 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)
```
Conseil / Astuce

Vous pouvez envisager de créer des vues en lecture seule qui contiennent uniquement les données que les utilisateurs sont autorisés à interroger à l’aide du langage naturel vers SQL.
Une règle est définie pour convertir toutes les valeurs de chaîne en valeur de requête paramétrable pour éviter les attaques par injection SQL.
Une règle est définie pour toujours retourner un objet JSON avec la requête SQL et les valeurs de paramètre qu’elle contient.
Les exemples d’invites utilisateur et les valeurs de requête et de paramètre SQL attendues sont fournies. C’est ce qu’on appelle l’apprentissage « à quelques coups ». Bien que les modules LLM soient formés sur de grandes quantités de données, ils peuvent être adaptés aux nouvelles tâches avec seulement quelques exemples. Une autre approche consiste à apprendre « zero-shot » où aucun exemple n’est fourni et que le modèle est censé générer les valeurs correctes de requête et de paramètre SQL.

La getSQLFromNLP() fonction envoie le système et l’utilisateur invite à une fonction nommée callOpenAI() qui se trouve également dans le fichier serveur/openAI.ts . La callOpenAI() fonction détermine si Azure OpenAI dans les modèles Foundry ou le service OpenAI doit être appelé en vérifiant les variables d’environnement. Si une clé, un point de terminaison et un modèle sont disponibles dans les variables d’environnement, Azure OpenAI est appelé, sinon OpenAI est appelé.
```
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);
}
```
Remarque

Bien que nous nous concentrions sur Azure OpenAI tout au long de ce tutoriel, si vous fournissez uniquement une OPENAI_API_KEY valeur dans le fichier .env , l’application utilisera OpenAI à la place. Si vous choisissez d’utiliser OpenAI au lieu d’Azure OpenAI, vous pouvez voir des résultats différents dans certains cas.
Recherchez la getAzureOpenAICompletion() fonction.
```
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;
}
```
Cette fonction effectue les opérations suivantes :
- Paramètres :
  - systemPrompt, userPromptet temperature sont les principaux paramètres.
    - systemPrompt: informe le modèle Azure OpenAI de son rôle et des règles à suivre.
    - userPrompt: contient les informations fournies par l’utilisateur, telles que l’entrée ou les règles en langage naturel pour générer la sortie.
    - temperature: Dicte le niveau de créativité de la réponse du modèle. Une valeur plus élevée entraîne des sorties plus créatives, tandis que les valeurs inférieures (par exemple, 0) produisent des réponses plus déterministes.
- Génération d’achèvement :
  - Les appels createAzureOpenAICompletion() de fonction avec systemPrompt, userPromptet temperature pour générer une saisie semi-automatique.
  - Il extrait le contenu du premier choix dans la saisie semi-automatique, en rognant tout espace blanc supplémentaire.
  - Si le contenu contient des structures de type JSON (indiquées par la présence et {}), il extrait le contenu JSON.
- Valeur de journalisation et de retour :
  - La fonction enregistre la sortie Azure OpenAI dans la console.
  - Elle retourne le contenu traité sous forme de chaîne.
Recherchez la createAzureOpenAICompletion() fonction.
```
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.`);
        }
    }
}
```
Cette fonction effectue les opérations suivantes :
- Paramètres :
  - systemPrompt, userPromptet temperature sont les principaux paramètres abordés précédemment.
  - Un paramètre facultatif dataSources prend en charge la fonctionnalité « Azure Bring Your Own Data », qui sera abordée plus loin dans ce tutoriel.
- Vérification des variables d’environnement :
  - La fonction vérifie la présence de variables d’environnement essentielles, lève une erreur si elle est manquante.
- Objet configuration :
  - Un config objet est créé à l’aide de valeurs à partir du .env fichier (OPENAI_API_KEY, OPENAI_ENDPOINT, OPENAI_API_VERSION, OPENAI_MODEL). Ces valeurs sont utilisées pour construire l’URL pour appeler Azure OpenAI.
- Instance AzureOpenAI :
  - Une instance de AzureOpenAI est créée à l’aide de l’objet config. Le AzureOpenAI symbole fait partie du openai package, qui doit être importé en haut de votre fichier.
- Génération d’une saisie semi-automatique :
  - La chat.completions.create() fonction est appelée avec les propriétés suivantes :
    - model: spécifie le modèle GPT (par exemple, gpt-4o, gpt-3.5-turbo) tel que défini dans votre .env fichier.
    - max_tokens: définit le nombre maximal de jetons pour la saisie semi-automatique.
    - temperature: définit la température d’échantillonnage. Les valeurs plus élevées (par exemple, 0,9) produisent des réponses plus créatives, tandis que les valeurs inférieures (par exemple, 0) produisent des réponses plus déterministes.
    - response_format: définit le format de réponse. Ici, il est défini pour renvoyer un objet JSON. Vous trouverez plus d’informations sur le mode JSON dans la documentation de référence Azure OpenAI.
    - messages: contient les messages permettant de générer des achèvements de conversation. Cet exemple inclut deux messages : un du système (définition du comportement et des règles) et l’autre de l’utilisateur (contenant le texte de l’invite).
- Valeur de retour :
  - La fonction retourne l’objet d’achèvement généré par Azure OpenAI.

Commentez les lignes suivantes dans la getSQLFromNLP() fonction :

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

Enregistrez openAI.ts. Le serveur d’API régénère automatiquement le code TypeScript et redémarre le serveur.
Revenez au navigateur et entrez Sélectionner tous les noms de table de la base de données dans l’entrée requête personnalisée . Sélectionnez Exécuter la requête. Les noms de tables sont-ils affichés ?
Revenez à la getSQLFromNLP() fonction dans le serveur/openAI.ts et ajoutez la règle suivante dans la Rules: section de l’invite système, puis enregistrez le fichier.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Revenez au navigateur et effectuez les tâches suivantes :
- Entrez sélectionner tous les noms de table de la base de données dans l’entrée requête personnalisée . Sélectionnez Exécuter la requête. Les noms de tables sont-ils affichés ?
- Entrez tous les noms de fonction de la base de données. Dans l’entrée requête personnalisée , puis sélectionnez Réexécuter la requête . Les noms de fonction sont-ils affichés ?
Question : Un modèle suivra-t-il toujours les règles que vous définissez dans l’invite ?

RÉPONSE : Non ! Il est important de noter que les modèles OpenAI peuvent retourner des résultats inattendus à l’occasion qui ne correspondent pas aux règles que vous avez définies. Il est important de planifier cela dans votre code.
Revenez au serveur/openAI.ts et recherchez la isProhibitedQuery() fonction. Il s’agit d’un exemple de code post-traitement qui peut être exécuté une fois qu’Azure OpenAI retourne les résultats. Notez qu’elle définit la sql propriété sur une chaîne vide si des mots clés interdits sont retournés dans la requête SQL générée. Cela garantit que si des résultats inattendus sont retournés à partir d’Azure OpenAI, la requête SQL ne sera pas exécutée sur la base de données.
```
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));
}
```
Remarque

Il est important de noter qu’il s’agit uniquement du code de démonstration. Il peut y avoir d’autres mots clés interdits requis pour couvrir vos cas d’usage spécifiques si vous choisissez de convertir le langage naturel en SQL. Il s’agit d’une fonctionnalité que vous devez planifier et utiliser avec soin pour vous assurer que seules les requêtes SQL valides sont retournées et exécutées sur la base de données. Outre les mots clés interdits, vous devez également prendre en compte la sécurité.
Revenez au serveur/openAI.ts et supprimez les marques de commentaire du code suivant dans la getSQLFromNLP() fonction. Enregistrez le fichier.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Supprimez la règle suivante et systemPrompt enregistrez le fichier.

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

Revenez au navigateur, entrez Sélectionner tous les noms de table de la base de données dans l’entrée requête personnalisée à nouveau, puis sélectionnez le bouton Exécuter la requête .
Les résultats du tableau s’affichent-ils ? Même sans la règle en place, le isProhibitedQuery code de post-traitement interdit l’exécution de ce type de requête sur la base de données.
Comme indiqué précédemment, l’intégration du langage naturel à SQL dans les applications métier peut être très bénéfique pour les utilisateurs, mais elle est associée à son propre ensemble de considérations.

Avantages :
- Convivialité de l’utilisateur : cette fonctionnalité peut rendre l’interaction de base de données plus accessible aux utilisateurs sans expertise technique, ce qui réduit le besoin de connaissances SQL et accélère potentiellement les opérations.
- Productivité accrue : les analystes d’entreprise, les spécialistes du marketing, les cadres et d’autres utilisateurs non techniques peuvent récupérer des informations précieuses à partir de bases de données sans avoir à compter sur des experts techniques, ce qui augmente l’efficacité.
- Large application : à l’aide de modèles de langage avancés, les applications peuvent être conçues pour répondre à un large éventail d’utilisateurs et de cas d’usage.
Considérations :
- Sécurité : l’une des principales préoccupations est la sécurité. Si les utilisateurs peuvent interagir avec des bases de données à l’aide du langage naturel, il doit y avoir des mesures de sécurité robustes en place pour empêcher l’accès non autorisé ou les requêtes malveillantes. Vous pouvez envisager d’implémenter un mode en lecture seule pour empêcher les utilisateurs de modifier des données.
- Confidentialité des données : certaines données peuvent être sensibles et ne doivent pas être facilement accessibles. Vous devez donc vous assurer que les garanties appropriées et les autorisations utilisateur sont en place.
- Précision : Bien que le traitement du langage naturel ait considérablement amélioré, il n’est pas parfait. Une mauvaise interprétation des requêtes utilisateur peut entraîner des résultats incorrects ou un comportement inattendu. Vous devez planifier la façon dont les résultats inattendus seront gérés.
- Efficacité : il n’existe aucune garantie que le sql retourné à partir d’une requête en langage naturel soit efficace. Dans certains cas, des appels supplémentaires à Azure OpenAI peuvent être nécessaires si des règles de post-traitement détectent les problèmes liés aux requêtes SQL.
- Formation et adaptation des utilisateurs : les utilisateurs doivent être formés pour formuler correctement leurs requêtes. Bien qu’il soit plus facile que d’apprendre SQL, il peut toujours y avoir une courbe d’apprentissage impliquée.
Quelques points finaux à prendre en compte avant de passer à l’exercice suivant :
- N’oubliez pas que « Juste parce que vous ne pouvez pas dire que vous devez » s’applique ici. Utilisez une prudence extrême et une planification minutieuse avant d’intégrer le langage naturel à SQL dans une application. Il est important de comprendre les risques potentiels et de les planifier.
- Avant d’utiliser ce type de technologie, discutez des scénarios potentiels avec votre équipe, les administrateurs de base de données, l’équipe de sécurité, les parties prenantes et toutes les autres parties concernées pour vous assurer qu’elle est appropriée pour votre organisation. Il est important de discuter si le langage naturel de SQL répond à la sécurité, à la confidentialité et aux autres exigences que votre organisation peut avoir en place.
- La sécurité doit être une préoccupation principale et intégrée au processus de planification, de développement et de déploiement.
- Bien que le langage naturel de SQL puisse être très puissant, une planification minutieuse doit y accéder pour s’assurer que les invites ont des règles requises et que les fonctionnalités de post-traitement sont incluses. Planifiez le temps supplémentaire d’implémenter et de tester ce type de fonctionnalité et de tenir compte des scénarios où des résultats inattendus sont retournés.
- Avec Azure OpenAI, les clients bénéficient des fonctionnalités de sécurité de Microsoft Azure tout en exécutant les mêmes modèles qu’OpenAI. Azure OpenAI offre une mise en réseau privé, une disponibilité régionale et un filtrage de contenu d’IA responsable. En savoir plus sur les données, la confidentialité et la sécurité pour Azure OpenAI.
Vous avez maintenant vu comment utiliser Azure OpenAI pour convertir le langage naturel en LANGAGE SQL et découvrir les avantages et inconvénients de l’implémentation de ce type de fonctionnalité. Dans l’exercice suivant, vous allez découvrir comment les messages électroniques et SMS peuvent être générés à l’aide d’Azure OpenAI.

Étape suivante

IA : génération de complétions

Partager via

IA : Langage naturel vers SQL

Utilisation de la fonctionnalité Langage naturel vers SQL

Exploration du langage naturel vers le code SQL

Étape suivante

Commentaires

Ressources supplémentaires