ApsaraDB RDS:Bangun chatbot khusus berbasis LLM menggunakan RDS for PostgreSQL

Latar Belakang

Semakin banyak perusahaan dan individu ingin memanfaatkan LLM dan AI generatif untuk membangun produk berbasis AI di domain spesifik mereka. Meskipun LLM bekerja dengan baik pada masalah umum, model ini memiliki keterbatasan dalam menangani pengetahuan khusus dan informasi real-time karena ketergantungannya pada data pelatihan dan mekanisme respons. Di era informasi, basis pengetahuan bisnis sering diperbarui. Basis pengetahuan vertikal tersebut—yang mencakup dokumen, gambar, serta file audio/video—bisa bersifat privat atau rahasia. Untuk membangun produk AI berbasis domain di atas LLM, bisnis harus terus-menerus melatih model dengan basis pengetahuannya sendiri.

Terdapat dua metode umum:

• Fine-tuning: Menyediakan dataset baru untuk menyesuaikan bobot model yang sudah ada. Anda dapat terus memperbarui input guna menyesuaikan output hingga mencapai hasil yang diinginkan. Metode ini cocok untuk dataset kecil atau pelatihan pada jenis tugas atau gaya tertentu, tetapi biaya pelatihannya tinggi.

• Prompt-tuning: Sesuaikan prompt input alih-alih mengubah bobot model untuk menyesuaikan output. Dibandingkan fine-tuning, prompt-tuning memiliki biaya komputasi lebih rendah, memerlukan sumber daya dan waktu pelatihan lebih sedikit, serta lebih fleksibel.

Keunggulan membangun chatbot di atas ApsaraDB RDS for PostgreSQL adalah sebagai berikut:

• ApsaraDB RDS for PostgreSQL dilengkapi plugin pgvector. Anda dapat menggunakannya untuk mengonversi konten real-time atau pengetahuan berbasis domain menjadi vector embeddings. Menyimpan embedding ini di ApsaraDB RDS for PostgreSQL mempercepat pencarian vektor, sehingga meningkatkan akurasi tanya jawab untuk data privat Anda.

• Sebagai mesin Pemrosesan transaksional (TP) open source tingkat lanjut, ApsaraDB RDS for PostgreSQL mampu menangani interaksi pengguna online dan tugas penyimpanan data secara bersamaan. Misalnya, sistem ini dapat mengelola riwayat percakapan, catatan interaksi, dan stempel waktu chat. Fleksibilitas ApsaraDB RDS for PostgreSQL menyederhanakan proses pembangunan layanan bisnis privat dan meringankan arsitektur.

• Plugin pgvector banyak digunakan di komunitas developer dan database PostgreSQL open source. Alat seperti ChatGPT Retrieval Plugin juga dengan cepat menambahkan dukungan untuk PostgreSQL. Hal ini menunjukkan bahwa ApsaraDB RDS for PostgreSQL memiliki dukungan ekosistem yang kuat dan basis aplikasi luas untuk pengambilan vektor, sehingga menyediakan banyak alat dan sumber daya bagi pengguna.

Topik ini menggunakan plugin indeks vektor open source untuk ApsaraDB RDS for PostgreSQL, pgvector, serta kemampuan embedding dari OpenAI untuk menunjukkan cara membangun chatbot khusus.

Prasyarat

• Instans RDS PostgreSQL yang memenuhi kondisi berikut telah dibuat:

  • Instans menjalankan PostgreSQL 14 atau versi yang lebih baru.

  • Versi mesin minor instans adalah 20230430 atau lebih baru.

  Catatan

  Untuk informasi selengkapnya, lihat Upgrade versi mesin utama dan Perbarui versi mesin minor.

• Chatbot khusus dalam topik ini didasarkan pada plugin pgvector open source untuk ApsaraDB RDS for PostgreSQL. Pastikan Anda memahami sepenuhnya penggunaan dan konsep dasarnya. Untuk informasi selengkapnya, lihat Panduan pengguna pgvector.

• Chatbot khusus dalam topik ini menggunakan kemampuan OpenAI. Pastikan Anda memiliki Secret API Key dan lingkungan jaringan Anda dapat mengakses OpenAI. Contoh kode dalam topik ini dideploy pada Instance ECS di wilayah Singapura.

• Kode contoh dalam topik ini menggunakan Python. Pastikan Anda memiliki lingkungan pengembangan Python. Contoh ini menggunakan Python 3.11.4 dan PyCharm 2023.1.2.

