Google Cloud의 Rag-to-SQL

Text-to-SQL Technologies는 종종 사용자의 요청의 완전한 컨텍스트와 의미를 캡처하기 위해 고군분투하여 의도 한 것과 정확히 일치하지 않는 쿼리를 초래합니다. 개발자는 이러한 시스템을 향상시키기 위해 열심히 노력하지만 더 나은 방법이 있는지 의문을 제기 할 가치가 있습니다.

자연 언어 이해와 강력한 데이터 검색을 결합하여 정확한 SQL 쿼리를 생성하는 새로운 접근법 인 Rag-to-SQL을 입력하십시오. Rag-to-SQL은 최고의 자연어 처리 및 정보 검색을 혼합하여 일상 언어를 데이터베이스의 의미있는 통찰력으로 전환하는보다 안정적인 방법을 제공합니다.

이 기사에서는 Rag-to-SQL이 특히 BigQuery 및 Vertex AI와 같은 Google Cloud 서비스를 사용하여 데이터베이스와 상호 작용하는 방식을 변환 할 수있는 방법을 살펴 보겠습니다.

학습 목표

• 사용자 의도를 정확하게 캡처 할 때 텍스트 간 SQL 시스템의 한계를 식별하십시오.
• 보다 신뢰할 수있는 SQL 쿼리를 생성하기위한 새로운 패러다임으로 Rag-to-SQL의 장점을 이해하십시오.
• BigQuery 및 Vertex AI와 같은 Google Cloud 서비스를 사용하여 Rag-to-SQL 접근 방식을 구현하십시오.
• Rag-to-SQL 구현을 위해 여러 Google 클라우드 도구를 통합하고 활용하는 방법을 알아보십시오.

이 기사는 Data Science Blogathon 의 일부로 출판되었습니다 .

목차

• 학습 목표
• 전통적인 텍스트 간 SQL 접근법의 한계
• Rag-to-SQL이란 무엇입니까?
• Google Cloud로 Rag-to-SQL 설정 : 단계별 가이드
  • 코드의 사전 반품
  • 코드 흐름도
  • 1 단계 : 필요한 라이브러리 설치
  • 2 단계 : Google 클라우드 프로젝트 및 자격 증명 구성
  • 3 단계 : 테이블 스키마 스토리지 용 벡터 데이터베이스 구축
  • 4 단계 : SQL 쿼리, 해석 및 에이전트 체인에 대한 LLM 모델 인스턴스화
  • 5 단계 : SQL 쿼리 체인 구성
  • 6 단계 : 해석을 위해 SQL 체인 출력을 정제합니다
  • 7 단계 : 쿼리 결과를위한 해석 체인 구축
  • 8 단계 : 동적 쿼리 라우팅을위한 에이전트 체인 구현
• 결론
  • 주요 테이크 아웃
• 자주 묻는 질문

전통적인 텍스트 간 SQL 접근법의 한계

LLM의 SQL 모델에 대한 텍스트의 주요 아이디어는 SQL에 대해 모르는 사람들이 데이터베이스와 상호 작용하고 자연어를 사용하여 정보를 얻을 수 있도록하는 것이 었습니다. 기존 텍스트 2 SQL 프레임 워크는 주로 LLM 지식에 의존하여 자연어 쿼리를 SQL 쿼리로 변환 할 수 있습니다. 이로 인해 SQL 쿼리가 잘못되거나 잘못 공식화 될 수 있습니다. 이곳은 SQL에 대한 새로운 접근 Rag가 다음 섹션에서 설명되는 구조에 오는 곳입니다.

Rag-to-SQL이란 무엇입니까?

텍스트의 단점을 SQL로 극복하기 위해 Rag의 혁신적인 접근 방식을 SQL로 사용할 수 있습니다. 데이터베이스에 대한 도메인 정보의 통합은 각 텍스트-SQL 소프트웨어가 직면 한 주요 문제입니다. RAG2SQL 아키텍처는 상황에 맞는 데이터 (메타 데이터, DDL, 쿼리 등)를 추가하여 이러한 어려움을 해결합니다. 이 데이터는 "훈련"되어 사용할 수 있습니다.
또한 "리트리버"는 가장 관련성이 높은 컨텍스트를 평가하고 전달하여 사용자 쿼리에 응답합니다. 최종 결과는 크게 개선되었습니다.

Google Cloud로 Rag-to-SQL 설정 : 단계별 가이드

