Memulai pengambilan semantik

Lihat di ai.google.dev Coba notebook Colab Lihat notebook di GitHub

Ringkasan

Model Bahasa Besar (LLM) dapat mempelajari kemampuan baru tanpa dilatih langsung. Namun, LLM sudah diketahui bisa "berhalusinasi" ketika ditugaskan untuk menjawab pertanyaan yang belum dilatih. Hal ini sebagian karena LLM tidak mengetahui event setelah pelatihan. Selain itu, sangat sulit untuk melacak sumber dari mana LLM mengambil respons mereka. Untuk aplikasi yang andal dan skalabel, LLM harus memberikan respons yang didasarkan pada fakta dan dapat mengutip sumber informasinya.

Pendekatan umum yang digunakan untuk mengatasi kendala ini disebut Retrieval Augmented Generation (RAG), yang meningkatkan prompt yang dikirim ke LLM dengan data relevan yang diambil dari pusat informasi eksternal melalui mekanisme Pengambilan Informasi (IR). Basis informasi dapat berupa korpora dokumen, database, atau API Anda sendiri.

Notebook ini akan memandu Anda dalam alur kerja untuk meningkatkan respons LLM dengan menambah pengetahuannya menggunakan korpora teks eksternal, dan melakukan pengambilan informasi semantik guna menjawab pertanyaan menggunakan Semantic Retriever dan Attributed Question & API Penjawaban (AQA) dari Generative Language API.

Penyiapan

Mengimpor Generative Language API

# Install the Client library (Semantic Retriever is only supported for versions >0.4.0)
pip install -U google.ai.generativelanguage

Autentikasikan

Semantic Retriever API memungkinkan Anda melakukan penelusuran semantik pada data Anda sendiri. Karena merupakan data Anda, kontrol akses yang lebih ketat diperlukan daripada kunci API. Autentikasi dengan OAuth dengan akun layanan atau melalui kredensial pengguna Anda.

Panduan memulai ini menggunakan pendekatan autentikasi sederhana yang ditujukan untuk lingkungan pengujian, dan pembuatan akun layanan biasanya lebih mudah untuk dimulai. Untuk lingkungan produksi, pelajari autentikasi dan otorisasi sebelum memilih kredensial akses yang sesuai untuk aplikasi Anda.

Menyiapkan OAuth menggunakan akun layanan

Ikuti langkah-langkah di bawah untuk menyiapkan OAuth menggunakan akun layanan:

  1. Aktifkan Generative Language API.

  1. Buat Akun Layanan dengan mengikuti dokumentasi.

    • Setelah membuat akun layanan, buat kunci akun layanan.

  1. Upload file akun layanan Anda menggunakan ikon file di sidebar kiri, lalu ikon upload, seperti yang ditunjukkan pada screenshot di bawah.

    • Ganti nama file yang diupload menjadi service_account_key.json atau ubah variabel service_account_file_name pada kode di bawah.

pip install -U google-auth-oauthlib

service_account_file_name = 'service_account_key.json'

from google.oauth2 import service_account

credentials = service_account.Credentials.from_service_account_file(service_account_file_name)

scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/cloud-platform', 'https://www.googleapis.com/auth/generative-language.retriever'])

Lakukan inisialisasi library klien menggunakan kredensial akun layanan.

import google.ai.generativelanguage as glm
generative_service_client = glm.GenerativeServiceClient(credentials=scoped_credentials)
retriever_service_client = glm.RetrieverServiceClient(credentials=scoped_credentials)
permission_service_client = glm.PermissionServiceClient(credentials=scoped_credentials)

Membuat korpus

Semantic Retriever API memungkinkan Anda menentukan hingga 5 korpora teks kustom per project. Anda dapat menentukan salah satu kolom berikut saat menentukan korpora:

  • name: Nama resource (ID) Corpus. Hanya boleh berisi maksimal 40 karakter alfanumerik. Jika name kosong saat pembuatan, nama unik akan dibuat dengan panjang maksimum 40 karakter dengan awalan dari display_name dan akhiran acak 12 karakter.
  • display_name: Nama tampilan yang dapat dibaca manusia untuk Corpus. Hanya boleh berisi maksimal 512 karakter, termasuk alfanumerik, spasi, dan tanda hubung.
