Rag-to-SQL di Google Cloud

Teknologi Text-to-SQL sering berjuang untuk menangkap konteks lengkap dan makna permintaan pengguna, yang mengakibatkan pertanyaan yang tidak sesuai dengan yang dimaksudkan. Walaupun pemaju bekerja keras untuk meningkatkan sistem ini, ia perlu dipersoalkan jika terdapat kaedah yang lebih baik.

Masukkan RAG-ke-SQL-Pendekatan baru yang menggabungkan pemahaman bahasa semulajadi dengan pengambilan data yang kuat untuk menghasilkan pertanyaan SQL yang tepat. Dengan menggabungkan pemprosesan bahasa semulajadi dan pengambilan maklumat semula jadi, RAG-ke-SQL menawarkan cara yang lebih dipercayai untuk menjadikan bahasa sehari-hari menjadi pandangan yang bermakna dari pangkalan data anda.

Dalam artikel ini, kami akan meneroka bagaimana RAG-to-SQL dapat mengubah cara kami berinteraksi dengan pangkalan data, terutama menggunakan perkhidmatan Google Cloud seperti BigQuery dan Vertex AI.

Objektif pembelajaran

• Kenal pasti batasan sistem teks-ke-SQL dengan tepat menangkap niat pengguna.
• Memahami kelebihan RAG-to-SQL sebagai paradigma baru untuk menghasilkan pertanyaan SQL yang lebih dipercayai.
• Melaksanakan pendekatan RAG-to-SQL menggunakan perkhidmatan Google Cloud seperti BigQuery dan Vertex AI.
• Ketahui cara mengintegrasikan dan menggunakan pelbagai alat Google Cloud untuk pelaksanaan RAG-to-SQL.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Objektif pembelajaran
• Batasan pendekatan teks-ke-SQL tradisional
• Apa itu Rag-to-SQL?
• Menyediakan Rag-ke-SQL dengan Google Cloud: Panduan Langkah demi Langkah
  • Pra-syarat untuk kod
  • Carta aliran kod
  • Langkah 1: Memasang perpustakaan yang diperlukan
  • Langkah 2: Mengkonfigurasi projek dan kelayakan Google Cloud anda
  • Langkah 3: Membina Pangkalan Data Vektor untuk Penyimpanan Skema Jadual
  • Langkah 4: Model LLM Instantiating untuk pertanyaan SQL, tafsiran, dan rantaian ejen
  • Langkah 5: Membina Rantaian Pertanyaan SQL
  • Langkah 6: Menapis output rantai SQL untuk tafsiran
  • Langkah 7: Membina rantai tafsiran untuk hasil pertanyaan
  • Langkah 8: Melaksanakan rantaian ejen untuk penghalaan pertanyaan dinamik
• Kesimpulan
  • Takeaways utama
• Soalan yang sering ditanya

Batasan pendekatan teks-ke-SQL tradisional

Idea utama di sebalik teks kepada model SQL LLM adalah untuk membolehkan orang yang tidak tahu tentang SQL untuk berinteraksi dengan pangkalan data dan mendapatkan maklumat menggunakan bahasa semulajadi. Rangka kerja Teks SQL yang sedia ada bergantung terutamanya dalam pengetahuan LLM untuk dapat menukar pertanyaan bahasa semula jadi ke pertanyaan SQL. Ini boleh membawa kepada perumusan yang salah atau tidak sah pertanyaan SQL. Di sinilah pendekatan baru RAG ke SQL datang ke penyelamatan kami yang dijelaskan dalam bahagian seterusnya.

Apa itu Rag-to-SQL?

Untuk mengatasi kekurangan teks kepada SQL, kita boleh menggunakan pendekatan inovatif RAG ke SQL. Penyepaduan maklumat domain mengenai pangkalan data adalah isu utama yang dihadapi oleh setiap perisian teks-ke-SQL. Senibina RAG2SQL menangani kesukaran ini dengan menambahkan data kontekstual (metadata, DDL, pertanyaan, dan banyak lagi). Data ini kemudiannya "terlatih" dan disediakan untuk penggunaan.
Selain itu, "retriever" menilai dan meneruskan konteks yang paling relevan untuk bertindak balas terhadap pertanyaan pengguna. Hasil akhirnya sangat baik.

Menyediakan Rag-ke-SQL dengan Google Cloud: Panduan Langkah demi Langkah