BigQuery 및 Vertex AI와 같은 Google Cloud 서비스를 사용하여 Rag-to-SQL을 구현하려면 자세한 안내서를 따라 가십시오.

코드의 사전 반품

이 코드를 따르고 실행하려면 GCP (결제 정보가 포함 된 Google Cloud 계정)를 설정해야합니다. 처음에는 90 일 동안 무료 300 $ 시험을 제공하므로 요금이 부과되지 않습니다. 계정 설정에 대한 세부 사항 : 링크

코드 흐름도

아래는 다양한 코드 블록을 더 높은 수준에서 설명하는 코드 유량 차트입니다. 우리는 우리가 진행할 때 그것을 따르는 것을 참조 할 수 있습니다.

코드 구현은 3 개의 주요 블록으로 나눌 수 있습니다.

• SQL 쿼리 체인 : 이 체인은 사용자 질문과 벡터 DB에서 가져온 테이블의 관련 스키마를 기반으로 적절한 SQL 쿼리를 생성하는 책임이 있습니다.
• 해석 체인 : 이 체인은 이전 체인에서 SQL 쿼리를 가져 와서 BigQuery에서 실행 한 다음 결과를 사용하여 적절한 프롬프트로 응답을 생성합니다.
• 에이전트 체인 : 이것은 위의 두 체인을 캡슐화하는 최종 체인입니다. 사용자 질문이 발생할 때마다 SQL 쿼리 도구를 호출 할 것인지 또는 질문에 직접 답변할지 여부가 결정됩니다. 질문에 대답하는 데 필요한 작업에 따라 사용자 쿼리를 다양한 도구로 라우팅합니다.

1 단계 : 필요한 라이브러리 설치

Colab 노트북에서는이 구현에 필요한 아래 라이브러리를 설치해야합니다.

 ! PIP 설치 langchain == 0.0.340 -Quiet
! PIP 설치 ChromADB == 0.4.13 -Quiet
! PIP는 Google-Cloud-BigQuery [Pandas]를 설치합니다
! PIP는 Google-Cloud-Aiplatform을 설치합니다

2 단계 : Google 클라우드 프로젝트 및 자격 증명 구성

이제 GCP 프로젝트 및 큰 쿼리 데이터 세트를 초기화하기 위해 일부 변수를 선언해야합니다. 이 변수를 사용하면 노트북에서 GCP를 사용하여 큰 쿼리의 테이블에 액세스 할 수 있습니다.

GCP 클라우드 콘솔 에서이 세부 정보를 볼 수 있습니다. BigQuery에서는 데이터 세트를 만들 수 있으며 데이터 세트 내에서 테이블을 추가하거나 업로드 할 수 있습니다. 자세한 내용은 데이터 세트 및 생성 테이블 작성을 참조하십시오.

 vertex_project = "GCP 프로젝트 ID" # @param {type : "string"}
vertex_region = "us-central1" # @param {type : "string"}

bigQuery_dataset = "Big Query 데이터 세트 이름" # @param {type : "string"}
bigQuery_Project = "Vertex Project ID" # @param {type : "String"}

이제 Colab의 아래 코드를 사용하여 노트북에서 GCP Vertex AI에 인증하고 로그인하십시오.

 Google.Colab Import Auth에서
auth.authenticate_user ()

vertexai 가져 오기
vertexai.init (project = vertex_project, location = vertex_region)

3 단계 : 테이블 스키마 스토리지 용 벡터 데이터베이스 구축

이제 우리는 데이터 세트에 존재하는 다양한 테이블의 스키마를 포함 할 벡터 DB를 만들어야 하며이 벡터 DB 위에 리트리버를 만들어 워크 플로에 Rag를 통합 할 수 있습니다.

Python에서 BQ 클라이언트를 사용하여 큰 쿼리에 연결하고 테이블의 스키마를 가져옵니다.

 Google.Cloud에서 BigQuery 가져 오기
JSON 수입

#테이블의 스키마

bq_client = bigQuery.client (project = vertex_project)
bq_tables = bq_client.list_tables (dataset = f "{bigQuery_project}. {bigQuery_dataset}")
스키마 = []
bq_tables의 bq_table의 경우 :
   t = bq_client.get_table (f "{bigquery_project}. {bigQuery_dataset}. {bq_table.table_id}")
   schema_fields = [f.to_api_repr () t.schema에서 f의 경우]
   schema = f "테이블 {bq_table.table_id}의 스키마는 다음과 같습니다.
   Schemas.Append (스키마)