example_corpus = glm.Corpus(display_name="Google for Developers Blog")
create_corpus_request = glm.CreateCorpusRequest(corpus=example_corpus)

# Make the request
create_corpus_response = retriever_service_client.create_corpus(create_corpus_request)

# Set the `corpus_resource_name` for subsequent sections.
corpus_resource_name = create_corpus_response.name
print(create_corpus_response)

name: "corpora/google-for-developers-blog-dqrtz8rs0jg"
display_name: "Google for Developers Blog"
create_time {
  seconds: 1713497533
  nanos: 587977000
}
update_time {
  seconds: 1713497533
  nanos: 587977000
}

Mendapatkan korpus yang dibuat

Gunakan metode GetCorpusRequest untuk mengakses secara terprogram Corpus yang Anda buat di atas. Nilai parameter name mengacu pada nama lengkap resource Corpus dan ditetapkan dalam sel di atas sebagai corpus_resource_name. Format yang diharapkan adalah corpora/corpus-123.

get_corpus_request = glm.GetCorpusRequest(name=corpus_resource_name)

# Make the request
get_corpus_response = retriever_service_client.get_corpus(get_corpus_request)

# Print the response
print(get_corpus_response)

Buat dokumen

Corpus dapat berisi hingga 10.000 Document. Anda dapat menentukan salah satu kolom berikut saat menentukan dokumen:

  • name: Nama resource (ID) Document. Hanya boleh berisi maksimal 40 karakter (alfanumerik atau tanda hubung saja). ID tidak boleh diawali atau diakhiri dengan tanda hubung. Jika nama tersebut kosong saat pembuatan, nama unik akan diambil dari display_name dengan akhiran acak 12 karakter.
  • display_name: Nama tampilan yang dapat dibaca manusia. Hanya boleh berisi maksimal 512 karakter, termasuk alfanumerik, spasi, dan tanda hubung.

Document juga mendukung hingga 20 kolom custom_metadata yang ditentukan pengguna, yang ditentukan sebagai pasangan nilai kunci. Metadata kustom dapat berupa string, daftar string, atau numerik. Perhatikan bahwa daftar string dapat mendukung maksimum 10 nilai dan nilai numerik dinyatakan sebagai angka floating point di API.

# Create a document with a custom display name.
example_document = glm.Document(display_name="Introducing Project IDX, An Experiment to Improve Full-stack, Multiplatform App Development")

# Add metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

Mendapatkan dokumen yang dibuat

Gunakan metode GetDocumentRequest untuk mengakses dokumen yang Anda buat di atas secara terprogram. Nilai parameter name mengacu pada nama resource lengkap dokumen dan ditetapkan dalam sel di atas sebagai document_resource_name. Format yang diharapkan adalah corpora/corpus-123/documents/document-123.

get_document_request = glm.GetDocumentRequest(name=document_resource_name)

# Make the request
# document_resource_name is a variable set in the "Create a document" section.
get_document_response = retriever_service_client.get_document(get_document_request)

# Print the response
print(get_document_response)

Serap & Potong Dokumen

Untuk meningkatkan relevansi konten yang ditampilkan oleh database vektor selama pengambilan semantik, uraikan dokumen besar menjadi bagian atau bagian yang lebih kecil saat menyerap dokumen.

Chunk adalah subbagian dari Document yang diperlakukan sebagai unit independen untuk tujuan representasi dan penyimpanan vektor. Chunk dapat memiliki maksimal 2043 token. Corpus dapat memiliki maksimum 1 juta Chunk.

Serupa dengan Document, Chunks juga mendukung maksimal 20 kolom custom_metadata yang ditentukan pengguna, yang ditentukan sebagai pasangan nilai kunci. Metadata kustom dapat berupa string, daftar string, atau numerik. Perhatikan bahwa daftar string dapat mendukung maksimum 10 nilai dan nilai numerik dinyatakan sebagai angka floating point di API.

Panduan ini menggunakan HTMLChunker Open Source Google.

Potongan besar lain yang dapat Anda gunakan meliputi LangChain atau LlamaIndex.

Serap HTML dan potong melalui HTMLChunker

!pip install google-labs-html-chunker

from google_labs_html_chunker.html_chunker import HtmlChunker

from urllib.request import urlopen