Konsep Terkait

Embedding

Embedding adalah proses pemetaan data berdimensi tinggi ke representasi berdimensi rendah. Dalam pembelajaran mesin dan Pemrosesan bahasa alami (NLP), embedding sering digunakan untuk merepresentasikan simbol atau objek diskrit sebagai titik dalam ruang vektor kontinu.

Dalam NLP, penyematan kata (word embedding) adalah teknik umum. Teknik ini memetakan kata ke vektor bilangan real agar komputer dapat lebih memahami dan memproses teks. Melalui word embedding, hubungan semantik dan gramatikal antar kata dapat direpresentasikan dalam ruang vektor.

OpenAI menyediakan fitur Embeddings.

Prinsip Implementasi

Proses membangun chatbot khusus terdiri dari dua fase:

Fase 1: Persiapan data

1. Ekstraksi dan chunk informasi dari basis pengetahuan: Ekstrak teks relevan dari basis pengetahuan domain dan proses menjadi chunk. Ini dapat mencakup pemisahan teks panjang menjadi paragraf atau kalimat, atau ekstraksi kata kunci atau entitas. Proses ini membantu mengorganisasi dan mengelola konten basis pengetahuan.

2. Panggil antarmuka LLM untuk menghasilkan embedding: Gunakan antarmuka yang disediakan oleh LLM, seperti OpenAI, untuk memasukkan chunk teks dan menghasilkan text embedding yang sesuai. Embedding ini menangkap informasi semantik dan kontekstual teks, serta menjadi dasar untuk pencarian dan pencocokan selanjutnya.

3. Simpan informasi embedding: Simpan text embedding yang dihasilkan, chunk teks, dan metadata terkait di database ApsaraDB RDS for PostgreSQL.

Fase 2: Tanya Jawab

1. Pengguna mengajukan pertanyaan.

2. Buat embedding untuk pertanyaan tersebut menggunakan antarmuka embedding yang disediakan oleh OpenAI.

3. Gunakan pgvector untuk memfilter chunk dokumen di database ApsaraDB RDS for PostgreSQL yang memiliki skor kemiripan di atas ambang batas tertentu dan kembalikan hasilnya.

Bagan alir berikut menunjukkan proses tersebut:

Prosedur

Fase 1: Persiapan Data

Topik ini menggunakan konten teks dari dokumen Buat instans RDS for PostgreSQL sebagai contoh. Konten tersebut dipisah dan disimpan dalam database ApsaraDB RDS for PostgreSQL. Anda harus menyiapkan basis pengetahuan berbasis domain Anda sendiri.

Kunci fase persiapan data adalah mengonversi pengetahuan berbasis domain menjadi text embedding serta menyimpan dan mencocokkan informasi tersebut secara efektif. Dengan memanfaatkan kemampuan pemahaman semantik LLM yang andal, Anda dapat memperoleh jawaban dan saran berkualitas tinggi terkait domain spesifik Anda. Beberapa framework open source saat ini, seperti LangChain dan ChatGPT Retrieval Plugin dari OpenAI, memungkinkan Anda mengunggah dan mengurai file basis pengetahuan dalam format seperti URL, Markdown, PDF, dan Word dengan mudah. Baik LangChain maupun ChatGPT Retrieval Plugin telah mendukung PostgreSQL dengan ekstensi pgvector sebagai database vektor backend-nya. Hal ini mempermudah integrasi dengan instans ApsaraDB RDS for PostgreSQL Anda. Dengan integrasi ini, Anda dapat menyelesaikan persiapan data untuk basis pengetahuan domain Anda di Fase 1. Anda juga dapat memanfaatkan sepenuhnya fitur indeks vektor dan pencarian kemiripan pgvector untuk pencocokan dan kueri teks yang efisien.

1. Hubungkan ke instans PostgreSQL.

2. Buat database uji. Contoh ini menggunakan rds_pgvector_test.

   CREATE DATABASE rds_pgvector_test;

3. Hubungkan ke database uji dan buat plugin pgvector.

   CREATE EXTENSION IF NOT EXISTS vector;