DataSet {bigQuery_project}에서 {f "{found {len (schemas)} 테이블 : {bigquery_dataset}")#import csv

Chroma DB와 같은 벡터 DB에 스키마를 저장합니다. “ data” 라는 폴더를 만들어야합니다.

 langchain.embeddings 가져 오기 vertexaiembeddings를 가져옵니다
Langchain에서 vectorstores import Chroma

임베딩 = vertexaiembeddings ()
시도 : # 복제 된 문서를 피하십시오
  vector_store.delete_collection ()
제외하고:
  인쇄 ( "벡터 스토어를 청소할 필요 없음")
vector_store = Chroma.from_texts (Schemas, Embedding = Embeddings, persist_directory = './data')
n_docs = len (vector_store.get () [ 'ids'])
Retriever = vector_store.as_retriever (search_kwargs = { 'k': 2})
print (f "벡터 스토어에는 {n_docs} 문서가 있습니다")

4 단계 : SQL 쿼리, 해석 및 에이전트 체인에 대한 LLM 모델 인스턴스화

우리는 3 개의 다른 체인에 대한 3 LLM 모델을 인스턴스화 할 것입니다.

첫 번째 모델은 사용자 질문과 유사한 벡터 DB에서 검색된 사용자 질문 및 테이블 스키마를 기반으로 SQL 쿼리를 생성하는 쿼리 모델입니다. 이를 위해 우리는 "Codechat-지시"를 사용하고 있습니다. 모델 . 이 모델은 다양한 코딩 언어로 코드를 생성하는 데 전문적이므로 사용 사례에 적합합니다.

다른 2 가지 모델은 Chatvertexai의 기본 LLM 모델입니다.“ Gemini-1.5-Flash-001 ”이는 Chat 및 빠른 응답에 최적화 된 최신 Gemini 모델입니다.

 langchain.chat_models에서 chatvertexai를 가져옵니다
langchain.llms import vertexai에서

query_model = chatvertexai (model_name = "codechat-bison", max_output_tokens = 1000)
Induct_Data_Model = ChatVertexai (max_output_tokens = 1000)
agent_model = chatvertexai (max_output_tokens = 1024)

5 단계 : SQL 쿼리 체인 구성

다음은 입력 사용자 질문에 대한 SQL 쿼리를 생성하는 데 사용되는 SQL 프롬프트입니다.

 SQL_PROMPT = "" "귀하는 SQL 및 BigQuery 전문가입니다.

귀하의 임무는 SQL에서 BigQuery에 대한 쿼리를 만드는 것입니다.

다음 단락에는 쿼리에 사용되는 테이블 스키마가 포함되어 있습니다. JSON 형식으로 인코딩됩니다.

{문맥}

위의 표를 사용하여 다음 사용자 입력을 위해 BigQuery SQL 쿼리를 만듭니다.
SQL 쿼리에 대한 스키마에서 언급 된 열만 사용

사용자와 에이전트는 지금 까지이 대화를 수행했습니다.
{chat_history}

이 제한 사항을 엄격하게 따르십시오.
- SQL 코드 만 반환하십시오.
- 백틱이나 마크 업을 추가하지 마십시오. 쿼리를 출력으로만 작성하십시오. 다른 것은 없습니다.
-에서`{project}`를 프로젝트로 사용하고`{dataSet}`을 데이터 세트로 사용하여 항상 전체 테이블 경로를 사용하십시오.
- 항상 국가 이름을 전체 대문자로 변환하십시오. 예를 들어, 국가가 일본인 경우 일본을 쿼리에 사용해야합니다.

사용자 입력 : {Question}

SQL 쿼리 :
"" "

이제 우리는 사용자 질문 입력에 대한 관련 문서, 즉 스키마를 검색하는 함수를 정의합니다.

 langchain.schema에서 vectorstore import vectorstoreretriever
def get_documents (Retriever : VectorStoreretriever, 질문 : str) -> str :
  # 첫 번째 문서 만 반환합니다
  출력 = ""
  retriever.get_relevant_documents (Question)에서 d의 경우 :
    출력 = d.page_content
    출력 = "\ n"
    반환 출력

그런 다음 Langchain 표현 언어 구문을 사용하여 LLM 체인을 정의합니다. 참고 우리는 5 개의 자리 표시 자 변수로 프롬프트를 정의하고 나중에 2 개의 자리 표시 자 변수 프로젝트 및 데이터 세트를 작성하여 부분 프롬프트를 정의합니다. 나머지 변수는 입력, 채팅 기록 및 컨텍스트의 정의 된 기능으로 구성된 수신 요청 사전으로 채워질 것입니다.

 운영자에서 ItemGetter를 가져옵니다
