AI: Bahasa Alami ke SQL

2025-06-13

Kutipan "Hanya karena Anda tidak dapat berarti Anda harus" adalah panduan yang berguna saat memikirkan kemampuan AI. Misalnya, fitur bahasa alami Azure OpenAI ke SQL memungkinkan pengguna membuat kueri database dalam bahasa Inggris biasa, yang dapat menjadi alat yang ampuh untuk meningkatkan produktivitas mereka. Namun, kuat tidak selalu berarti tepat atau aman. Latihan ini akan menunjukkan cara menggunakan fitur AI ini sambil juga membahas pertimbangan penting yang perlu diingat sebelum memutuskan untuk menerapkannya.

Berikut adalah contoh kueri bahasa alami yang dapat digunakan untuk mengambil data dari database:

Get the the total revenue for all companies in London.

Dengan perintah yang tepat, Azure OpenAI akan mengonversi kueri ini ke SQL yang dapat digunakan untuk mengembalikan hasil dari database. Akibatnya, pengguna non-teknis termasuk analis bisnis, pemasar, dan eksekutif dapat lebih mudah mengambil informasi berharga dari database tanpa bergulat dengan sintaks SQL yang rumit atau mengandalkan datagrid dan filter yang dibatasi. Pendekatan yang disederhanakan ini dapat meningkatkan produktivitas dengan menghilangkan kebutuhan pengguna untuk mencari bantuan dari pakar teknis.

Latihan ini menyediakan titik awal yang akan membantu Anda memahami cara kerja bahasa alami untuk SQL, memperkenalkan Anda pada beberapa pertimbangan penting, membuat Anda berpikir tentang pro dan kontra, dan menunjukkan kode untuk memulai.

Dalam latihan ini, Anda akan:

Gunakan perintah GPT untuk mengonversi bahasa alami ke SQL.
Bereksperimenlah dengan permintaan GPT yang berbeda.
Gunakan SQL yang dihasilkan untuk mengkueri database PostgreSQL yang dimulai sebelumnya.
Mengembalikan hasil kueri dari PostgreSQL dan menampilkannya di browser.

Mari kita mulai dengan bereksperimen dengan permintaan GPT berbeda yang dapat digunakan untuk mengonversi bahasa alami ke SQL.

Menggunakan Bahasa Alami untuk Fitur SQL