Ikuti panduan terperinci untuk melaksanakan RAG-to-SQL menggunakan perkhidmatan Google Cloud seperti BigQuery dan Vertex AI.

Pra-syarat untuk kod

Untuk mengikuti dan menjalankan kod ini, anda perlu menyiapkan GCP anda (akaun Google Cloud dengan maklumat pembayaran). Pada mulanya mereka menyediakan percubaan 300 $ percuma selama 90 hari jadi tidak ada caj yang akan ditanggung. Perincian untuk Persediaan Akaun: Pautan

Carta aliran kod

Berikut adalah carta aliran kod yang menggambarkan pada tahap yang lebih tinggi pelbagai blok kod. Kita boleh merujuknya untuk mengikuti semasa kita meneruskan.

Pelaksanaan kod boleh dibahagikan kepada 3 blok utama:

• Rantaian pertanyaan SQL: Rantaian ini bertanggungjawab untuk menghasilkan pertanyaan SQL yang sesuai berdasarkan soalan pengguna dan skema jadual yang berkaitan yang diambil dari vektor DB.
• Tafsiran Rantaian: Rantaian ini mengambil pertanyaan SQL dari rantai sebelumnya, menjalankannya di BigQuery, dan kemudian menggunakan hasilnya untuk menghasilkan respons dengan prompt yang sesuai.
• Rantaian Agen: Ini adalah rantaian akhir yang merangkumi dua rantai di atas. Setiap kali soalan pengguna datang di dalamnya akan memutuskan sama ada untuk menghubungi alat pertanyaan SQL atau menjawab soalan secara langsung. Ia mengarahkan pertanyaan pengguna ke pelbagai alat berdasarkan tugas yang diperlukan untuk menjawab soalan.

Langkah 1: Memasang perpustakaan yang diperlukan

Di Colab Notebook kita perlu memasang perpustakaan di bawah yang diperlukan untuk pelaksanaan ini.

 ! Pip Install Langchain == 0.0.340 -Quiet
! PIP Pasang Chromadb == 0.4.13 -Quiet
! Pip Pasang Google-Cloud-Bigquery [Pandas]-Quiet
! PIP Pasang Google-Cloud-Aiplatform-Quim#Import CSV

Langkah 2: Mengkonfigurasi projek dan kelayakan Google Cloud anda

Sekarang kita perlu mengisytiharkan beberapa pembolehubah untuk memulakan projek GCP kami dan dataset pertanyaan besar. Menggunakan pembolehubah ini, kami boleh mengakses jadual dalam pertanyaan besar dengan GCP dalam buku nota kami.

Anda boleh melihat butiran ini di Konsol Awan GCP anda. Di BigQuery, anda boleh membuat dataset dan dalam dataset anda boleh menambah atau memuat naik jadual untuk butiran lihat Create DataSetand Create Table.

 Vertex_project = "id projek gcp anda" # @param {type: "string"}
Vertex_region = "us-central1" # @param {type: "string"}

Bigquery_dataset = "nama dataset pertanyaan besar" # @param {type: "string"}
Bigquery_project = "Vertex Project ID" # @param {type: "String"}

Sekarang mengesahkan dan log masuk ke GCP Vertex AI anda dari buku nota anda menggunakan kod di bawah dalam COLAB.

 dari Google.Colab Import Auth
auth.authenticate_user ()

import vertexai
vertexai.init (projek = vertex_project, lokasi = vertex_region)

Langkah 3: Membina Pangkalan Data Vektor untuk Penyimpanan Skema Jadual

Sekarang kita perlu membuat vektor DB yang akan mengandungi skema pelbagai jadual yang terdapat dalam dataset kami dan kami akan membuat retriever di atas vektor db ini supaya kami dapat memasukkan kain dalam aliran kerja kami.

Menyambung ke pertanyaan besar menggunakan klien BQ dalam skema Python dan mengambil jadual.

 dari Google.Cloud Import BigQuery
Import JSON

#Fetching skema jadual

bq_client = bigQuery.client (projek = vertex_project)
bq_tables = bq_client.list_tables (dataset = f "{bigquery_project}. {bigquery_dataset}")
skema = []
untuk bq_table dalam bq_tables:
   t = bq_client.get_table (f "{bigquery_project}. {bigquery_dataset}. {bq_table.table_id}")
   skema_fields = [f.to_api_repr () untuk f dalam t.schema]
   skema = f "skema untuk jadual {bq_table.table_id} adalah yang berikut: \ n`` {json.dumps (skema_fields, indent = 1)}` `` "
   skema.Append (Skema)