langchain.prompts import prompttemplate
Langchain.schema import Stroutputparser에서

Prompt_template = PrustTemplate (
    input_variables = [ "context", "Chat_history", "Question", "Project", "DataSet"],
    템플릿 = sql_prompt)

partial_prompt = prompt_template.partial (project = bigQuery_project,
                                         DataSet = bigQuery_Dataset)

# 입력은 { "input": "some_question", "Chat_history": "history"}과 같습니다.
docs = { "Context": Lambda x : get_documents (Retriever, x [ 'input'])}
Question = { "Question": ItemGetter ( "입력")}
chat_history = { "chat_history": itemgetter ( "chat_history")}
query_chain = 문서 | 질문 | chat_history | partial_prompt | query_model
query = query_chain | Stroutputparser ()

Langchain의 콜백 처리기를 사용하여 체인을 테스트하여 체인 실행 단계를 자세히 보여줄 각 단계를 테스트하겠습니다.

 Langchain.callbacks.Tracers에서 ConsoleCallbackHandler를 가져옵니다
# 예
x = { "입력": "시작 스테이션이 Atlantic Ave & Fort Greene PL에서 온 여행 기간", "Chat_history": ""}
print (query.invoke (x, config = { 'Callbacks': [ConsoleCallbackHandler ()])))) 

6 단계 : 해석을 위해 SQL 체인 출력을 정제합니다

위의 SQL 체인 출력을 세분화하여 다른 변수를 ALLP에 포함시켜 두 번째 체인 - 해석 체인으로 전달됩니다.

 langchain.output_parsers에서 reptrationschema, studuredoutputparser를 가져옵니다
langchain.schema에서 runnablelambda

#사전 형식의 출력에 다른 변수를 포함하도록 체인 출력을 Refine
def _dict_to_json (x : dict) -> str :
  "````\ n"json.dumps (x) "\ n```````는 반환합니다.

query_response_schema = [
    responseeschema (name = "query", description = "사용자 질문을 해결하려면 SQL 쿼리"),
    ResponseSchema (name = "Question", description = "사용자가 질문 한 질문"),
    responseeschema (이름 = "context", description = "벡터 저장소에서 검색된 문서")
  ]]
query_output_parser = producturedoutputparser.from_response_schemas (query_response_schema)
query_output_json = 문서 | 질문 | { "쿼리": 쿼리} | runnablelambda (_dict_to_json) | Stroutputparser ()
query_output = query_output_json | query_output_parser

이 체인을 실행하려고합니다.

 # 예
x = { "입력": "여행 기간이 가장 높은 2 개의 시작 스테이션을 제공합니까?", "Chat_history": ""}
output = query_output.invoke (x) # 출력은 이제 사전, 다음 체인의 입력입니다.

위의 정제 체인의 출력이 SQL 쿼리임을 볼 수 있습니다.

7 단계 : 쿼리 결과를위한 해석 체인 구축

이제 위에서 정의 된 SQL 쿼리 체인의 출력을 취할 다음 체인을 구축해야합니다. 이 체인은 이전 체인에서 SQL 쿼리를 가져 와서 큰 쿼리로 실행하고 결과를 사용하여 적절한 프롬프트를 사용하여 응답을 생성하는 데 사용됩니다.

 Indupl_Prompt = "" ""귀하는 BigQuery Expert입니다. CSV에서 데이터를 추출하는 전문가입니다.

다음 단락은 쿼리에 사용 된 테이블의 스키마를 설명합니다. JSON 형식으로 인코딩됩니다.

{문맥}

사용자 가이 질문을했습니다.
{질문}

답을 찾기 위해 다음 SQL 쿼리가 BigQuery에서 실행되었습니다.
```
{질문}
```

해당 쿼리의 결과는 CSV 형식의 다음 표였습니다.
```
{결과}
```

이러한 결과를 기반으로 사용자 질문에 대한 간단한 답변을 제공하십시오.

이 제한 사항을 엄격하게 따르십시오.
- 답변을 얻는 방법에 대한 설명을 추가하지 마십시오. 답을 작성하십시오.
- 쿼리 결과에서만 답과 관련된 값을 추출하십시오. 다른 데이터 소스를 사용하지 마십시오.
- 답을 쓰고 답변에서 질문을 생략하십시오. 이것은 채팅이며 답을 제공하십시오.
- 결과에서 답을 찾을 수 없다면 데이터를 구성하지 마십시오. "답을 찾을 수 없습니다"라고 말하십시오.
"" "

 Google.Cloud에서 BigQuery 가져 오기
