Database diakses menggunakan syntax SQL masing-masing program database, namun seiring berkembangnya LLM cara konvensional ini ternyata bisa dibuat alternatifnya. Alternatif ini memungkinkan mengakses data SQL dengan bahasa manusia dengan bantuan LLM.

Berikut beberapa fakta LLM:
- LLM bisa menjawab apapun dan segalanya berdasarkan keterbatasan pengetahuannya.
- LLM dapat mengenerate kode, termasuk kode SQL.

## Percobaan 1

Berdasarkan dua fakta di atas artinya saya dapat bertanya mengenai sebuah query SQL ke LLM. Misal saya bertanya

```text
Buat sebuah query SQL untuk mengakses daftar user
```

Ketika saya bertanya ke Claude.AI dijawab seperti berikut:

````text
Berikut adalah query SQL untuk mengakses daftar pengguna:
```sql
SELECT * FROM users;
```

Query ini akan mengambil semua data dari tabel "users". Jika Anda ingin membatasi kolom yang ditampilkan, Anda bisa menentukan kolom-kolom tersebut, misalnya:
```sql
SELECT user_id, username, email, created_at FROM users;
```

Jika Anda ingin menambahkan filter tertentu, Anda bisa menggunakan klausa WHERE:
```sql
SELECT * FROM users WHERE status = 'active';
```

Atau jika Anda ingin mengurutkan hasil berdasarkan kolom tertentu:
```sql
SELECT * FROM users ORDER BY created_at DESC;
```

Apakah Anda memerlukan query yang lebih spesifik atau ingin menambahkan kondisi tertentu pada query?
````

Ternyata tidak sesuai harapan, terlalu kompleks dan tidak to the point. Saya memikirkan cara apa yang diperlukan agar jawabannya sesuai dengan database yang saya miliki. Beberapa opsi terpiki:

- Bagaimana jika saya dump data SQL yang saya punya? *Nooo, datanya terlalu banyak, mahal*
- Bagaimana jika skemanya saja? **YESSSS**

## Percobaan 2