cetak (f "dijumpai {len (skema)} jadual dalam dataset {bigQuery_project}: {BigQuery_dataset}")#Import CSV

Menyimpan skema dalam vektor DB seperti Chroma DB. Kita perlu membuat folder yang disebut " data"

 dari langchain.embeddings import vertexaiembeddings
dari Langchain.VectorStores Import Chroma

embeddings = vertexaiembeddings ()
Cuba: # Elakkan dokumen yang diduplikasi
  vector_store.delete_collection ()
Kecuali:
  Cetak ("Tidak Perlu Membersihkan Kedai Vektor")
vector_store = chroma.from_texts (skema, embedding = embeddings, erenti_directory = './data')
n_docs = len (vector_store.get () ['ids'])
retriever = vector_store.as_retriever (search_kwargs = {'k': 2})
cetak (f "kedai vektor mempunyai {n_docs} dokumen")

Langkah 4: Model LLM Instantiating untuk pertanyaan SQL, tafsiran, dan rantaian ejen

Kami akan meneliti model 3 llm untuk 3 rantai yang berbeza.

Model pertama adalah model pertanyaan yang bertanggungjawab untuk menjana pertanyaan SQL berdasarkan soalan pengguna dan skema jadual yang diambil dari vektor db serupa dengan soalan pengguna. Untuk ini kami menggunakan "CodeChat-Bison" model. Model ini mengkhususkan diri dalam menghasilkan kod dalam bahasa pengekodan yang berbeza dan oleh itu, sesuai untuk kes penggunaan kami.

Model 2 lain adalah model LLM lalai di Chatvertexai yang " Gemini-1.5-Flash-001 " Ini adalah model Gemini terkini yang dioptimumkan untuk sembang dan tindak balas cepat.

 dari langchain.chat_models import chatvertexai
dari langchain.llms import vertexai

query_model = chatverTexai (model_name = "codeChat-bison", max_output_tokens = 1000)
interpret_data_model = chatverTexai (max_output_tokens = 1000)
agen_model = chatvertExai (max_output_tokens = 1024)

Langkah 5: Membina Rantaian Pertanyaan SQL

Berikut adalah prompt SQL yang digunakan untuk menghasilkan pertanyaan SQL untuk soalan pengguna input.

 Sql_prompt = "" "Anda adalah pakar SQL dan BigQuery.

Tugas anda adalah untuk membuat pertanyaan untuk BigQuery dalam SQL.

Perenggan berikut mengandungi skema jadual yang digunakan untuk pertanyaan. Ia dikodkan dalam format JSON.

{konteks}

Buat pertanyaan SQL BigQuery untuk input pengguna berikut, menggunakan jadual di atas.
Dan gunakan hanya lajur yang disebut dalam skema untuk pertanyaan SQL

Pengguna dan ejen telah melakukan perbualan ini setakat ini:
{chat_history}

Ikuti sekatan ini dengan ketat:
- Hanya mengembalikan kod SQL.
- Jangan tambahkan backticks atau mana -mana markup. Hanya tulis pertanyaan sebagai output. Tidak ada yang lain.
- dari, sentiasa gunakan laluan meja penuh, menggunakan `{project}` sebagai projek dan `{dataset}` sebagai dataset.
- Sentiasa mengubah nama negara menjadi huruf besar penuh. Sebagai contoh, jika negara adalah Jepun, anda harus menggunakan Jepun dalam pertanyaan.

Input pengguna: {soalan}

Pertanyaan SQL:
"" "

Sekarang kita akan menentukan fungsi yang akan mengambil dokumen yang berkaitan iaitu skema untuk input soalan pengguna.

 dari langchain.schema.vectorstore import vectorstoreTriever
def get_documents (retriever: vectorstoreretriever, soalan: str) -> str:
  # Kembalikan hanya dokumen pertama
  output = ""
  untuk d dalam retriever.get_relevant_documents (soalan):
    output = d.page_content
    output = "\ n"
    output pulangan

Kemudian kami menentukan rantai LLM menggunakan sintaks bahasa ekspresi Langchain. Perhatikan kita menentukan prompt dengan 5 pembolehubah tempat dan kemudian kita menentukan prompt separa dengan mengisi projek pembolehubah letak dan dataset.

 dari itemgetter import pengendali
dari langchain.prompts import promptplate
dari Langchain.Schema Import StroutputParser