def get_bq_csv (bq_client : bigquery.client, query : str) -> str :
  cleaned_query = clean_query (query)
  df = bq_client.query (cleaned_query, location = "us"). to_dataframe ()
  반환 df.to_csv (index = false)


def clean_query (query : str) :
  query = query.replace ( "```SQL", "")
  cleaned_query = query.replace ( "````", "")

  Cleaned_Query를 반환합니다

우리는 두 가지 함수를 정의합니다. 이것은 clean_query입니다 - 이것은 Apostrophes 및 기타 불필요한 문자의 SQL 쿼리를 정리하고 다른 불필요한 문자는 get_bq_csv입니다. 이것은 Cleaned SQL 쿼리를 큰 쿼리에서 실행하고 CSV 형식으로 출력 테이블을 얻습니다.

 # 이전 체인의 출력을 얻으십시오


query = { "query": itemgetter ( "query")}
Context = { "Context": itemGetter ( "Context")}
Question = { "Question": ItemGetter ( "Question")}
#cleaned_query = { "결과": Lambda X : Clean_Query (x [ "query"])}
query_result = { "result": lambda x : get_bq_csv (bq_client, x [ "query"])}

프롬프트 = PrustTemplate (
    input_variables = [ "Question", "Query", "result", "context"],
    템플릿 = 해석 _prompt)

run_bq_chain = 컨텍스트 | 질문 | 쿼리 | query_result | 즉각적인
run_bq_result = run_bq_chain | 해석 _data_model | Stroutputparser ()

체인을 실행하고 테스트합시다.

 # 예
x = { "입력": "여행 기간이 가장 높은 2 개의 시작 스테이션을 제공합니까?", "Chat_history": ""}
final_response = run_bq_result.invoke (query_output.invoke (x))
print (final_response)

8 단계 : 동적 쿼리 라우팅을위한 에이전트 체인 구현

이제 우리는 에이전트 체인 인 최종 체인을 구축 할 것입니다. 사용자가 질문을하면 SQL 쿼리 도구를 사용할지 또는 직접 대답할지 여부를 결정합니다. 기본적으로 사용자의 문의에 답하기 위해 완료 해야하는 작업에 따라 사용자 쿼리를 다양한 도구로 보냅니다.

Agent_Memory, 에이전트 프롬프트, 도구 기능을 정의합니다.

 Langchain에서 Memory 가져 오기 대화 BufferWindowMemory

Agent_Memory = ConfertionBufferWindowMemory (
    memory_key = "chat_history",
    k = 10,
    return_messages = true)

 Agent_prompt = "" ""당신은 BigQuery를 사용하여 질문에 대답 할 수있는 매우 강력한 조수입니다.

도구 user_question_tool을 호출하여 BigQuery를 사용하여 질문에 답변 할 수 있습니다.

항상 도구를 사용하여 질문에 답하십시오. 컨텍스트에 채팅 기록을 사용하십시오. 다른 외부 정보를 사용하지 마십시오.

사용자가 철자로 쓸 수 있다고 가정하고 질문을 모든 도구에 전달하기 전에 사용자의 철자를 수정하십시오.

답에 사용한 도구를 언급하지 마십시오.
"" "

 Langchain에서 Tools 가져 오기 도구
Langchain.callbacks.Tracers에서 ConsoleCallbackHandler를 가져옵니다

@도구
def user_question_tool (Question) -> str :
  "" "BigQuery를 사용하는 사용자의 자연 언어 질문에 대답하는 데 유용합니다." ""
  config = { 'Callbacks': [ConsoleCallbackHandler ()]}
  config = {}
  메모리 = agent_memory.buffer_as_str.strip ()
  Question = { "입력": Question, "Chat_history": memory}
  query = query_output.invoke (질문, config = config)
  print ( "\ n \ n ********************* \ n \ n")
  print (query [ 'query'])
  print ( "\ n \ n ********************* \ n \ n")
  결과 = run_bq_result.invoke (query, config = config)
  return result.strip ()

우리는 이제 에이전트의 모든 주요 구성 요소를 모아서 에이전트를 초기화합니다.

 langchain.agents import agenttype, initialize_agent, agentexecutor

