セマンティック取得を使ってみる

ai.google.dev で表示 Colab ノートブックを試す GitHub のノートブックを表示

概要

大規模言語モデル（LLM）は、直接トレーニングされていなくても新しい能力を学習できます。しかし、LLM は「ハルシネーション」を起こすことがトレーニングを受けていない質問に対する回答を提供する業務に従事しています。これは、LLM がトレーニング後のイベントを認識しない点が一因となっています。また、LLM が回答を引き出すソースを特定することも非常に困難です。信頼性が高くスケーラブルなアプリケーションには、LLM が事実に基づいて回答し、情報源を引用できることが重要です。

これらの制約を克服するために使用される一般的なアプローチは、検索拡張生成（RAG）と呼ばれ、LLM に送信されるプロンプトを、情報検索（IR）メカニズムを介して外部のナレッジベースから取得された関連データで拡張します。ナレッジベースは、ドキュメント、データベース、API の独自のコーパスにすることができます。

このノートブックでは、外部テキスト コーパスで LLM の知識を補強し、Semantic Retriever と Attributed Question &Generative Language API の応答（AQA）API。

セットアップ

Generative Language API をインポートする

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

認証

Semantic Retriever API を使用すると、独自のデータに対してセマンティック検索を実行できます。ユーザーのデータであるため、API キーよりも厳密なアクセス制御が必要になります。サービス アカウントまたはユーザー認証情報を使用して OAuth 認証を行います。

このクイックスタートでは、テスト環境向けの簡素化された認証アプローチを使用します。通常、サービス アカウントの設定は簡単に開始できます。本番環境の場合は、アプリに適したアクセス認証情報を選択する前に、認証と認可についてご確認ください。

サービス アカウントを使用して OAuth を設定する

サービス アカウントを使用して OAuth を設定するには、次の手順を行います。

  1. Generative Language API を有効にします。

  1. ドキュメントに沿ってサービス アカウントを作成します。

    • サービス アカウントを作成したら、サービス アカウント キーを生成します。

  1. 以下のスクリーンショットに示すように、左側のサイドバーにあるファイル アイコン、アップロード アイコンの順に使用して、サービス アカウント ファイルをアップロードします。

    • アップロードしたファイルの名前を service_account_key.json に変更するか、以下のコードの変数 service_account_file_name を変更します。

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'])

サービス アカウントの認証情報を使用してクライアント ライブラリを初期化します。

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)

コーパスを作成する

Semantic Retriever API を使用すると、プロジェクトごとに最大 5 つのカスタム テキスト コーパスを定義できます。コーパスを定義する際に、次のいずれかのフィールドを指定できます。

  • name: Corpus リソース名（ID）。40 文字以下の英数字のみを使用してください。作成時に name が空の場合、display_name の接頭辞と 12 文字のランダムな接尾辞を使用して、最大 40 文字の一意の名前が生成されます。
  • display_name: 人が読める形式の Corpus の表示名。使用できるのは、英数字、スペース、ダッシュを含む 512 文字までです。
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
}

作成されたコーパスを取得する

GetCorpusRequest メソッドを使用して、上記で作成した Corpus にプログラムでアクセスします。name パラメータの値は、Corpus の完全なリソース名を参照し、上のセルでは corpus_resource_name として設定されます。想定される形式は 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)

ドキュメントを作成して

Corpus には最大 10,000 個の Document を含めることができます。ドキュメントを定義するときに、次のいずれかのフィールドを指定できます。

  • name: Document リソース名（ID）。最大文字数は 40 文字（英数字またはダッシュのみ）です。ID の先頭または末尾を ダッシュ。作成時に名前が空の場合は、 display_name と 12 文字のランダムな接尾辞。
  • display_name: 人が読める形式の表示名。使用できるのは、英数字、スペース、ダッシュを含む 512 文字までです。

Document は、最大 20 個のユーザー指定の custom_metadata フィールドもサポートしており、Key-Value ペアとして指定します。カスタム メタデータには、文字列、文字列のリスト、数値を使用できます。文字列のリストは最大 10 個の値をサポートでき、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)

作成されたドキュメントを取得する

上記で作成したドキュメントにプログラムでアクセスするには、GetDocumentRequest メソッドを使用します。name パラメータの値はドキュメントの完全なリソース名を参照し、上のセルには document_resource_name と設定されています。想定される形式は 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)

取り込みとドキュメントをチャンク化する

セマンティック検索の際にベクトル データベースから返されるコンテンツの関連性を改善するには、ドキュメントを取り込む際に、大きなドキュメントを小さな断片またはチャンクに分割します。