prompt_template = promptTemplate (
    input_variables = ["konteks", "chat_history", "soalan", "projek", "dataset"],
    templat = sql_prompt)

partial_prompt = prompt_template.partial (projek = bigQuery_project,
                                         dataset = bigquery_dataset)

# Input akan seperti {"input": "some_question", "chat_history": "sejarah"}
docs = {"context": lambda x: get_documents (retriever, x ['input'])}
Soalan = {"Soalan": itemgetter ("input")}
chat_history = {"chat_history": itemgetter ("chat_history")}
query_chain = docs | Soalan | chat_history | partial_prompt | query_model
query = query_chain | Stroutputparser ()

Marilah kita menguji rantaian kami menggunakan pengendali panggil balik Langchain yang akan menunjukkan setiap langkah pelaksanaan rantaian secara terperinci.

 dari Langchain.Callbacks.Tracers Import ConsoleCallBackHandler
# Contoh
x = {"input": "Tempoh tertinggi perjalanan di mana stesen mula berasal dari Atlantic Ave & Fort Greene Pl", "Chat_history": ""}
cetak (query.invoke (x, config = {'callbacks': [consoleCallbackHandler ()]})) 

Langkah 6: Menapis output rantai SQL untuk tafsiran

Kita perlu memperbaiki output rantai SQL di atas supaya ia termasuk pembolehubah lain juga dalam keadaannya yang kemudiannya akan diteruskan ke rantai kedua - rantaian tafsiran.

 dari langchain.output_parsers import responseschema, structuredoutputparser
dari langchain.schema.runnable import RunnableLambda

#Refine output rantai untuk memasukkan pembolehubah lain dalam output dalam format kamus
def _dict_to_json (x: dict) -> str:
  kembali "` `` \ n "json.dumps (x)" \ n``` "

query_response_schema = [
    ResponseSchema (name = "query", description = "sql query untuk menyelesaikan soalan pengguna."),
    ResponseSchema (name = "Soalan", Description = "Soalan yang ditanya oleh pengguna."),
    ResponseSchema (name = "context", description = "Dokumen yang diambil dari kedai vektor.")
  ]
query_output_parser = structuredoutputparser.from_response_schemas (query_response_schema)
query_output_json = docs | Soalan | {"pertanyaan": query} | RunNableLambda (_dict_to_json) | Stroutputparser ()
query_output = query_output_json | query_output_parser

Mari cuba melaksanakan rantai ini.

 # Contoh
x = {"input": "Beri saya 2 stesen permulaan di mana tempoh perjalanan tertinggi?", "chat_history": ""}
output = query_output.invoke (x) # output kini menjadi kamus, input untuk rantai seterusnya

Di atas kita dapat melihat output rantai halus adalah pertanyaan SQL.

Langkah 7: Membina rantai tafsiran untuk hasil pertanyaan

Sekarang kita perlu membina rantai seterusnya yang akan mengambil output rantaian pertanyaan SQL yang ditakrifkan di atas. Rantaian ini akan mengambil pertanyaan SQL dari rantai sebelumnya dan menjalankannya dalam pertanyaan besar dan hasilnya kemudian digunakan untuk menghasilkan respons menggunakan prompt yang sesuai.

 Interpret_prompt = "" "Anda seorang pakar besar. Anda juga pakar dalam mengekstrak data dari CSV.

Perenggan berikut menerangkan skema jadual yang digunakan untuk pertanyaan. Ia dikodkan dalam format JSON.

{konteks}

Pengguna mengemukakan soalan ini:
{soalan}

Untuk mencari jawapannya, pertanyaan SQL berikut dijalankan di BigQuery:
`` `
{query}
`` `

Hasil pertanyaan itu adalah jadual berikut dalam format CSV:
`` `
{hasil}
`` `

Berdasarkan hasil tersebut, berikan jawapan ringkas kepada soalan pengguna.

Ikuti sekatan ini dengan ketat:
- Jangan tambahkan penjelasan tentang bagaimana jawapannya diperoleh, tulis jawapannya.
- Ekstrak apa -apa nilai yang berkaitan dengan jawapan hanya dari hasil pertanyaan. Jangan gunakan sumber data lain.
- Cuma tulis jawapannya, tidak ada soalan dari jawapan anda, ini adalah sembang, hanya memberikan jawapannya.
- Sekiranya anda tidak dapat mencari jawapan dalam hasilnya, jangan buat sebarang data, katakanlah "Saya tidak dapat mencari jawapannya"
"" "

 dari Google.Cloud Import BigQuery