Dalam latihan sebelumnya , Anda memulai database, API, dan aplikasi. Anda juga memperbarui .env file. Jika Anda tidak menyelesaikan langkah-langkah tersebut, ikuti instruksi di akhir latihan sebelum melanjutkan.
Kembali ke browser (http://localhost:4200) dan temukan bagian Kueri Kustom dari halaman di bawah datagrid. Perhatikan bahwa nilai kueri sampel sudah disertakan: Dapatkan total pendapatan untuk semua pesanan. Kelompokkan menurut perusahaan dan sertakan kota.
Pilih tombol Jalankan Kueri . Ini akan meneruskan kueri bahasa alami pengguna ke Azure OpenAI yang akan mengonversinya ke SQL. Kueri SQL kemudian akan digunakan untuk mengkueri database dan mengembalikan hasil potensial apa pun.

Jalankan Kueri Kustom berikut ini:

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

Lihat jendela terminal yang menjalankan server API di Visual Studio Code dan perhatikan bahwa jendela tersebut menampilkan kueri SQL yang dikembalikan dari Azure OpenAI. Data JSON digunakan oleh API sisi server untuk mengkueri database PostgreSQL. Setiap nilai string yang disertakan dalam kueri ditambahkan sebagai nilai parameter untuk mencegah serangan injeksi 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"] 
}
```
Kembali ke browser dan pilih Reset Data untuk melihat semua pelanggan lagi di datagrid.

Menjelajahi Bahasa Alami ke Kode SQL

Petunjuk / Saran

Jika Anda menggunakan Visual Studio Code, Anda dapat membuka file secara langsung dengan memilih:

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

Kemudian ketik nama file yang ingin Anda buka.

Nota

Tujuan dari latihan ini adalah untuk menunjukkan apa yang mungkin dengan bahasa alami untuk fungsionalitas SQL dan menunjukkan cara mulai menggunakannya. Seperti disebutkan sebelumnya, penting untuk membahas apakah jenis AI ini sesuai untuk organisasi Anda sebelum melanjutkan implementasi apa pun. Ini juga penting untuk merencanakan aturan permintaan yang tepat dan langkah-langkah keamanan database untuk mencegah akses yang tidak sah dan melindungi data sensitif.

Sekarang setelah Anda melihat bahasa alami untuk fitur SQL dalam tindakan, mari kita periksa bagaimana penerapannya.

Buka file server/apiRoutes.ts dan temukan rutenya generateSql . Rute API ini dipanggil oleh aplikasi sisi klien yang berjalan di browser dan digunakan untuk menghasilkan SQL dari kueri bahasa alami. Setelah kueri SQL diambil, kueri tersebut digunakan untuk mengkueri database dan mengembalikan hasil.

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

Perhatikan fungsionalitas berikut dalam generateSql rute:

Ini mengambil nilai kueri pengguna dari req.body.prompt dan menetapkannya ke variabel bernama userPrompt. Nilai ini akan digunakan dalam prompt GPT.
Ini memanggil getSQLFromNLP() fungsi untuk mengonversi bahasa alami ke SQL.
Ini meneruskan SQL yang dihasilkan ke fungsi bernama queryDb yang menjalankan kueri SQL dan mengembalikan hasil dari database.

Buka file server/openAI.ts di editor Anda dan temukan fungsinya getSQLFromNLP() . Fungsi ini dipanggil oleh generatesql rute dan digunakan untuk mengonversi bahasa alami ke 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;
}

Parameter userPrompt diteruskan ke fungsi . Nilainya userPrompt adalah kueri bahasa alami yang dimasukkan oleh pengguna di browser.
systemPrompt menentukan jenis asisten AI yang akan digunakan dan aturan yang harus diikuti. Ini membantu Azure OpenAI memahami struktur database, aturan apa yang akan diterapkan, dan cara mengembalikan kueri dan parameter SQL yang dihasilkan.
Fungsi bernama callOpenAI() dipanggil dan systemPrompt nilai dan userPrompt diteruskan ke fungsi tersebut.
Hasilnya diperiksa untuk memastikan tidak ada nilai yang dilarang yang disertakan dalam kueri SQL yang dihasilkan. Jika nilai yang dilarang ditemukan, kueri SQL diatur ke string kosong.

Mari kita telusuri permintaan sistem secara lebih rinci:

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

Jenis asisten AI yang akan digunakan ditentukan. Dalam hal ini "bahasa alami untuk bot SQL".
Nama tabel dan kolom dalam database ditentukan. Skema tingkat tinggi yang disertakan dalam prompt dapat ditemukan dalam file server/db.schema dan terlihat seperti berikut ini.
```
- 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)
```
Petunjuk / Saran

Anda dapat mempertimbangkan untuk membuat tampilan baca-saja yang hanya berisi pengguna data yang diizinkan untuk mengkueri menggunakan bahasa alami ke SQL.
Aturan didefinisikan untuk mengonversi nilai string apa pun ke nilai kueri berparameter untuk menghindari serangan injeksi SQL.
Aturan didefinisikan untuk selalu mengembalikan objek JSON dengan kueri SQL dan nilai parameter di dalamnya.
Contoh perintah pengguna dan kueri SQL dan nilai parameter yang diharapkan disediakan. Ini disebut sebagai pembelajaran "beberapa tembakan". Meskipun LLM dilatih pada sejumlah besar data, mereka dapat disesuaikan dengan tugas baru hanya dengan beberapa contoh. Pendekatan alternatif adalah pembelajaran "zero-shot" di mana tidak ada contoh yang disediakan dan model diharapkan menghasilkan nilai kueri dan parameter SQL yang benar.

Fungsi ini getSQLFromNLP() mengirimkan permintaan sistem dan pengguna ke fungsi bernama callOpenAI() yang juga terletak di file server/openAI.ts . Fungsi callOpenAI() menentukan apakah Azure OpenAI dalam Model Foundry atau layanan OpenAI perlu dipanggil dengan memeriksa variabel lingkungan. Jika kunci, titik akhir, dan model tersedia dalam variabel lingkungan maka Azure OpenAI dipanggil, jika tidak, OpenAI dipanggil.
```
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