agent_kwgards = { "System_Message": agent_prompt}
agent_tools = [user_question_tool]

agent_memory.clear ()

에이전트 = initialize_agent (
    도구 = Agent_Tools,
    llm = agent_model,
    에이전트 = agenttype.chat_conversational_react_description,
    메모리 = agent_memory,
    agent_kwgards = agent_kwgards,
    max_iterations = 5,
    early_stopping_method = 'Generate',
    verbose = true)

지금 에이전트를 실행하자.

 Q = "여행 기간이 가장 높은 2 개의 스타트 스테이션을 줘?"
Agent.invoke (Q) 

에이전트에 대한 후속 질문.

 Q = "이 스테이션 이름 각각의 용량은 얼마입니까?"
Agent.invoke (Q) 

관찰

에이전트는 복잡한 질문을 정확하게 처리하고 채팅 기록을 기반으로 다음 질문에 대한 정답을 생성 한 다음 다른 테이블을 사용하여 Citi 자전거의 용량 정보를 얻었습니다.

결론

Rag-to-SQL 접근법은 상황에 맞는 데이터를 통합하고 검색 기술을 활용하여 전통적인 텍스트-SQL 모델의 한계를 해결하는 데 중요한 발전을 나타냅니다. 이 방법론은 벡터 데이터베이스에서 관련 스키마 정보를 검색하여 쿼리 정확도를 향상시켜보다 정확한 SQL 생성을 허용합니다. BigQuery 및 Vertex AI와 같은 Google 클라우드 서비스 내에서 Rag-to-SQL을 구현하면 실제 응용 프로그램에서 확장 성과 효과가 나타납니다. 쿼리 처리에서 의사 결정 프로세스를 자동화함으로써 Rag-to-SQL은 비 기술적 사용자가 데이터베이스와 완벽하게 상호 작용하면서 높은 정밀도를 유지할 수있는 새로운 가능성을 엽니 다.

주요 테이크 아웃

• Text-to-SQL 제한은 메타 데이터를 통합하여 전통적인 텍스트-SQL 모델의 일반적인 함정을 해결합니다.
• 에이전트 기반 시스템은 사용자 쿼리를 처리하는 방법을 효율적으로 결정하여 유용성을 향상시킵니다.
• Rag-to-SQL을 사용하면 기술이 아닌 사용자가 자연어 입력으로 복잡한 SQL 쿼리를 생성 할 수 있습니다.
• 이 접근 방식은 BigQuery 및 Vertex AI와 같은 서비스를 사용하여 성공적으로 구현됩니다.

자주 묻는 질문

Q1. gcp vertex ai 액세스가 무료입니까?

A. 아니요, 그러나 처음 등록하면 300 달러의 크레딧으로 90 일의 시험 기간을받을 수 있으며 액세스를위한 카드 세부 정보 만 제공하면됩니다. 카드에서 요금이 공제되지 않으며 300 달러 이상의 크레딧을 넘어 소비하는 서비스를 사용하더라도 Google은 서비스를 사용할 수 있도록 결제 계정을 활성화하도록 요청합니다. 따라서 금액의 자동 공제는 없습니다.

Q2. Rag에 SQL을 사용하면 무엇이 이점이 있습니까?

A.이를 통해 여러 테이블을 사용하는 경우 LLM에 공급되는 테이블 스키마를 자동화 할 수 있습니다. 모든 테이블 스키마를 한 번에 공급할 필요가 없습니다. 사용자 쿼리를 기반으로 관련 테이블 스키마를 걸레에서 가져올 수 있습니다. 따라서, 기존 텍스트에 대한 SQL 시스템에 대한 효율성이 높아집니다.

Q3. 이 사용 사례에 에이전트가 어떻게 유용 할 수 있습니까?

A. 전체적인 챗봇을 구축하는 경우 SQL 쿼리 도구 외에 다른 많은 도구가 필요할 수 있습니다. 따라서 에이전트를 활용하고 웹 검색, 데이터베이스 SQL 쿼리 도구, 기타 RAG 도구 또는 API 도구를 호출하는 기능과 같은 여러 도구를 제공 할 수 있습니다. 이를 통해 사용자 쿼리에 응답하기 위해 수행 해야하는 작업을 기반으로 다양한 유형의 사용자 쿼리를 처리 할 수 ​​있습니다.

이 기사에 표시된 미디어는 분석 Vidhya가 소유하지 않으며 저자의 재량에 따라 사용됩니다.

위 내용은 Google Cloud의 Rag-to-SQL의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!