4. Buat tabel uji untuk menyimpan konten basis pengetahuan. Contoh ini menggunakan rds_pg_help_docs.

   CREATE TABLE rds_pg_help_docs (
     id bigserial PRIMARY KEY, 
     title text,			-- Judul dokumen
     description text, 		-- Deskripsi
     doc_chunk text, 		-- Chunk dokumen
     token_size int, 		-- Jumlah token chunk dokumen
     embedding vector(1536));	-- Informasi text embedding

5. Buat indeks pada kolom embedding untuk mengoptimalkan dan mempercepat kueri.

   CREATE INDEX ON rds_pg_help_docs USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

   Catatan

   Untuk informasi selengkapnya tentang pembuatan indeks pada kolom vektor, lihat Panduan pengguna pgvector.

6. Di PyCharm, buat proyek, buka Terminal, dan jalankan perintah berikut untuk menginstal dependensi yang diperlukan.

   pip install openai psycopg2 tiktoken requests beautifulsoup4 numpy

7. Buat file .py untuk memisah dokumen basis pengetahuan dan menyimpannya di database. Contoh ini menggunakan knowledge_chunk_storage.py. Kode contohnya adalah sebagai berikut:

   Catatan

   Dalam kode contoh di bawah, metode pemisahan kustom hanya membagi dokumen basis pengetahuan berdasarkan jumlah karakter tetap. Anda dapat menggunakan metode yang disediakan oleh framework open source seperti LangChain dan ChatGPT Retrieval Plugin dari OpenAI untuk pemisahan. Kualitas dokumen dalam basis pengetahuan dan hasil chunking berdampak signifikan terhadap output akhir.

   import openai
   import psycopg2
   import tiktoken
   import requests
   from bs4 import BeautifulSoup
   
   EMBEDDING_MODEL = "text-embedding-ada-002"
   tokenizer = tiktoken.get_encoding("cl100k_base")
   
   # Hubungkan ke database RDS for PostgreSQL
   conn = psycopg2.connect(database="<database_name>",
                           host="<instance_endpoint>",
                           user="<username>",
                           password="<password>",
                           port="<port>")
   conn.autocommit = True
   
   # Kunci API OpenAI
   openai.api_key = '<Secret API Key>'
   
   # Metode pemisahan kustom (hanya sebagai contoh)
     def get_text_chunks(text, max_chunk_size):
       chunks_ = []
       soup_ = BeautifulSoup(text, 'html.parser')
   
       content = ''.join(soup_.strings).strip()
   
       length = len(content)
       start = 0
       while start < length:
           end = start + max_chunk_size
           if end >= length:
               end = length
   
           chunk_ = content[start:end]
           chunks_.append(chunk_)
   
           start = end
   
       return chunks_
   
   
   # Tentukan halaman web yang akan dipisah
   url = 'https://www.alibabacloud.com/help/document_detail/148038.html'
   
   response = requests.get(url)
   if response.status_code == 200:
       # Ambil konten halaman web
       web_html_data = response.text
       soup = BeautifulSoup(web_html_data, 'html.parser')
       # Ambil judul (tag H1)
       title = soup.find('h1').text.strip()
   
       # Ambil deskripsi (konten tag p dengan class='shortdesc')
       description = soup.find('p', class_='shortdesc').text.strip()
   
       # Pisah dan simpan
       chunks = get_text_chunks(web_html_data, 500)
       for chunk in chunks:
           doc_item = {
               'title': title,
               'description': description,
               'doc_chunk': chunk,
               'token_size': len(tokenizer.encode(chunk))
           }
   
           query_embedding_response = openai.Embedding.create(
               model=EMBEDDING_MODEL,
               input=chunk,
           )
   
           doc_item['embedding'] = query_embedding_response['data'][0]['embedding']
   
           cur = conn.cursor()
           insert_query = '''
           INSERT INTO rds_pg_help_docs 
               (title, description, doc_chunk, token_size, embedding) VALUES (%s, %s, %s, %s, %s);
           '''
   
           cur.execute(insert_query, (
               doc_item['title'], doc_item['description'], doc_item['doc_chunk'], doc_item['token_size'],
               doc_item['embedding']))
   
           conn.commit()
   
   else:
       print('Gagal mengambil halaman web')

8. Jalankan program Python.

9. Login ke database dan jalankan perintah berikut untuk memeriksa apakah konten basis pengetahuan telah dipisah dan disimpan sebagai data vektor.

   SELECT * FROM rds_pg_help_docs;

   

Fase 2: Tanya Jawab