Meskipun kita akan fokus pada Azure OpenAI sepanjang tutorial ini, jika Anda hanya menyediakan OPENAI_API_KEY nilai dalam file .env , aplikasi akan menggunakan OpenAI sebagai gantinya. Jika Anda memilih untuk menggunakan OpenAI alih-alih Azure OpenAI, Anda mungkin melihat hasil yang berbeda dalam beberapa kasus.
getAzureOpenAICompletion() Temukan fungsi .
```
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;
}
```
Fungsi ini melakukan hal berikut:
- Parameter:
  - systemPrompt, userPrompt, dan temperature adalah parameter utama.
    - systemPrompt: Menginformasikan model Azure OpenAI tentang perannya dan aturan yang harus diikuti.
    - userPrompt: Berisi informasi yang disediakan pengguna seperti input bahasa alami atau aturan untuk menghasilkan output.
    - temperature: Menentukan tingkat kreativitas respons model. Nilai yang lebih tinggi menghasilkan output yang lebih kreatif, sementara nilai yang lebih rendah (misalnya, 0) menghasilkan jawaban yang lebih deterministik.
- Pembuatan Penyelesaian:
  - Fungsi memanggil createAzureOpenAICompletion() dengan systemPrompt, userPrompt, dan temperature untuk menghasilkan penyelesaian.
  - Ini mengekstrak konten dari pilihan pertama dalam penyelesaian, memangkas spasi kosong tambahan.
  - Jika konten berisi struktur seperti JSON (ditunjukkan oleh keberadaan { dan }), konten JSON akan diekstrak.
- Nilai Pengelogan dan Pengembalian:
  - Fungsi ini mencatat output Azure OpenAI ke konsol.
  - Ini mengembalikan konten yang diproses sebagai string.
createAzureOpenAICompletion() Temukan fungsi .
```
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.`);
        }
    }
}
```
Fungsi ini melakukan hal berikut:
- Parameter:
  - systemPrompt, userPrompt, dan temperature adalah parameter utama yang dibahas sebelumnya.
  - Parameter opsional dataSources mendukung fitur "Azure Bring Your Own Data", yang akan dibahas nanti dalam tutorial ini.
- Pemeriksaan Variabel Lingkungan:
  - Fungsi ini memverifikasi adanya variabel lingkungan penting, melemparkan kesalahan jika ada yang hilang.
- Objek Konfigurasi:
  - Objek config dibuat menggunakan nilai dari .env file (OPENAI_API_KEY, , OPENAI_ENDPOINT, OPENAI_API_VERSIONOPENAI_MODEL). Nilai-nilai ini digunakan untuk membuat URL untuk memanggil Azure OpenAI.
- Instans AzureOpenAI:
  - Instans AzureOpenAI dibuat menggunakan objek config. Simbol AzureOpenAI adalah bagian openai dari paket, yang harus diimpor di bagian atas file Anda.
- Menghasilkan Penyelesaian:
  - Fungsi chat.completions.create() ini dipanggil dengan properti berikut:
    - model: Menentukan model GPT (misalnya, gpt-4o, gpt-3.5-turbo) seperti yang didefinisikan dalam file Anda .env .
    - max_tokens: Menentukan jumlah maksimum token untuk penyelesaian.
    - temperature: Mengatur suhu pengambilan sampel. Nilai yang lebih tinggi (misalnya, 0,9) menghasilkan respons yang lebih kreatif, sementara nilai yang lebih rendah (misalnya, 0) menghasilkan jawaban yang lebih deterministik.
    - response_format: Menentukan format respons. Di sini, diatur untuk mengembalikan objek JSON. Detail selengkapnya tentang mode JSON dapat ditemukan di dokumentasi referensi Azure OpenAI.
    - messages: Berisi pesan untuk menghasilkan penyelesaian obrolan. Contoh ini mencakup dua pesan: satu dari sistem (menentukan perilaku dan aturan) dan satu dari pengguna (berisi teks perintah).
- Nilai Pengembalian:
  - Fungsi mengembalikan objek penyelesaian yang dihasilkan oleh Azure OpenAI.

Komentari baris berikut dalam getSQLFromNLP() fungsi:

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

Simpan openAI.ts. Server API akan secara otomatis membangun ulang kode TypeScript dan menghidupkan ulang server.
Kembali ke browser dan masukkan Pilih semua nama tabel dari database ke dalam input Kueri Kustom . Pilih Jalankan Kueri. Apakah nama tabel ditampilkan?
Kembali ke getSQLFromNLP() fungsi di server/openAI.ts dan tambahkan aturan berikut ke Rules: bagian prompt sistem lalu simpan file.
```
- Do not allow the SELECT query to return table names, function names, or procedure names.
```
Kembali ke browser dan lakukan tugas berikut:
- Masukkan Pilih semua nama tabel dari database ke dalam input Kueri Kustom . Pilih Jalankan Kueri. Apakah nama tabel ditampilkan?
- Masukkan Pilih semua nama fungsi dari database. ke dalam input Kueri Kustom dan pilih Jalankan Kueri lagi. Apakah nama fungsi ditampilkan?
PERTANYAAN: Apakah model akan selalu mengikuti aturan yang Anda tentukan dalam perintah?

JAWABAN: Tidak! Penting untuk dicatat bahwa model OpenAI dapat mengembalikan hasil yang tidak terduga sesekali yang mungkin tidak cocok dengan aturan yang telah Anda tentukan. Penting untuk merencanakannya dalam kode Anda.
Kembali ke server/openAI.ts dan temukan fungsi .isProhibitedQuery() Ini adalah contoh kode pasca-pemrosesan yang dapat dijalankan setelah Azure OpenAI mengembalikan hasil. Perhatikan bahwa properti mengatur sql properti ke string kosong jika kata kunci yang dilarang dikembalikan dalam kueri SQL yang dihasilkan. Ini memastikan bahwa jika hasil yang tidak terduga dikembalikan dari Azure OpenAI, kueri SQL tidak akan dijalankan terhadap 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));
}
```
Nota