Chunk は Document のサブパートであり、ベクトル表現と保存の目的で独立した単位として扱われます。Chunk には最大 2,043 個のトークンを含めることができます。Corpus には、最大 100 万個の Chunk を指定できます。

Document と同様に、Chunks も最大 20 個のユーザー指定の custom_metadata フィールド（Key-Value ペアとして指定）をサポートします。カスタム メタデータには、文字列、文字列のリスト、数値を使用できます。文字列のリストは最大 10 個の値をサポートでき、API では数値は浮動小数点数として表されることに注意してください。

このガイドでは、Google のオープンソース htmlChunker を使用します。

使用できる他のチャンクには、LangChain や LlamaIndex があります。

HTMLChunker を介して HTML とチャンクを取り込む

!pip install google-labs-html-chunker

from google_labs_html_chunker.html_chunker import HtmlChunker

from urllib.request import urlopen

ウェブサイトの HTML DOM を取得します。ここでは HTML が直接読み取られますが、 HTML のポスト レンダリングに JavaScript インジェクション HTML を含めることをおすすめします。 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")

テキスト文書を文章に分解し、その文章からChunkを作成します。このステップでは Chunk オブジェクト自体を作成し、次のセクションでは 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)

チャンクの一括作成

チャンクをバッチで作成する。バッチ リクエストごとに最大 100 個のチャンクを指定できます。

単一のチャンクの作成には CreateChunk() を使用します。

# 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)

または、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)

Chunk を一覧表示して状態を取得する

ListChunksRequest メソッドを使用して、利用可能なすべての Chunk をページ分けされたリストとして取得します。最大サイズは 1 ページあたり 100 Chunk で、Chunk.create_time の昇順で並べ替えられます。上限を指定しない場合、最大 10 個の Chunk が返されます。

次のページを取得するには、ListChunksRequest レスポンスで返された next_page_token を次のリクエストの引数として指定します。ページ分割を行う場合、ListChunks に指定する他のすべてのパラメータは、ページトークンを提供した呼び出しと一致する必要があります。

すべての Chunk は state を返します。これを使用して、Corpus をクエリする前に Chunks の状態を確認します。Chunk の状態には、UNSPECIFIED、PENDING_PROCESSING、ACTIVE、FAILED があります。クエリできるのは 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}')

別のドキュメントを取り込む

htmlChunker で Document をもう 1 つ追加し、フィルタを追加します。

# 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)

コーパスにクエリを実行する

QueryCorpusRequest メソッドを使用してセマンティック検索を行い、関連する文章を取得します。

  • results_count: 返される文の数を指定します。最大値は 100 です。指定しない場合、API は最大 10 個の Chunk を返します。
  • metadata_filters: chunk_metadata または document_metadata でフィルタします。各 MetadataFilter は一意のキーに対応している必要があります。複数の MetadataFilter オブジェクトが論理 AND で結合されます。類似のメタデータ フィルタ条件は論理 OR で結合されます。例:
(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} }]
  }]

同じキーに「AND」使用できるのは数値のみです。文字列 同じキーに対する「OR」のみがサポートされています。