1. Di proyek Python, buat file .py untuk membuat pertanyaan, membandingkan kemiripannya dengan konten basis pengetahuan di database, dan mengembalikan hasilnya. Contoh ini menggunakan chatbot.py.

   import openai
   import psycopg2
   from psycopg2.extras import DictCursor
   
   GPT_MODEL = "gpt-3.5-turbo"
   EMBEDDING_MODEL = "text-embedding-ada-002"
   GPT_COMPLETIONS_MODEL = "text-davinci-003"
   MAX_TOKENS = 1024
   
   # Kunci API OpenAI
   openai.api_key = '<Secret API Key>'
   
   prompt = 'How to create an RDS for PostgreSQL instance'
   
   prompt_response = openai.Embedding.create(
       model=EMBEDDING_MODEL,
       input=prompt,
   )
   prompt_embedding = prompt_response['data'][0]['embedding']
   
   # Hubungkan ke database RDS for PostgreSQL
   conn = psycopg2.connect(database="<database_name>",
                           host="<instance_endpoint>",
                           user="<username>",
                           password="<password>",
                           port="<port>")
   conn.autocommit = True
   
   
   def answer(prompt_doc, prompt):
       improved_prompt = f"""
       Jawab pertanyaan berikut berdasarkan dokumen dan langkah yang disediakan:
       (1) Pertama, analisis konten dokumen untuk melihat apakah relevan dengan pertanyaan.
       (2) Kedua, gunakan hanya konten dari dokumen untuk balasan. Berikan detail sebanyak mungkin dan keluarkan dalam format markdown.
       (3) Terakhir, jika pertanyaan tidak terkait dengan RDS for PostgreSQL, balas dengan "Saya tidak terlalu memahami topik selain RDS for PostgreSQL."
   
       Dokumen:
       \"\"\"
       {prompt_doc}
       \"\"\"
   
       Pertanyaan: {prompt}
       """
   
       response = openai.Completion.create(
           model=GPT_COMPLETIONS_MODEL,
           prompt=improved_prompt,
           temperature=0.2,
           max_tokens=MAX_TOKENS
       )
   
       print(f"{response['choices'][0]['text']}\n")
   
   
   similarity_threshold = 0.78
   max_matched_doc_counts = 8
   
   # Filter chunk dokumen dengan kemiripan di atas ambang batas tertentu menggunakan pgvector
   similarity_search_sql = f'''
   SELECT doc_chunk, token_size, 1 - (embedding <=> '{prompt_embedding}') AS similarity 
   FROM rds_pg_help_docs WHERE 1 - (embedding <=> '{prompt_embedding}') > {similarity_threshold} ORDER BY id LIMIT {max_matched_doc_counts};
   '''
   
   cur = conn.cursor(cursor_factory=DictCursor)
   cur.execute(similarity_search_sql)
   matched_docs = cur.fetchall()
   
   total_tokens = 0
   prompt_doc = ''
   print('Jawaban: \n')
   for matched_doc in matched_docs:
       if total_tokens + matched_doc['token_size'] <= 1000:
           prompt_doc += f"\n---\n{matched_doc['doc_chunk']}"
           total_tokens += matched_doc['token_size']
           continue
   
       answer(prompt_doc,prompt)
   
       total_tokens = 0
       prompt_doc = ''
   
   answer(prompt_doc,prompt)

2. Setelah menjalankan program Python, jawaban yang sesuai akan muncul di jendela run, mirip dengan berikut:

   Catatan

   Anda dapat mengoptimalkan metode pemisahan dan prompt pertanyaan untuk memperoleh jawaban yang lebih akurat dan lengkap. Topik ini hanya menyediakan contoh.

   

Ringkasan

Jika basis pengetahuan khusus tidak terhubung, jawaban OpenAI terhadap pertanyaan "How do I create an RDS for PostgreSQL instance?" sering kali tidak relevan dengan Alibaba Cloud. Misalnya:

Setelah terhubung ke basis pengetahuan khusus yang disimpan di database ApsaraDB RDS for PostgreSQL, jawaban terhadap pertanyaan "How do I create an RDS for PostgreSQL instance?" akan spesifik untuk ApsaraDB RDS for PostgreSQL milik Alibaba Cloud.

Berdasarkan contoh di atas, jelas bahwa ApsaraDB RDS for PostgreSQL mampu membangun basis pengetahuan berbasis LLM untuk domain vertikal.