def get_bq_csv (bq_client: bigquery.client, query: str) -> str:
  dibersihkan_Query = Clean_Query (pertanyaan)
  df = bq_client.Query (Cleaned_Query, location = "us"). TO_DataFrame ()
  kembali df.to_csv (indeks = palsu)


def clean_query (pertanyaan: str):
  query = query.replace ("` `` sql "," ")
  dibersihkan_query = query.replace ("` `` "," ")

  kembali dibersihkan_Query

Kami akan menentukan dua fungsi satu adalah Clean_Query - ini akan membersihkan pertanyaan SQL apostrophes dan watak -watak lain yang tidak perlu dan lain -lain adalah get_bq_csv - ini akan menjalankan pertanyaan SQL yang dibersihkan dalam pertanyaan besar dan dapatkan jadual output dalam format CSV.

 # Dapatkan output rantai sebelumnya


pertanyaan = {"query": itemgetter ("query")}
konteks = {"konteks": itemgetter ("konteks")}
Soalan = {"Soalan": ItemGetter ("Soalan")}
#cleaned_query = {"result": lambda x: clean_query (x ["query"])}
query_result = {"result": lambda x: get_bq_csv (bq_client, x ["query"])}

prompt = promptTemplate (
    input_variables = ["soalan", "pertanyaan", "hasil", "konteks"],
    templat = tafsiran_prompt)

run_bq_chain = konteks | Soalan | pertanyaan | query_result | segera
run_bq_result = run_bq_chain | interpret_data_model | Stroutputparser ()

Mari laksanakan rantai dan uji.

 # Contoh
x = {"input": "Beri saya 2 stesen permulaan di mana tempoh perjalanan tertinggi?", "chat_history": ""}
final_response = run_bq_result.invoke (query_output.invoke (x))
cetak (final_response)

Langkah 8: Melaksanakan rantaian ejen untuk penghalaan pertanyaan dinamik

Sekarang kita akan membina rantaian akhir yang merupakan rantaian ejen. Apabila pengguna bertanya soalan, ia memutuskan sama ada untuk menggunakan alat pertanyaan SQL atau untuk menjawabnya secara langsung. Pada asasnya, ia menghantar pertanyaan pengguna ke pelbagai alat mengikut kerja yang mesti diselesaikan untuk menjawab pertanyaan pengguna.

Kami menentukan agen_memory, ejen prompt, funtion alat.

 dari Langchain.Memory Import ConversationBufferWindowMemory

ejen_memory = perbualanBufferWindowMemory (
    memory_key = "chat_history",
    k = 10,
    return_messages = benar)

 Agen_prompt = "" "Anda adalah pembantu yang sangat kuat yang dapat menjawab soalan menggunakan BigQuery.

Anda boleh memanggil alat user_question_tool untuk menjawab soalan menggunakan BigQuery.

Sentiasa gunakan alat untuk cuba menjawab soalan. Gunakan sejarah sembang untuk konteks. Jangan sekali -kali cuba menggunakan maklumat luaran yang lain.

Anggapkan bahawa pengguna boleh menulis dengan salah ejaan, menetapkan ejaan pengguna sebelum menyampaikan soalan kepada mana -mana alat.

Jangan nyatakan alat apa yang telah anda gunakan dalam jawapan anda.
"" "

 dari alat import langchain.tools
dari Langchain.Callbacks.Tracers Import ConsoleCallBackHandler

@tool
def user_question_tool (soalan) -> str:
  "" "Berguna untuk menjawab soalan bahasa semulajadi dari pengguna menggunakan BigQuery." ""
  config = {'callbacks': [consoleCallbackHandler ()]}
  config = {}
  memori = agen_memory.buffer_as_str.strip ()
  soalan = {"input": soalan, "chat_history": memori}
  query = query_output.invoke (soalan, config = config)
  cetak ("\ n \ n ****************** \ n \ n")
  Cetak (pertanyaan ['pertanyaan'])
  cetak ("\ n \ n ****************** \ n \ n")
  hasil = run_bq_result.invoke (pertanyaan, config = config)
  hasil pulangan.strip ()

Kami kini menyatukan semua komponen utama ejen dan memulakan ejen.

 dari Langchain.Agents Import AgentType, Initialize_Agent, AgentExecutor