Penting untuk dicatat bahwa ini hanya kode demo. Mungkin ada kata kunci terlarang lain yang diperlukan untuk mencakup kasus penggunaan spesifik Anda jika Anda memilih untuk mengonversi bahasa alami ke SQL. Ini adalah fitur yang harus Anda rencanakan dan gunakan dengan hati-hati untuk memastikan bahwa hanya kueri SQL yang valid yang dikembalikan dan dijalankan terhadap database. Selain kata kunci yang dilarang, Anda juga perlu memperhitungkan keamanan.
Kembali ke server/openAI.ts dan hapus komentar kode berikut dalam getSQLFromNLP() fungsi . Simpan file tersebut.
```
if (isProhibitedQuery(queryData.sql)) { 
    queryData.sql = '';
}
```

Hapus aturan berikut dari systemPrompt dan simpan file.

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

Kembali ke browser, masukkan Pilih semua nama tabel dari database ke input Kueri Kustom lagi dan pilih tombol Jalankan Kueri .
Apakah ada hasil tabel yang ditampilkan? Bahkan tanpa aturan di tempat, isProhibitedQuery kode pasca-pemrosesan melarang jenis kueri tersebut dijalankan terhadap database.
Seperti yang dibahas sebelumnya, mengintegrasikan bahasa alami ke SQL dalam lini aplikasi bisnis bisa sangat bermanfaat bagi pengguna, tetapi itu datang dengan serangkaian pertimbangannya sendiri.