("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)

アトリビューションのある質問応答

GenerateAnswer メソッドを使用して、ドキュメント、コーパス、または一連の文章に対してアトリビューション付きの質問応答を実行します。

アトリビューションのある質問応答（AQA）とは、ハルシネーションを最小限に抑えながら、特定のコンテキストに基づいて質問に答え、アトリビューションを提供することを意味します。

AQA が必要な場合、GenerateAnswer には、チューニングされていない LLM を使用する場合と比べていくつかの利点があります。

  • 基礎となるモデルは、与えられたコンテキストに基づいた回答のみを返すようにトレーニングされています。
  • アトリビューション（回答に貢献した提供されたコンテキストのセグメント）を特定します。アトリビューションにより、ユーザーは答えを確認できます。
  • 特定の（質問、コンテキスト）ペアの answerable_probability を推定します。これにより、返された回答が根拠のある正しいものである可能性に応じて、商品の振る舞いをさらに変えることができます。
で確認できます。

answerable_probability と「わからない」問題

場合によっては、「わからない」という回答が最適です。たとえば、提供されたコンテキストに質問の回答が含まれていない場合、その質問は「回答不可」とみなされます。

AQA モデルは、このようなケースの識別に優れています。回答可能性と回答不可の度合いを区別することもできます。

ただし、GenerateAnswer API を使用すると、次の方法で最終的な意思決定権限を利用者に委ねることができます。

  • 必ず、根拠のある回答を返すようにしてください。たとえその回答が根拠に基づいた正しい回答である可能性が比較的低い場合でも同様です。
  • 値を返す answerable_probability - 回答が根拠に基づいている正解である確率のモデル推定値。

answerable_probability が低い場合、次の要因のうち 1 つ以上が原因であると考えられます。

  • モデルは、回答が正しいという確信を持てません。
  • モデルが、その答えが引用された文章に根拠があることに確信を持てていない。その答えは世の中の知識から導き出されるかもしれません。例: question="1+1=?", passages=["2+2=4”] → answer=2, answerable_probability=0.02
  • モデルは関連情報を提供しましたが、質問に完全には答えていませんでした。例: 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"
  • GenerateAnswerRequest で適切な形式の質問が行われていません。

answerable_probability が低い場合は、GenerateAnswerResponse.answer が間違っているか、根拠がない可能性が高いことを示しているため、answerable_probability を調べてレスポンスをさらに処理することを強くおすすめします。

answerable_probability が低い場合、一部のクライアントは次のことを要求する可能性があります。

  • 「その質問に回答できませんでした」という内容のメッセージを表示する提供します。
  • 世界中の知識からの質問に答える汎用 LLM に話を戻します。このようなフォールバックのしきい値と性質は、個々のユースケースによって異なります。answerable_probability は 0.5 以下の値が開始しきい値として適切です。

AQA に役立つヒント

詳細な API 仕様については、GenerateAnswerRequest API リファレンスをご覧ください。

  • パッセージの長さ: 1 パッセージあたり最大 300 トークンをおすすめします。
  • 文章の並べ替え: <ph type="x-smartling-placeholder">
      </ph>
    • GenerateAnswerRequest.inline_passages を指定した場合、文章はクエリとの関連性が高い順に並べられます。モデルのコンテキストの長さの上限を超えると、最後の（関連性が最も低い）文章が省略されます。
    • GenerateAnswerRequest.semantic_retriever を指定すると、関連性の並べ替えが自動的に行われます。
  • 制限事項: AQA モデルは質問応答に特化しています。クリエイティブな記述、要約などの他のユースケースでは、GenerateContent を介して汎用モデルを呼び出してください。
    • チャット: ユーザー入力が、特定のコンテキストから回答できる可能性がある質問であることがわかっている場合、AQA はチャットクエリに回答できます。ただし、ユーザー入力があらゆる種類のエントリの場合は、汎用モデルの方が適しています。
  • 温度: <ph type="x-smartling-placeholder">
      </ph>
    • 一般に、正確な AQA のためには、温度を比較的低く（約 0.2）に設定することをおすすめします。
    • ユースケースが決定論的な出力に依存している場合は、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)

その他のオプション: インライン パッセージを使用した AQA

また、Semantic Retriever API を使用せずに inline_passages を渡して、AQA エンドポイントを直接使用することもできます。

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)

コーパスを共有する

CreatePermissionRequest API を使用すると、コーパスを他のユーザーと共有できます。

制約:

  • 共有には READER と EDITOR の 2 つのロールがあります。
    • READER はコーパスにクエリを実行できます。
    • WRITER には閲覧者の権限があり、さらにコーパスの編集と共有を行うことができます。
  • コーパスを公開するには、EVERYONE に 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)

コーパスを削除する

DeleteCorpusRequest を使用して、ユーザー コーパスと関連するすべての Document を削除します。Chunk 秒。

空でないコーパスは、force=True フラグを指定せずにエラーをスローします。force=True を設定すると、この Document に関連する Chunk とオブジェクトも削除されます。

force=False（デフォルト）で、Document に Chunk が含まれている場合、FAILED_PRECONDITION エラーが返されます。

# 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)

まとめと関連情報

このガイドでは、Semantic Retriever と Attributed Question &Generative Language API の応答（AQA）API と、この API を使用してカスタム テキストデータに対してセマンティック情報検索を実行する方法を紹介しました。なお、この API は LlamaIndex データ フレームワークとも連携します。詳しくは、チュートリアルをご覧ください。

また、利用可能なその他の機能の詳細については、API ドキュメントをご覧ください。

付録: ユーザー認証情報を使用して OAuth を設定する

OAuth クイックスタートの以下の手順に沿って、OAuth 認証を設定します。

  1. OAuth 同意画面を構成する

  2. デスクトップ アプリケーションの認証情報を承認する。このノートブックを Colab で実行するには、まず認証情報ファイル（通常は client_secret_*.json）の名前を client_secret.json に変更します。次に、以下のスクリーンショットに示すように、左側のサイドバーにあるファイル アイコン、アップロード アイコンの順に使用してファイルをアップロードします。

# 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"

クライアント ライブラリを初期化し、コーパスの作成から開始してノートブックを再実行します。

import google.ai.generativelanguage as glm

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