Dapatkan DOM HTML untuk situs web. Di sini, HTML dibaca secara langsung, tetapi lebih baik mendapatkan HTML pasca-rendering untuk menyertakan HTML yang dimasukkan JavaScript misalnya document.documentElement.innerHTML.

with(urlopen("https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")) as f:
  html = f.read().decode("utf-8")

Uraikan dokumen teks menjadi beberapa bagian dan buat Chunk dari bagian-bagian ini. Langkah ini akan membuat objek Chunk itu sendiri dan bagian berikutnya menguploadnya ke Semantic Retriever API.

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=200,
    greedily_aggregate_sibling_nodes=True,
    html_tags_to_exclude={"noscript", "script", "style"},
)
passages = chunker.chunk(html)
print(passages)


# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    # Optionally, you can add metadata to a chunk
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Project IDX", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="greedily_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20230808))
    chunks.append(chunk)
print(chunks)

Membuat potongan secara batch

Membuat potongan dalam batch. Anda dapat menentukan maksimum 100 potongan per permintaan batch.

Gunakan CreateChunk() untuk pembuatan satu bagian.

# Option 1: Use HtmlChunker in the section above.
# `chunks` is the variable set from the section above.
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Sebagai alternatif, Anda dapat membuat potongan tanpa menggunakan HTMLChunker.

# Add up to 100 CreateChunk requests per batch request.
# document_resource_name is a variable set in the "Create a document" section.
chunks = []
chunk_1 = glm.Chunk(data={'string_value': "Chunks support user specified metadata."})
chunk_1.custom_metadata.append(glm.CustomMetadata(key="section",
                                                  string_value="Custom metadata filters"))
chunk_2 = glm.Chunk(data={'string_value': "The maximum number of metadata supported is 20"})
chunk_2.custom_metadata.append(glm.CustomMetadata(key = "num_keys",
                                                  numeric_value = 20))
chunks = [chunk_1, chunk_2]
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Mencantumkan Chunk dan mendapatkan status

Gunakan metode ListChunksRequest untuk mendapatkan semua Chunk yang tersedia sebagai daftar yang diberi nomor halaman dengan batas ukuran maksimum 100 Chunk per halaman, yang diurutkan dalam urutan menaik Chunk.create_time. Jika Anda tidak menentukan batas, maksimum 10 Chunk akan ditampilkan.

Berikan next_page_token yang ditampilkan dalam respons ListChunksRequest sebagai argumen bagi permintaan berikutnya untuk mengambil halaman berikutnya. Perhatikan bahwa saat memberi nomor halaman, semua parameter lain yang diberikan ke ListChunks harus cocok dengan panggilan yang menyediakan token halaman.

Semua Chunk menampilkan state. Gunakan ini untuk memeriksa status Chunks sebelum membuat kueri Corpus. Status Chunk mencakup - UNSPECIFIED, PENDING_PROCESSING, ACTIVE, dan FAILED. Anda hanya dapat mengajukan kueri ACTIVE Chunk.

# Make the request
request = glm.ListChunksRequest(parent=document_resource_name)
list_chunks_response = retriever_service_client.list_chunks(request)
for index, chunks in enumerate(list_chunks_response.chunks):
  print(f'\nChunk # {index + 1}')
  print(f'Resource Name: {chunks.name}')
  # Only ACTIVE chunks can be queried.
  print(f'State: {glm.Chunk.State(chunks.state).name}')

Serap dokumen lain

Tambahkan Document lain melalui HTMLChunker dan tambahkan filter.

# Create a document with a custom display name.
example_document = glm.Document(display_name="How it’s Made: Interacting with Gemini through multimodal prompting")

# Add document metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the CreateDocument request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

# Chunks - add another webpage from Google for Developers
with(urlopen("https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")) as f:
  html = f.read().decode("utf-8")

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=100,
    greedily_aggregate_sibling_nodes=False,
)
passages = chunker.chunk(html)

# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Gemini API", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="no_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20231206))
    chunks.append(chunk)

# Make the request
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Membuat kueri korpus