Keuntungan:
- Keramahan pengguna: Fitur ini dapat membuat interaksi database lebih mudah diakses oleh pengguna tanpa keahlian teknis, mengurangi kebutuhan akan pengetahuan SQL dan berpotensi mempercepat operasi.
- Peningkatan produktivitas: Analis bisnis, pemasar, eksekutif, dan pengguna non-teknis lainnya dapat mengambil informasi berharga dari database tanpa harus mengandalkan pakar teknis, sehingga meningkatkan efisiensi.
- Aplikasi luas: Dengan menggunakan model bahasa lanjutan, aplikasi dapat dirancang untuk memenuhi berbagai pengguna dan kasus penggunaan.
Pertimbangan:
- Keamanan: Salah satu kekhawatiran terbesar adalah keamanan. Jika pengguna dapat berinteraksi dengan database menggunakan bahasa alami, perlu ada langkah-langkah keamanan yang kuat untuk mencegah akses yang tidak sah atau kueri berbahaya. Anda dapat mempertimbangkan untuk menerapkan mode baca-saja untuk mencegah pengguna memodifikasi data.
- Privasi Data: Data tertentu mungkin sensitif dan tidak boleh mudah diakses, jadi Anda harus memastikan perlindungan yang tepat dan izin pengguna telah diberlakukan.
- Akurasi: Meskipun pemrosesan bahasa alami telah meningkat secara signifikan, itu tidak sempurna. Salah menafsirkan kueri pengguna dapat menyebabkan hasil yang tidak akurat atau perilaku yang tidak terduga. Anda harus merencanakan bagaimana hasil yang tidak terduga akan ditangani.
- Efisiensi: Tidak ada jaminan bahwa SQL yang dikembalikan dari kueri bahasa alami akan efisien. Dalam beberapa kasus, panggilan tambahan ke Azure OpenAI mungkin diperlukan jika aturan pasca-pemrosesan mendeteksi masalah dengan kueri SQL.
- Pelatihan dan Adaptasi Pengguna: Pengguna perlu dilatih untuk merumuskan kueri mereka dengan benar. Meskipun lebih mudah daripada mempelajari SQL, masih ada kurva pembelajaran yang terlibat.
Beberapa poin akhir yang perlu dipertimbangkan sebelum melanjutkan ke latihan berikutnya:
- Ingatlah bahwa, "Hanya karena Anda tidak dapat berarti Anda harus" berlaku di sini. Gunakan perencanaan yang sangat hati-hati dan hati-hati sebelum mengintegrasikan bahasa alami ke SQL ke dalam aplikasi. Penting untuk memahami potensi risiko dan merencanakannya.
- Sebelum menggunakan jenis teknologi ini, diskusikan skenario potensial dengan tim Anda, administrator database, tim keamanan, pemangku kepentingan, dan pihak terkait lainnya untuk memastikan bahwa itu sesuai untuk organisasi Anda. Penting untuk dibahas jika bahasa alami ke SQL memenuhi keamanan, privasi, dan persyaratan lain yang mungkin dimiliki organisasi Anda.
- Keamanan harus menjadi perhatian utama dan dibangun dalam proses perencanaan, pengembangan, dan penyebaran.
- Meskipun bahasa alami ke SQL bisa sangat kuat, perencanaan yang cermat harus masuk ke dalamnya untuk memastikan permintaan memiliki aturan yang diperlukan dan fungsionalitas pasca-pemrosesan disertakan. Rencanakan waktu tambahan untuk menerapkan dan menguji jenis fungsionalitas ini dan untuk memperhitungkan skenario di mana hasil yang tidak terduga dikembalikan.
- Dengan Azure OpenAI, pelanggan mendapatkan kemampuan keamanan Microsoft Azure sambil menjalankan model yang sama dengan OpenAI. Azure OpenAI menawarkan jaringan privat, ketersediaan regional, dan pemfilteran konten AI yang bertanggung jawab. Pelajari selengkapnya tentang Data, privasi, dan keamanan untuk Azure OpenAI.
Anda sekarang telah melihat cara menggunakan Azure OpenAI untuk mengonversi bahasa alami ke SQL dan mempelajari tentang pro dan kontra penerapan jenis fungsionalitas ini. Dalam latihan berikutnya, Anda akan mempelajari bagaimana pesan email dan SMS dapat dibuat menggunakan Azure OpenAI.

Langkah Berikutnya

AI: Menghasilkan Penyelesaian

Bagikan melalui

AI: Bahasa Alami ke SQL

Menggunakan Bahasa Alami untuk Fitur SQL

Menjelajahi Bahasa Alami ke Kode SQL

Langkah Berikutnya

Saran dan Komentar

Sumber Daya Tambahan: