AI: Natuurlijke taal naar SQL

2025-06-13

De aanhalingsteken 'Alleen omdat u niet kunt betekenen dat u moet' is een handige handleiding bij het nadenken over AI-mogelijkheden. Met de natuurlijke taal van Azure OpenAI voor SQL-functies kunnen gebruikers bijvoorbeeld databasequery's in eenvoudig Engels maken. Dit kan een krachtig hulpprogramma zijn om hun productiviteit te verbeteren. Krachtig betekent echter niet altijd passend of veilig. In deze oefening wordt gedemonstreert hoe u deze AI-functie kunt gebruiken, terwijl u ook belangrijke overwegingen bespreekt waarmee u rekening moet houden voordat u besluit deze te implementeren.

Hier volgt een voorbeeld van een query in natuurlijke taal die kan worden gebruikt om gegevens op te halen uit een database:

Get the the total revenue for all companies in London.

Met de juiste prompts converteert Azure OpenAI deze query naar SQL die kan worden gebruikt om resultaten van de database te retourneren. Als gevolg hiervan kunnen niet-technische gebruikers, waaronder bedrijfsanalisten, marketeers en leidinggevenden, gemakkelijker waardevolle informatie ophalen uit databases zonder te grapplen met ingewikkelde SQL-syntaxis of afhankelijk te zijn van beperkte datagrids en filters. Deze gestroomlijnde aanpak kan de productiviteit verhogen door de noodzaak voor gebruikers om hulp te vragen van technische experts weg te nemen.

Deze oefening biedt een beginpunt waarmee u begrijpt hoe natuurlijke taal voor SQL werkt, u een aantal belangrijke overwegingen maakt, nadelen en voor- en nadelen overweegt en u de code laat zien om aan de slag te gaan.

In deze oefening gaat u het volgende doen:

Gebruik GPT-prompts om natuurlijke taal te converteren naar SQL.
Experimenteer met verschillende GPT-prompts.
Gebruik de gegenereerde SQL om een query uit te voeren op de PostgreSQL-database die eerder is gestart.
Retourneer queryresultaten van PostgreSQL en geef deze weer in de browser.

Laten we beginnen met het experimenteren met verschillende GPT-prompts die kunnen worden gebruikt om natuurlijke taal te converteren naar SQL.

De functie Natuurlijke taal gebruiken voor SQL

In de vorige oefening hebt u de database, API's en toepassing gestart. U hebt het .env bestand ook bijgewerkt. Als u deze stappen niet hebt voltooid, volgt u de instructies aan het einde van de oefening voordat u doorgaat.
Ga terug naar de browser (http://localhost:4200) en zoek de sectie Aangepaste query van de pagina onder de datagrid. U ziet dat er al een voorbeeldquerywaarde is opgenomen: Haal de totale omzet voor alle orders op. Groeperen op bedrijf en de stad opnemen.
Selecteer de knop Query uitvoeren . Hiermee wordt de query in natuurlijke taal van de gebruiker doorgegeven aan Azure OpenAI, waardoor deze wordt geconverteerd naar SQL. De SQL-query wordt vervolgens gebruikt om een query uit te voeren op de database en mogelijke resultaten te retourneren.

Voer de volgende aangepaste query uit:

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

Bekijk het terminalvenster met de API-server in Visual Studio Code en u ziet dat de SQL-query wordt weergegeven die is geretourneerd vanuit Azure OpenAI. De JSON-gegevens worden gebruikt door de API's aan de serverzijde om een query uit te voeren op de PostgreSQL-database. Tekenreekswaarden die zijn opgenomen in de query, worden toegevoegd als parameterwaarden om SQL-injectieaanvallen te voorkomen:
```
{ 
    "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"] 
}
```
Ga terug naar de browser en selecteer Gegevens opnieuw instellen om alle klanten opnieuw weer te geven in datagrid.

De natuurlijke taal verkennen naar SQL-code

Aanbeveling

Als u Visual Studio Code gebruikt, kunt u bestanden rechtstreeks openen door het volgende te selecteren:

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

Typ vervolgens de naam van het bestand dat u wilt openen.

Opmerking

Het doel van deze oefening is om te laten zien wat er mogelijk is met natuurlijke taal voor SQL-functionaliteit en hoe u aan de slag kunt gaan. Zoals eerder vermeld, is het belangrijk om te bespreken of dit type AI geschikt is voor uw organisatie voordat u doorgaat met een implementatie. Het is ook noodzakelijk om de juiste promptregels en databasebeveiligingsmaatregelen te plannen om onbevoegde toegang te voorkomen en gevoelige gegevens te beschermen.

Nu u de natuurlijke taal voor SQL-functie in actie hebt gezien, gaan we kijken hoe deze wordt geïmplementeerd.

Open het server-/apiRoutes.ts-bestand en zoek de generateSql route. Deze API-route wordt aangeroepen door de clienttoepassing die wordt uitgevoerd in de browser en wordt gebruikt om SQL te genereren op basis van een query in natuurlijke taal. Zodra de SQL-query is opgehaald, wordt deze gebruikt om een query uit te voeren op de database en resultaten te retourneren.

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

Let op de volgende functionaliteit in de generateSql route:

De querywaarde van de gebruiker wordt req.body.prompt opgehaald en toegewezen aan een variabele met de naam userPrompt. Deze waarde wordt gebruikt in de GPT-prompt.
Er wordt een getSQLFromNLP() functie aangeroepen om natuurlijke taal te converteren naar SQL.
De gegenereerde SQL wordt doorgegeven aan een functie die queryDb de SQL-query uitvoert en resultaten van de database retourneert.

Open het server-/openAI.ts-bestand in uw editor en zoek de getSQLFromNLP() functie. Deze functie wordt aangeroepen door de generatesql route en wordt gebruikt om natuurlijke taal te converteren naar 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;
}

Er wordt een userPrompt parameter doorgegeven aan de functie. De userPrompt waarde is de query in natuurlijke taal die is ingevoerd door de gebruiker in de browser.
A systemPrompt definieert het type AI-assistent dat moet worden gebruikt en regels die moeten worden gevolgd. Dit helpt Azure OpenAI inzicht te hebben in de databasestructuur, welke regels moeten worden toegepast en hoe u de gegenereerde SQL-query en -parameters kunt retourneren.
Een benoemde callOpenAI() functie wordt aangeroepen en de systemPrompt waarden userPrompt worden eraan doorgegeven.
De resultaten worden gecontroleerd om ervoor te zorgen dat er geen verboden waarden worden opgenomen in de gegenereerde SQL-query. Als er verboden waarden worden gevonden, wordt de SQL-query ingesteld op een lege tekenreeks.

Laten we de systeemprompt nader bekijken:

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

Het type AI-assistent dat moet worden gebruikt, wordt gedefinieerd. In dit geval een 'natuurlijke taal voor SQL-bot'.
Tabelnamen en kolommen in de database worden gedefinieerd. Het schema op hoog niveau dat in de prompt is opgenomen, vindt u in het bestand server/db.schema en ziet er als volgt uit.
```
- 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)
```
Aanbeveling

U kunt overwegen om alleen-lezenweergaven te maken die alleen de gegevens bevatten die gebruikers mogen opvragen met natuurlijke taal in SQL.
Er wordt een regel gedefinieerd om tekenreekswaarden te converteren naar een geparameteriseerde querywaarde om SQL-injectieaanvallen te voorkomen.
Er wordt een regel gedefinieerd om altijd een JSON-object te retourneren met de SQL-query en de parameterwaarden erin.
Voorbeeld van gebruikersprompts en de verwachte SQL-query- en parameterwaarden worden opgegeven. Dit wordt ' weinig-shot' leren genoemd. Hoewel LLM's worden getraind op grote hoeveelheden gegevens, kunnen ze met slechts enkele voorbeelden worden aangepast aan nieuwe taken. Een alternatieve benadering is 'zero-shot' waarbij geen voorbeeld wordt gegeven en het model naar verwachting de juiste SQL-query- en parameterwaarden genereert.

De getSQLFromNLP() functie verzendt het systeem en de gebruikersprompts naar een functie met de naam callOpenAI() die zich ook in het server-/openAI.ts-bestand bevindt. De callOpenAI() functie bepaalt of Azure OpenAI in Foundry Models of OpenAI-service moet worden aangeroepen door omgevingsvariabelen te controleren. Als er een sleutel, eindpunt en model beschikbaar zijn in de omgevingsvariabelen, wordt Azure OpenAI aangeroepen, anders wordt OpenAI aangeroepen.
```
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);
}
```
Opmerking

Hoewel we ons in deze zelfstudie richten op Azure OpenAI, wordt in plaats daarvan OpenAI gebruikt als u alleen een OPENAI_API_KEY waarde opgeeft in het .env-bestand . Als u ervoor kiest om OpenAI te gebruiken in plaats van Azure OpenAI, ziet u in sommige gevallen mogelijk andere resultaten.
Zoek de getAzureOpenAICompletion() functie.
```
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;
}
```
Deze functie doet het volgende:
- Parameters:
  - systemPrompt, userPrompten temperature zijn de belangrijkste parameters.
    - systemPrompt: informeert het Azure OpenAI-model over de rol en de regels die moeten worden gevolgd.
    - userPrompt: bevat de door de gebruiker verstrekte informatie, zoals invoer in natuurlijke taal of regels voor het genereren van de uitvoer.
    - temperature: Bepaalt het creativiteitsniveau van het antwoord van het model. Een hogere waarde resulteert in meer creatieve uitvoer, terwijl lagere waarden (bijvoorbeeld 0) meer deterministische antwoorden produceren.
- Voltooiingsgeneratie:
  - De functie roept createAzureOpenAICompletion() aan met systemPrompt, userPrompten temperature om een voltooiing te genereren.
  - Hiermee wordt de inhoud geëxtraheerd uit de eerste keuze in de voltooiing, waardoor eventuele extra witruimte wordt ingekort.
  - Als de inhoud JSON-achtige structuren bevat (aangegeven door de aanwezigheid van { en }), wordt de JSON-inhoud geëxtraheerd.
- Logboekregistratie en retourwaarde:
  - De functie registreert de Azure OpenAI-uitvoer naar de console.
  - Deze retourneert de verwerkte inhoud als een tekenreeks.