Gunakan metode QueryCorpusRequest untuk melakukan penelusuran semantik guna mendapatkan bagian yang relevan.

  • results_count: Menentukan jumlah bagian yang akan ditampilkan. Jumlah maksimumnya adalah 100. Jika tidak ditentukan, API akan menampilkan maksimum 10 Chunk.
  • metadata_filters: Filter menurut chunk_metadata atau document_metadata. Setiap MetadataFilter harus sesuai dengan kunci unik. Beberapa objek MetadataFilter digabungkan dengan AND yang logis. Kondisi filter metadata yang serupa digabungkan dengan OR yang logis. Beberapa contohnya:
(year >= 2020 OR year < 2010) AND (genre = drama OR genre = action)

metadata_filter = [
  {
    key = "document.custom_metadata.year"
    conditions = [
      {int_value = 2020, operation = GREATER_EQUAL},
      {int_value = 2010, operation = LESS}]
  },
  {
    key = "document.custom_metadata.genre"
    conditions = [
      {string_value = "drama", operation = EQUAL},
      {string_value = "action", operation = EQUAL} }]
  }]

Perhatikan bahwa hanya nilai numerik yang mendukung "AND" untuk kunci yang sama. {i>String<i} nilai tersebut hanya mendukung "OR" untuk kunci yang sama.

("Google for Developers" in tags) and (20230314 > publish_date)

metadata_filter = [
 {
    key = "chunk.custom_metadata.tags"
    conditions = [
    {string_value = 'Google for Developers', operation = INCLUDES},
  },
  {
    key = "chunk.custom_metadata.publish_date"
    conditions = [
    {numeric_value = 20230314, operation = GREATER_EQUAL}]
  }]

user_query = "What is the purpose of Project IDX?"
results_count = 5

# Add metadata filters for both chunk and document.
chunk_metadata_filter = glm.MetadataFilter(key='chunk.custom_metadata.tags',
                                           conditions=[glm.Condition(
                                              string_value='Google For Developers',
                                              operation=glm.Condition.Operator.INCLUDES)])

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.QueryCorpusRequest(name=corpus_resource_name,
                                 query=user_query,
                                 results_count=results_count,
                                 metadata_filters=[chunk_metadata_filter])
query_corpus_response = retriever_service_client.query_corpus(request)
print(query_corpus_response)

Tanya Jawab yang Diatribusikan

Gunakan metode GenerateAnswer untuk melakukan Tanya Jawab Beratribusi pada dokumen, korpus, atau sekumpulan bagian.

Attributed Question-Answering (AQA) mengacu pada menjawab pertanyaan yang didasarkan pada konteks tertentu dan memberikan atribusi, sekaligus meminimalkan halusinasi.

GenerateAnswer memberikan beberapa keuntungan dibandingkan menggunakan LLM yang tidak disesuaikan, jika AQA diinginkan:

  • Model yang mendasarinya telah dilatih untuk hanya menampilkan jawaban yang didasarkan pada konteks yang diberikan.
  • Bagian ini mengidentifikasi atribusi (segmen dari konteks yang diberikan yang berkontribusi pada jawaban). Atribusi memungkinkan pengguna memverifikasi jawaban.
  • Fitur ini memperkirakan answerable_probability untuk pasangan (pertanyaan, konteks) tertentu, yang makin memberdayakan Anda untuk mengalihkan perilaku produk, bergantung pada seberapa besar kemungkinan jawaban yang ditampilkan didasarkan dan benar.

answerable_probability dan masalah “Saya tidak tahu”

Dalam beberapa kasus, jawaban terbaik terhadap pertanyaan tersebut adalah “Saya tidak tahu”. Misalnya, jika konteks yang diberikan tidak berisi jawaban atas suatu pertanyaan, maka pertanyaan tersebut dianggap “tidak dapat dijawab”.

Model AQA sangat mahir dalam mengenali kasus semacam itu. Bahkan, alat ini dapat membedakan tingkat kemampuan yang dapat dijawab dan tidak dapat dijawab.

Namun, GenerateAnswer API memberikan kendali penuh atas pengambilan keputusan di tangan Anda dengan:

  • Selalu berusaha menampilkan jawaban dasar - meski jawaban tersebut kemungkinan tidak beralasan dan benar.
  • Menampilkan nilai answerable_probability - Perkiraan model tentang probabilitas bahwa jawaban tersebut didasarkan dan benar.

answerable_probability rendah dapat dijelaskan oleh 1 atau beberapa faktor berikut:

  • Model tidak yakin bahwa jawabannya benar.
  • Model tidak yakin bahwa jawabannya didasarkan pada bagian yang dikutip; Jawabannya mungkin diperoleh dari pengetahuan dunia. Misalnya: question="1+1=?", passages=["2+2=4”] → answer=2, answerable_probability=0.02
  • Model memberikan informasi relevan yang tidak sepenuhnya menjawab pertanyaan. Contoh: question="Is it available in my size?, passages=["Available in sizes 5-11"] → answer="Yes it is available in sizes 5-11", answerable_probability=0.03"
  • Tidak ada pertanyaan yang disusun dengan baik di GenerateAnswerRequest.

Karena answerable_probability yang rendah menunjukkan bahwa GenerateAnswerResponse.answer mungkin salah atau tidak didasarkan, sangat disarankan untuk memproses respons lebih lanjut dengan memeriksa answerable_probability.

Jika answerable_probability rendah, beberapa klien mungkin ingin:

  • Menampilkan pesan sebagai efek "tidak dapat menjawab pertanyaan tersebut" kepada pengguna akhir.
  • Kembali ke LLM tujuan umum yang menjawab pertanyaan dari pengetahuan dunia. Batas dan sifat penggantian tersebut akan bergantung pada kasus penggunaan individual. Nilai answerable_probability <= 0,5 adalah nilai minimum awal yang baik.

Tips Bermanfaat AQA

Untuk spesifikasi API lengkap, lihat Referensi API GenerateAnswerRequest.

  • Panjang bagian: Maksimal 300 token per bagian.
  • Penyortiran bagian:
  • Keterbatasan: Model AQA dikhususkan untuk proses menjawab pertanyaan. Untuk kasus penggunaan lainnya seperti penulisan kreatif, perangkuman, dll., panggil model tujuan umum melalui GenerateContent.
    • Chat: Jika input pengguna diketahui sebagai pertanyaan yang mungkin dapat dijawab dari konteks tertentu, AQA dapat menjawab kueri chat. Tetapi jika input pengguna bisa berupa jenis entri apa pun, model dengan tujuan umum mungkin merupakan pilihan yang lebih baik.
  • Suhu:
    • Umumnya, suhu yang relatif rendah (~0,2) direkomendasikan untuk AQA yang akurat.
    • Jika kasus penggunaan Anda bergantung pada output determenistik, tetapkan temperature=0.
user_query = "What is the purpose of Project IDX?"
answer_style = "ABSTRACTIVE" # Or VERBOSE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
content = glm.Content(parts=[glm.Part(text=user_query)])
retriever_config = glm.SemanticRetrieverConfig(source=corpus_resource_name, query=content)
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[content],
                                semantic_retriever=retriever_config,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

# Get the metadata from the first attributed passages for the source
chunk_resource_name = aqa_response.answer.grounding_attributions[0].source_id.semantic_retriever_chunk.chunk
get_chunk_response = retriever_service_client.get_chunk(name=chunk_resource_name)
print(get_chunk_response)

Opsi Lainnya: AQA Menggunakan Bagian Inline

Atau, Anda dapat menggunakan endpoint AQA secara langsung, tanpa menggunakan Semantic Retriever API dengan meneruskan inline_passages.

user_query = "What is AQA from Google?"
user_query_content = glm.Content(parts=[glm.Part(text=user_query)])
answer_style = "VERBOSE" # or ABSTRACTIVE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Create the grounding inline passages
grounding_passages = glm.GroundingPassages()
passage_a = glm.Content(parts=[glm.Part(text="Attributed Question and Answering (AQA) refers to answering questions grounded to a given corpus and providing citation")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_a, id="001"))
passage_b = glm.Content(parts=[glm.Part(text="An LLM is not designed to generate content grounded in a set of passages. Although instructing an LLM to answer questions only based on a set of passages reduces hallucination, hallucination still often occurs when LLMs generate responses unsupported by facts provided by passages")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_b, id="002"))
passage_c = glm.Content(parts=[glm.Part(text="Hallucination is one of the biggest problems in Large Language Models (LLM) development. Large Language Models (LLMs) could produce responses that are fictitious and incorrect, which significantly impacts the usefulness and trustworthiness of applications built with language models.")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_c, id="003"))

# Create the request
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[user_query_content],
                                inline_passages=grounding_passages,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

Membagikan korpus

Anda dapat memilih untuk membagikan korpus kepada orang lain menggunakan CreatePermissionRequest API.

{i>Constraints<i} (Batasan):

  • Ada 2 peran untuk berbagi: READER dan EDITOR.
    • READER dapat mengkueri korpus.
    • WRITER memiliki izin pembaca dan juga dapat mengedit serta membagikan korpus.
  • Korpus dapat bersifat publik dengan memberi EVERYONE sebagai akses baca user_type.
# Replace your-email@gmail.com with the email added as a test user in the OAuth Quickstart
shared_user_email = "TODO-your-email@gmail.com" #  @param {type:"string"}
user_type = "USER"
role = "READER"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.CreatePermissionRequest(
    parent=corpus_resource_name,
    permission=glm.Permission(grantee_type=user_type,
                              email_address=shared_user_email,
                              role=role))
create_permission_response = permission_service_client.create_permission(request)
print(create_permission_response)

Hapus korpus

Gunakan DeleteCorpusRequest untuk menghapus korpus pengguna dan semua Document terkait & Chunk.

Perhatikan bahwa korpora yang tidak kosong akan menampilkan error tanpa menentukan tanda force=True. Jika Anda menetapkan force=True, semua Chunk dan objek yang terkait dengan Document ini juga akan dihapus.

Jika force=False (default) dan Document berisi Chunk, error FAILED_PRECONDITION akan ditampilkan.

# Set force to False if you don't want to delete non-empty corpora.
req = glm.DeleteCorpusRequest(name=corpus_resource_name, force=True)
delete_corpus_response = retriever_service_client.delete_corpus(req)
print("Successfully deleted corpus: " + corpus_resource_name)

Ringkasan dan bacaan lebih lanjut

Panduan ini memperkenalkan Pengambil Semantik dan Pertanyaan yang Diatribusikan & API Penjawaban (AQA) dari Generative Language API dan menunjukkan cara menggunakannya untuk melakukan pengambilan informasi semantik pada data teks kustom Anda. Perlu diperhatikan bahwa API ini juga berfungsi dengan framework data LlamaIndex. Lihat tutorial untuk mempelajari lebih lanjut.

Lihat juga dokumen API untuk mempelajari lebih lanjut fungsi lain yang tersedia.

Lampiran: Menyiapkan OAuth dengan kredensial pengguna

Ikuti langkah-langkah di bawah dari Panduan Memulai OAuth untuk menyiapkan autentikasi OAuth.

  1. Konfigurasi layar izin OAuth.

  2. Otorisasi kredensial untuk aplikasi desktop. Untuk menjalankan notebook ini di Colab, ganti nama file kredensial Anda (biasanya client_secret_*.json) terlebih dahulu menjadi client_secret.json. Kemudian upload file dengan menggunakan ikon file di sidebar kiri, lalu ikon upload, seperti yang ditunjukkan pada screenshot di bawah.

# Replace TODO-your-project-name with the project used in the OAuth Quickstart
project_name = "TODO-your-project-name" #  @param {type:"string"}
# Replace TODO-your-email@gmail.com with the email added as a test user in the OAuth Quickstart
email = "TODO-your-email@gmail.com" #  @param {type:"string"}
# Rename the uploaded file to `client_secret.json` OR
# Change the variable `client_file_name` in the code below.
client_file_name = "client_secret.json"

# IMPORTANT: Follow the instructions from the output - you must copy the command
# to your terminal and copy the output after authentication back here.
!gcloud config set project $project_name
!gcloud config set account $email

# NOTE: The simplified project setup in this tutorial triggers a "Google hasn't verified this app." dialog.
# This is normal, click "Advanced" -> "Go to [app name] (unsafe)"
!gcloud auth application-default login --no-browser --client-id-file=$client_file_name --scopes="https://www.googleapis.com/auth/generative-language.retriever,https://www.googleapis.com/auth/cloud-platform"

Lakukan inisialisasi library klien dan jalankan ulang notebook mulai dari Create a corpus.

import google.ai.generativelanguage as glm

generative_service_client = glm.GenerativeServiceClient()
retriever_service_client = glm.RetrieverServiceClient()
permission_service_client = glm.PermissionServiceClient()