Disini saya akan menggunakan syntax [ADF](https://github.com/Graf-Research/adf-core) untuk skema database karena lebih mudah dibaca. Struktur database saya seperti berikut:

```adf
enum UserType {
  Regular
  VIP
}

table User {
  id bigint autoincrement primary-key notnull
  fullname varchar(255) notnull
  email varchar(255) notnull
  password varchar(255) notnull
  type UserType notnull default=UserType.Regular
  created_at timestamp notnull
}
```

saya akan coba tanya 

```text
buat query SQL untuk menampilkan data user dengan jenis VIP
```

sembari menyisipkan skema basis data diatas, dan hasilnya... (kali ini saya pakai ChatGPT)

````text
Untuk menampilkan data user dengan jenis VIP, kamu dapat menggunakan query SQL seperti berikut:

```sql
SELECT * FROM User
WHERE type = 'VIP';
```

Query ini akan menampilkan semua kolom dari tabel User di mana kolom type memiliki nilai VIP.
````

hasilnya sudah semakin mendekati, namun ada dua hal yang masih mengganggu:

- Setiap jawaban masih diikuti oleh intro dan outro teks yang bukan kode SQL
- Kode SQL tersebut belum sesuai dengan syntax PostgreSQL sesuai database saya

## Percobaan 3

Saya akan ubah sedikit query saya menjadi berikut:

```text
buat query SQL untuk menampilkan data user dengan jenis VIP dan gunakan syntax PostgreSQL dimana nama tabel dan kolom menggunakan double quotes
```

Hasilnya semakin baik:

```sql
SELECT *
FROM "User"
WHERE "type" = 'VIP';
```

namun intro dan outro masih tetap ada. Saya berpikir karena LLM ini tidak terduga sepertinya intro dan outro ini akan menjadi hal yang harus diterima, sehingga satu-satunya solusi adalah dengan mengekstrak query dari respon LLM tersebut. Hmmm... terpaksa harus pakai regex.

## Percobaan 4

Kali ini saya menerima kekurangan LLM yang tidak bisa konsisten memberikan hanya kode SQL, lalu saya akan coba mengekstrak menggunakan regex di NodeJS

```ts
const regex = /(```(sql)?\n)((.|\r|\n)+?)(?=```)(\```[^\w])/g
```
**Penjelasan**

- ` (```(sql)?\n) ` mendeteksi awalan *backtick* bisa dengan atau tanpa keyword sql
- ` ((.|\r|\n)+?)(?=```) ` seluruh karakter sebelum ketemu tiga *backtick* dengan `+?` menandakan match karakter paling pendek
- ` (\```[^\w]) ` mendeteksi akhiran *backtick*

Regex di atas kurang lebih akan mengambil blok kode yang diawali ` ```sql ` atau ` ``` ` dan diakhiri ` ``` `.

Saya coba ekstraksi data hasil di atas dengan kode berikut:

```ts
const regex = /(```(sql)?\n)((.|\r|\n)+?)(?=```)(\```[^\w])/g

const raw_data = `
Untuk menampilkan data user dengan jenis VIP, kamu dapat menggunakan query SQL seperti berikut:
 
\`\`\`sql
SELECT * FROM User
WHERE type = 'VIP';
\`\`\`
 
Query ini akan menampilkan semua kolom dari tabel User di mana kolom type memiliki nilai VIP.
`;

const matches = regex.exec(raw_data)
if (matches) {
  console.log(matches[3]);
}
```

Hasilnya

```sql
SELECT * FROM User
WHERE type = 'VIP';
```

sesuai harapan berhasil mengekstraksi kode SQL.

## Percobaan 5

Sekarang saya akan coba mengintegrasikan LLM ke NodeJS menggunakan API LLM dengan library yang baru-baru ini saya buat [Graf LLM Runner](https://github.com/Graf-Research/llm-runner) lalu melakukan query ke basis data menggunakan query yang diberikan LLM dan telah diekstraksi regex.

Saya akan menggunakan skema database buku utang sederhana yang saya pernah buat.

```ts
import { ChatGPTLLM, LLMRunner, MSModule_YesNo } from '@graf-research/llm-runner';

export async function test() {
  const chat_gpt_api_key = '';
  const llm: LLMRunner.BaseLLM = new ChatGPTLLM(chat_gpt_api_key, 'gpt-4o-mini');

  const db_schema = `
table Pelanggan {
  id bigint pk inc notnull
  nama varchar(200) notnull
  nomor_hp varchar(100) notnull
}

table Produk {
  id bigint pk inc notnull
  nama varchar(100) notnull
  deskripsi text
  harga_satuan bigint notnull
}

table Utang {
  id bigint pk inc notnull
  id_pelanggan Pelanggan.id notnull
  id_produk Produk.id notnull
  jumlah_utang bigint notnull
}`;

  const q = 'Tampilkan daftar pelanggan yang memiliki utang';

  const prompt1 = `
Berikut skema database
${db_schema}

# Instruksi
Buat PostgreSQL query untuk menjawab instruksi berikut: ${q}
Gunakan syntax PostgreSQL dan gunakan double quotes pada nama tabel dan kolom`;

  const response: string = await llm.askNoContext([prompt1]);

  const regex = /(```(sql)?\n)((.|\r|\n)+?)(?=```)(\```[^\w])/g
  
  const matches = regex.exec(response);
  if (!matches) {
    console.error(`Tidak ada query dari LLM`);
    return;
  }

  const sql_query = matches[3];
  console.log(sql_query);
}

test();

```

Hasilnya sesuai ekspektasi

```sql
SELECT DISTINCT p."id", p."nama", p."nomor_hp"
FROM "Pelanggan" p
JOIN "Utang" u ON p."id" = u."id_pelanggan";
```

## Percobaan 6

Sebelum mengeksekusi query tersebut ke database, saya ingin mengecek terlebih dahulu apakah query yang dihasilkan LLM tersebut berpotensi mengubah data di database, jika mengubah maka saya harus tolak query-nya.

```ts
import { ChatGPTLLM, LLMRunner, MSModule_YesNo } from '@graf-research/llm-runner';

export async function test() {
  const chat_gpt_api_key = '';
  const llm: LLMRunner.BaseLLM = new ChatGPTLLM(chat_gpt_api_key, 'gpt-4o-mini');

  ...

  const sql_query = matches[3];

  const prompt2 = `
Perhatikan query berikut ini
${sql_query}
Apakah query tersebut berpotensi mengubah data pada basis data?`;

  const is_query_change_db = await MSModule_YesNo.ask(llm, prompt2);
  if (is_query_change_db) {
    console.error(`Instruksi tidak dapat dilakukan karena berpotensi mengubah data`);
    return;
  }

  console.log(sql_query);
}

test();
```

## Percobaan 7

Saya akan membuat sebuah fungsi wrapper untuk mengakses database PostgreSQL dan mengembalikan data dalam format tabel markdown seperti berikut:

```ts
import { Client } from "pg";

export interface PostgreSQLParam {
  user: string
  password: string
  host: string
  port: number
  database: string
}

async function queryData(q: string, param: PostgreSQLParam): Promise<string> {
  const client = new Client({
    user: param.user,
    password: param.password,
    host: param.host,
    port: param.port,
    database: param.database,
  });

  try {
    await client.connect();
    const query_result_data = await client.query(q);
    const fields_name = query_result_data.fields.map(f => f.name);
    
    return [
      '| ' + fields_name.join(' | ') + ' |',
      '| ' + Array(fields_name.length).fill('----').join(' | ') + ' |',
      ...query_result_data.rows.map(row => '| ' + fields_name.map((key: string) => row[key]).join(' | ') + ' |')
    ].join('\n');
  } catch (err: any) {
    throw err;
  } finally {
    await client.end();
  }
}
```

## Percobaan 8 (Akhir)

Saatnya menggabungkan LLM dan query database di atas

```ts
import { ChatGPTLLM, LLMRunner, MSModule_YesNo } from '@graf-research/llm-runner';

export async function test() {
  const chat_gpt_api_key = '';
  const llm: LLMRunner.BaseLLM = new ChatGPTLLM(chat_gpt_api_key, 'gpt-4o-mini');

  ...

  const sql_query = matches[3];

  const prompt2 = `
Perhatikan query berikut ini
${sql_query}
Apakah query tersebut berpotensi mengubah data pada basis data?`;

  const is_query_change_db = await MSModule_YesNo.ask(llm, prompt2);
  if (is_query_change_db) {
    console.error(`Instruksi tidak dapat dilakukan karena berpotensi mengubah data`);
    return;
  }

  const db_param: PostgreSQLParam = {...};
  console.log(await queryData(sql_query, db_param));
}

test();
```

# Simpulan

LLM bisa digunakan sebagai jembatan untuk mengakses database. Selama LLM mengetahui konteks database seperti skema database, LLM dapat menggenerate query dengan cukup akurat. Terdapat beberapa hal yang perlu diperhatikan ketika melakukan implementasi seperti:
- ekstraksi output LLM yang bisa dibilang selalu tidak konsisten, 
- post-processing data output LLM, 
- validasi query agar berhati-hati dalam menerima output query dari LLM, misal tidak serta-merta mengeksekusi query tanpa memahami apakah query tersebut berbahaya ke database atau tidak.

LLM bisa dileverage menjadi sebuah asisten untuk menerjemahkan bahasa manusia menjadi pengakses basis data. Pengguna bisa bertanya apapun ke basis data dan LLM akan menjawab dengan data yang ada pada basis data. Pada studi kasus ini saya coba menggunakan syntax ADF sebagai format informasi basis data dan PostgreSQL sebagai program basis data percobaan.