Zoek de createAzureOpenAICompletion() functie.
```
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.`);
        }
    }
}
```
Deze functie doet het volgende:
- Parameters:
  - systemPrompt, userPrompten temperature zijn de belangrijkste parameters die eerder zijn besproken.
  - Een optionele dataSources parameter ondersteunt de functie 'Azure Bring Your Own Data', die verderop in deze zelfstudie wordt behandeld.
- Controle van omgevingsvariabelen:
  - De functie controleert de aanwezigheid van essentiële omgevingsvariabelen, waardoor er een fout wordt gegenereerd als deze ontbreken.
- Configuratieobject:
  - Een config object wordt gemaakt met behulp van waarden uit het .env bestand (OPENAI_API_KEY, OPENAI_ENDPOINT, OPENAI_API_VERSION, ). OPENAI_MODEL Deze waarden worden gebruikt om de URL te maken voor het aanroepen van Azure OpenAI.
- AzureOpenAI-exemplaar:
  - Er wordt een exemplaar gemaakt met behulp van AzureOpenAI het config object. Het AzureOpenAI symbool maakt deel uit van het openai pakket, dat boven aan het bestand moet worden geïmporteerd.
- Een voltooiing genereren:
  - De chat.completions.create() functie wordt aangeroepen met de volgende eigenschappen:
    - model: Hiermee geeft u het GPT-model (bijvoorbeeld gpt-4o, gpt-3.5-turbo) zoals gedefinieerd in uw .env bestand.
    - max_tokens: Hiermee definieert u het maximum aantal tokens voor de voltooiing.
    - temperature: Hiermee stelt u de monsternametemperatuur in. Hogere waarden (bijvoorbeeld 0,9) leveren meer creatieve reacties op, terwijl lagere waarden (bijvoorbeeld 0) meer deterministische antwoorden produceren.
    - response_format: Definieert de antwoordindeling. Hier is het ingesteld om een JSON-object te retourneren. Meer informatie over de JSON-modus vindt u in de referentiedocumentatie van Azure OpenAI.
    - messages: Bevat de berichten voor het genereren van chatvoltooiingen. Dit voorbeeld bevat twee berichten: één van het systeem (gedrag en regels definiëren) en één van de gebruiker (met de prompttekst).
- Retourwaarde:
  - De functie retourneert het voltooiingsobject dat is gegenereerd door Azure OpenAI.

Markeer de volgende regels in de getSQLFromNLP() functie als commentaar:

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

Sla openAI.ts op. De API-server bouwt automatisch de TypeScript-code opnieuw op en start de server opnieuw op.
Ga terug naar de browser en voer Alle tabelnamen uit de database selecteren in de invoer voor aangepaste query's in. Selecteer Query uitvoeren. Worden tabelnamen weergegeven?
Ga terug naar de getSQLFromNLP() functie in server/openAI.ts en voeg de volgende regel toe aan de Rules: sectie van de systeemprompt en sla het bestand vervolgens op.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Ga terug naar de browser en voer de volgende taken uit:
- Voer alle tabelnamen uit de database in in de invoer voor aangepaste query's . Selecteer Query uitvoeren. Worden tabelnamen weergegeven?
- Voer alle functienamen uit de database in. Voer de invoer van de aangepaste query in en selecteer Query uitvoeren opnieuw. Worden functienamen weergegeven?
VRAAG: Volgt een model altijd de regels die u in de prompt definieert?

ANTWOORD: Nee! Het is belangrijk te weten dat OpenAI-modellen onverwachte resultaten kunnen retourneren die mogelijk niet overeenkomen met de regels die u hebt gedefinieerd. Het is belangrijk om dat in uw code te plannen.
Ga terug naar de server/openAI.ts en zoek de isProhibitedQuery() functie. Dit is een voorbeeld van naverwerkingscode die kan worden uitgevoerd nadat Azure OpenAI resultaten retourneert. U ziet dat de sql eigenschap wordt ingesteld op een lege tekenreeks als verboden trefwoorden worden geretourneerd in de gegenereerde SQL-query. Dit zorgt ervoor dat als er onverwachte resultaten worden geretourneerd vanuit Azure OpenAI, de SQL-query niet wordt uitgevoerd op de database.
```
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));
}
```
Opmerking

Het is belangrijk om te weten dat dit alleen democode is. Er zijn mogelijk andere verboden trefwoorden vereist om uw specifieke gebruiksvoorbeelden te behandelen als u ervoor kiest om natuurlijke taal te converteren naar SQL. Dit is een functie die u met zorg moet plannen en gebruiken om ervoor te zorgen dat alleen geldige SQL-query's worden geretourneerd en uitgevoerd op de database. Naast verboden trefwoorden moet u ook rekening houden met beveiliging.
Ga terug naar de server/openAI.ts en verwijder de opmerkingen bij de volgende code in de getSQLFromNLP() functie. Sla het bestand op.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Verwijder de volgende regel uit systemPrompt en sla het bestand op.

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

Ga terug naar de browser, voer alle tabelnamen uit de database in de invoer voor aangepaste query's opnieuw in en selecteer de knop Query uitvoeren .
Worden er tabelresultaten weergegeven? Zelfs zonder dat de regel is ingesteld, verbiedt de isProhibitedQuery naverwerkingscode dat type query niet wordt uitgevoerd op de database.
Zoals eerder is besproken, kan het integreren van natuurlijke taal in Line-Of-Business-toepassingen voor SQL heel nuttig zijn voor gebruikers, maar het heeft wel een eigen set overwegingen.

Voordelen:
- Gebruiksvriendelijkheid: deze functie kan database-interactie toegankelijker maken voor gebruikers zonder technische expertise, waardoor de noodzaak van SQL-kennis en mogelijk snellere bewerkingen wordt verminderd.
- Verhoogde productiviteit: bedrijfsanalisten, marketeers, leidinggevenden en andere niet-technische gebruikers kunnen waardevolle informatie ophalen uit databases zonder dat ze op technische experts hoeven te vertrouwen, waardoor de efficiëntie toeneemt.
- Brede toepassing: Met behulp van geavanceerde taalmodellen kunnen toepassingen worden ontworpen voor een breed scala aan gebruikers en gebruiksvoorbeelden.
Overwegingen:
- Beveiliging: Een van de grootste problemen is beveiliging. Als gebruikers kunnen communiceren met databases met natuurlijke taal, moeten er robuuste beveiligingsmaatregelen zijn om onbevoegde toegang of schadelijke query's te voorkomen. U kunt overwegen om een modus alleen-lezen te implementeren om te voorkomen dat gebruikers gegevens wijzigen.
- Gegevensprivacy: bepaalde gegevens zijn mogelijk gevoelig en mogen niet gemakkelijk toegankelijk zijn, dus u moet ervoor zorgen dat de juiste beveiliging en gebruikersmachtigingen aanwezig zijn.
- Nauwkeurigheid: Hoewel de verwerking van natuurlijke taal aanzienlijk is verbeterd, is het niet perfect. Onjuiste interpretatie van gebruikersquery's kan leiden tot onjuiste resultaten of onverwacht gedrag. U moet plannen hoe onverwachte resultaten worden verwerkt.
- Efficiëntie: Er zijn geen garanties dat de SQL die wordt geretourneerd door een query in natuurlijke taal efficiënt is. In sommige gevallen zijn er mogelijk extra aanroepen naar Azure OpenAI vereist als naverwerkingsregels problemen met SQL-query's detecteren.
- Training en gebruikersaanpassing: Gebruikers moeten worden getraind om hun query's correct te formuleren. Hoewel het eenvoudiger is dan het leren van SQL, kan er nog steeds een leercurve worden gebruikt.
Enkele laatste punten die u moet overwegen voordat u verdergaat met de volgende oefening:
- Houd er rekening mee dat 'Alleen omdat je niet kunt betekenen dat je moet' hier van toepassing is. Wees uiterst voorzichtig en zorgvuldig bij het plannen voordat u natuurlijke taal integreert in SQL in een toepassing. Het is belangrijk om inzicht te krijgen in de potentiële risico's en deze te plannen.
- Voordat u dit type technologie gebruikt, moet u mogelijke scenario's bespreken met uw team, databasebeheerders, beveiligingsteam, belanghebbenden en andere relevante partijen om ervoor te zorgen dat deze geschikt zijn voor uw organisatie. Het is belangrijk om te bespreken of natuurlijke taal voor SQL voldoet aan de vereisten voor beveiliging, privacy en eventuele andere vereisten die uw organisatie mogelijk heeft.
- Beveiliging moet een belangrijk aandachtspunt zijn en ingebouwd zijn in het plannings-, ontwikkelings- en implementatieproces.
- Hoewel natuurlijke taal voor SQL zeer krachtig kan zijn, moet er zorgvuldige planning in worden geplaatst om ervoor te zorgen dat prompts vereiste regels hebben en dat de functionaliteit voor naverwerking is opgenomen. Plan extra tijd om dit type functionaliteit te implementeren en te testen en om rekening te houden met scenario's waarin onverwachte resultaten worden geretourneerd.
- Met Azure OpenAI krijgen klanten de beveiligingsmogelijkheden van Microsoft Azure terwijl ze dezelfde modellen uitvoeren als OpenAI. Azure OpenAI biedt privénetwerken, regionale beschikbaarheid en verantwoordelijke AI-inhoudsfiltering. Meer informatie over gegevens, privacy en beveiliging voor Azure OpenAI.
U hebt nu gezien hoe u Azure OpenAI kunt gebruiken om natuurlijke taal te converteren naar SQL en meer te leren over de voor- en nadelen van het implementeren van dit type functionaliteit. In de volgende oefening leert u hoe e-mail- en sms-berichten kunnen worden gegenereerd met behulp van Azure OpenAI.

Volgende stap

AI: Het genereren van voltooiingen

Delen via

AI: Natuurlijke taal naar SQL

De functie Natuurlijke taal gebruiken voor SQL

De natuurlijke taal verkennen naar SQL-code

Volgende stap

Feedback

Aanvullende resources