agen_kwgards = {"System_Message": Agent_Prompt}
agen_tools = [user_question_tool]

agen_memory.clear ()

agen = initialisasi_agent (
    alat = agen_tools,
    llm = agen_model,
    agen = agentype.chat_conversational_react_description,
    memori = agen_memory,
    agen_kwgards = agen_kwgards,
    max_iterations = 5,
    Early_stopping_method = 'menghasilkan',
    verbose = benar)

Mari lari ejen sekarang.

 Q = "Beri saya 2 stesen permulaan di mana tempoh perjalanan adalah tertinggi?"
agen.invoke (Q) 

Soalan susulan kepada ejen.

 Q = "Apakah keupayaan untuk setiap nama stesen ini?"
agen.invoke (Q) 

Pemerhatian

Ejen itu tepat dapat memproses soalan yang kompleks dan juga menghasilkan jawapan yang betul untuk soalan ikuti berdasarkan sejarah sembang dan kemudian menggunakan jadual lain untuk mendapatkan maklumat kapasiti basikal Citi.

Kesimpulan

Pendekatan RAG-to-SQL mewakili kemajuan yang signifikan dalam menangani batasan model teks-ke-SQL tradisional dengan menggabungkan data kontekstual dan memanfaatkan teknik pengambilan semula. Metodologi ini meningkatkan ketepatan pertanyaan dengan mendapatkan maklumat skema yang relevan dari pangkalan data vektor, yang membolehkan generasi SQL yang lebih tepat. Melaksanakan RAG-to-SQL dalam perkhidmatan Google Cloud seperti BigQuery dan Vertex AI menunjukkan skalabilitas dan keberkesanannya dalam aplikasi dunia nyata. Dengan mengautomasikan proses membuat keputusan dalam pengendalian pertanyaan, RAG-to-SQL membuka kemungkinan baru untuk pengguna bukan teknikal untuk berinteraksi dengan lancar dengan pangkalan data sambil mengekalkan ketepatan yang tinggi.

Takeaways utama

• Mengatasi keterbatasan teks-ke-SQL menangani perangkap biasa model teks-ke-SQL tradisional dengan mengintegrasikan metadata.
• Sistem berasaskan ejen dengan cekap memutuskan bagaimana untuk memproses pertanyaan pengguna, meningkatkan kebolehgunaan.
• RAG-to-SQL membolehkan pengguna bukan teknikal untuk menghasilkan pertanyaan SQL yang kompleks dengan input bahasa semula jadi.
• Pendekatan ini berjaya dilaksanakan menggunakan perkhidmatan seperti BigQuery dan Vertex AI.

Soalan yang sering ditanya

Q1. Adakah akses GCP Vertex AI percuma?

A. Tidak, tetapi anda boleh mendapatkan tempoh percubaan selama 90 hari dengan 300 $ kredit jika anda mendaftar pertama kali dan anda hanya perlu memberikan butiran kad untuk mendapatkan akses. Tiada caj yang ditolak dari kad dan walaupun anda menggunakan sebarang perkhidmatan yang memakan lebih daripada 300 $ kredit maka Google akan meminta anda untuk membolehkan akaun pembayaran supaya anda boleh menggunakan perkhidmatan tersebut. Jadi tidak ada potongan automatik.

S2. Apakah manfaat utama menggunakan RAG ke SQL?

A. Ini membolehkan kami mengautomasikan skema jadual yang akan diberi makan kepada LLM jika kami menggunakan pelbagai jadual, kami tidak perlu memberi makan semua skema jadual sekaligus. Berdasarkan pertanyaan pengguna skema jadual yang berkaitan boleh diambil dari kain. Oleh itu, meningkatkan kecekapan ke atas teks konvensional kepada sistem SQL.

Q3. Bagaimanakah ejen boleh berguna untuk kes penggunaan ini?

A. Jika kita membina chatbot holistik, ia mungkin memerlukan banyak alat lain selain dari alat pertanyaan SQL. Oleh itu, kami boleh memanfaatkan ejen dan menyediakannya dengan pelbagai alat seperti carian web, alat pertanyaan SQL pangkalan data, alat RAG lain atau fungsi yang memanggil alat API. Ini akan membolehkan mengendalikan pelbagai jenis pertanyaan pengguna berdasarkan tugas yang perlu dicapai untuk bertindak balas terhadap pertanyaan pengguna.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Rag-to-SQL di Google Cloud. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!