Redução no preço do Gemini 1.5 Flash, ajuste do acesso para todos os desenvolvedores e muito mais! Saiba mais

Esta página foi traduzida pela API Cloud Translation.

Primeiros passos com a recuperação semântica

Ver em ai.google.dev

Executar no Google Colab

Veja o código-fonte no GitHub

Visão geral

Os modelos de linguagem grandes (LLMs) podem aprender novas habilidades sem serem treinados diretamente nelas. No entanto, é conhecido que os LLMs "alucinam" quando têm a tarefa de fornecer respostas para perguntas para as quais não receberam treinamento. Em parte, isso é importante porque os LLMs não ficam cientes dos eventos após o treinamento. Também é muito difícil rastrear as fontes de onde os LLMs extraem as respostas. Para aplicativos confiáveis e escalonáveis, é importante que um LLM forneça respostas fundamentadas em fatos e seja capaz de citar as fontes de informação.

Uma abordagem comum usada para superar essas restrições é a geração aumentada de recuperação (RAG, na sigla em inglês), que amplia o comando enviado a um LLM com dados relevantes recuperados de uma base de conhecimento externa por um mecanismo de recuperação de informações (RI). A base de conhecimento pode ser seu próprio conjunto de documentos, bancos de dados ou APIs.

Este notebook mostra um fluxo de trabalho para melhorar a resposta de um LLM, aumentando o conhecimento com corpora de texto externo e realizando a recuperação de informações semânticas para responder a perguntas usando o Recuperador Semântico e a Pergunta atribuída e APIs de resposta (AQA) da API Generative Language.

Configuração

Importar a API Generative Language

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

Autenticar

A API Semantic Retriever permite realizar pesquisas semânticas nos seus próprios dados. Como são seus dados, os controles de acesso são mais rigorosos do que as chaves de API. Use o OAuth com contas de serviço ou usando suas credenciais de usuário.

Este guia de início rápido usa uma abordagem de autenticação simplificada destinada a um ambiente de teste, e geralmente é mais fácil iniciar as configurações de contas de serviço. Para um ambiente de produção, saiba mais sobre autenticação e autorização antes de escolher as credenciais de acesso adequadas para o app.

Configurar o OAuth usando contas de serviço

Siga as etapas abaixo para configurar o OAuth usando contas de serviço:

Ative a API Generative Language.

Crie a conta de serviço seguindo a documentação.
- Depois de criar a conta de serviço, gere uma chave para ela.

Faça upload do arquivo da conta de serviço usando o ícone de arquivo na barra lateral esquerda e, em seguida, o ícone de upload, conforme mostrado na captura de tela abaixo.
- Renomeie o arquivo enviado como service_account_key.json ou mude a variável service_account_file_name no código abaixo.

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

Inicialize a biblioteca de cliente usando as credenciais da conta de serviço.

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)

Criar um corpus

A API Semantic Retriever permite definir até cinco corpora de textos personalizados por projeto. É possível especificar um dos seguintes campos ao definir seu corpora:

name: o nome do recurso (ID) Corpus. Precisa ter no máximo 40 caracteres alfanuméricos. Se a name estiver vazia na criação, um nome exclusivo vai ser gerado com tamanho máximo de 40 caracteres, com um prefixo da display_name e um sufixo aleatório de 12 caracteres.
display_name: o nome de exibição legível para o Corpus. Precisa ter no máximo 512 caracteres, incluindo alfanuméricos, espaços e traços.

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
}

Acessar o corpus criado

Use o método GetCorpusRequest para acessar de forma programática o Corpus que você criou acima. O valor do parâmetro name se refere ao nome completo do recurso de Corpus e é definido na célula acima como corpus_resource_name. O formato esperado é 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)

Criar um documento

Um Corpus pode conter até 10.000 Documents. É possível especificar um dos seguintes campos ao definir seus documentos:

name: o nome do recurso (ID) Document. Precisa ter no máximo 40 caracteres (alfanuméricos ou com traços). O ID não pode começar nem terminar com traço. Se o nome estiver vazio na criação, um nome exclusivo será derivado de display_name com um sufixo aleatório de 12 caracteres.
display_name: o nome de exibição legível. Precisa ter no máximo 512 caracteres, incluindo alfanuméricos, espaços e traços.

Documents também oferecem suporte a até 20 campos custom_metadata especificados pelo usuário, definidos como pares de chave-valor. Os metadados personalizados podem ser strings, listas de strings ou numéricos. As listas de strings aceitam no máximo 10 valores, e os valores numéricos são representados como números de ponto flutuante na 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)

Acessar o documento criado

Use o método GetDocumentRequest para acessar de forma programática o documento criado acima. O valor do parâmetro name se refere ao nome completo do recurso do documento e é definido na célula acima como document_resource_name. O formato esperado é 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)

Ingerir e Dividir um documento

Para melhorar a relevância do conteúdo retornado pelo banco de dados de vetores durante a recuperação semântica, divida documentos grandes em partes menores ou blocos durante a ingestão do documento.

Um Chunk é uma subparte de uma Document que é tratada como uma unidade independente para fins de representação vetorial e armazenamento. Um Chunk pode ter no máximo 2.043 tokens. Um Corpus pode ter no máximo um milhão de Chunks.

Assim como os Documents, o Chunks também aceita até 20 campos custom_metadata especificados pelo usuário, que são definidos como pares de chave-valor. Os metadados personalizados podem ser strings, listas de strings ou numéricos. As listas de strings aceitam no máximo 10 valores, e os valores numéricos são representados como números de ponto flutuante na API.

Este guia usa o HTMLChunker de código aberto do Google.

Outros blocos que você pode usar incluem LangChain ou LlamaIndex.

Ingerir HTML e blocos via HTMLChunker

!pip install google-labs-html-chunker

from google_labs_html_chunker.html_chunker import HtmlChunker

from urllib.request import urlopen

Obter o DOM do HTML de um site. Aqui, o HTML é lido diretamente, mas ser melhor para a pós-renderização de HTML para incluir HTML com injeção de JavaScript como 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")

Divida o documento de texto em trechos e crie Chunks com base neles. Esta etapa cria os objetos Chunk e a próxima seção faz upload deles para a API Semantic Retriever.

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

Criar blocos em lote

Criar blocos em lotes. É possível especificar no máximo 100 blocos por solicitação em lote.

Use CreateChunk() para a criação de um bloco único.

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

Como alternativa, é possível fazer pedaços sem usar o 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)

Lista `Chunk`s e recebe o estado

Use o método ListChunksRequest para ver todas as Chunks disponíveis como uma lista paginada com um limite máximo de tamanho de 100 Chunks por página, classificada em ordem crescente de Chunk.create_time. Se você não especificar um limite, serão retornados no máximo 10 Chunks.

Forneça o next_page_token retornado na resposta ListChunksRequest como um argumento para a próxima solicitação a fim de recuperar a próxima página. Ao paginar, todos os outros parâmetros fornecidos para ListChunks precisam corresponder à chamada que forneceu o token da página.

Todos os Chunks retornam um state. Use esse método para verificar o estado da Chunks antes de consultar uma Corpus. Os estados Chunk incluem UNSPECIFIED, PENDING_PROCESSING, ACTIVE e FAILED. Só é possível consultar ACTIVE Chunks.

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

Ingerir outro documento

Adicione outro Document via HTMLChunker e adicione filtros.

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

Consultar o corpus

Use o método QueryCorpusRequest para fazer uma pesquisa semântica e encontrar trechos relevantes.

results_count: especifica o número de trechos a serem retornados. O máximo é 100. Se não for especificada, a API retornará um máximo de 10 Chunks.
metadata_filters: filtra por chunk_metadata ou document_metadata. Cada MetadataFilter precisa corresponder a uma chave exclusiva. Vários objetos MetadataFilter são unidos por ANDs lógicos. Condições de filtro de metadados semelhantes são unidas por ORs lógicos. Alguns exemplos:

(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} }]
  }]

Apenas valores numéricos aceitam "AND" para a mesma chave. Corda são compatíveis apenas com "OR"s para a mesma chave.

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

Respostas a perguntas atribuídas

Use o método GenerateAnswer para responder a perguntas com atribuição no seu documento, corpus ou um conjunto de trechos.

A atribuição de respostas a perguntas (AQA, na sigla em inglês) refere-se a responder perguntas embasadas em um determinado contexto e fornecer atribuições, minimizando a alucinação.

O GenerateAnswer oferece várias vantagens em relação ao uso de um LLM não ajustado, nos casos em que o AQA é desejado:

O modelo subjacente foi treinado para retornar somente respostas fundamentadas no contexto fornecido.
Identifica atribuições (segmentos do contexto fornecido que contribuíram para a resposta). As atribuições permitem que o usuário verifique a resposta.
Ela estima o answerable_probability para um determinado par (pergunta, contexto), o que permite que você desvie o comportamento do produto dependendo da probabilidade de a resposta retornada ser fundamentada e correta.

`answerable_probability` e o problema "Não sei"

Em alguns casos, a melhor resposta à pergunta é de fato “não sei”. Por exemplo, se o contexto fornecido não contém a resposta para a pergunta, então a pergunta é considerada "sem resposta".

O modelo AQA é altamente adepto em reconhecer tais casos. Ela consegue até mesmo distinguir entre graus de responsabilidade e não resposta.

No entanto, a API GenerateAnswer coloca o poder de tomada de decisão final nas suas mãos ao:

Sempre tente retornar uma resposta embasada, mesmo quando é relativamente improvável que essa resposta esteja embasada e correta.
Retornar um valor answerable_probability: a estimativa do modelo da probabilidade de que a resposta esteja fundamentada e correta.

Um answerable_probability baixo pode ser explicado por um ou mais dos seguintes fatores:

O modelo não tem certeza de que a resposta está correta.
O modelo não tem certeza de que a resposta está fundamentada nos trechos citados. A resposta pode vir, em vez disso, do conhecimento mundial. Por exemplo: question="1+1=?", passages=["2+2=4”] → answer=2, answerable_probability=0.02
O modelo forneceu informações relevantes que não responderam completamente à pergunta. Exemplo: 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"
Nenhuma pergunta bem escrita foi feita no GenerateAnswerRequest.

Como um answerable_probability baixo indica que GenerateAnswerResponse.answer provavelmente está errado ou sem embasamento, é altamente recomendável processar a resposta inspecionando answerable_probability.

Quando o answerable_probability estiver baixo, alguns clientes talvez queiram:

Exibir uma mensagem com o seguinte efeito: "não foi possível responder a essa pergunta" para o usuário final.
Use um LLM de uso geral que responda à pergunta com base no conhecimento do mundo. O limite e a natureza desses substitutos dependem dos casos de uso individuais. Um valor de answerable_probability <= 0,5 é um bom limite inicial.

Dicas úteis de AQA

Para conferir as especificações completas da API, consulte a Referência da API do GenerateAnswerRequest.

Tamanho da passagem: é recomendado até 300 tokens por passagem.
Classificação de passagem:
- Se você informar GenerateAnswerRequest.inline_passages, os trechos serão classificados em ordem decrescente de relevância para a consulta. Se o limite de tamanho do contexto do modelo for excedido, os últimos trechos (menos relevantes) serão omitidos.
- Se você informar GenerateAnswerRequest.semantic_retriever, a classificação de relevância será feita automaticamente.
Limitações: o modelo de AQA é especializado para responder a perguntas. Para outros casos de uso, como escrita criativa, resumo etc., chame um modelo de uso geral via GenerateContent.
- Chat: se a entrada do usuário for uma pergunta que pode ser respondida de um determinado contexto, a AQA poderá responder às consultas do chat. No entanto, se a entrada do usuário puder ser de qualquer tipo, um modelo de uso geral pode ser uma escolha melhor.
Temperatura:
- Geralmente, uma temperatura relativamente baixa (~0,2) é recomendada para uma AQA precisa.
- Se o caso de uso depender de saídas determinísticas, defina a temperatura=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)

Mais opções: AQA usando passagens inline

Como alternativa, é possível usar o endpoint AQA diretamente, sem usar a API Semantic Retriever, transmitindo 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)

Compartilhar o corpus

É possível compartilhar o corpus com outras pessoas usando a API CreatePermissionRequest.

Restrições:

Há dois papéis para compartilhamento: READER e EDITOR.
- Um READER pode consultar o corpus.
- Um WRITER tem permissões de leitor e também pode editar e compartilhar o corpus.
Para ser público, um corpus pode ser concedido ao conceder acesso de leitura a EVERYONE como 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)

Excluir o corpus

Use DeleteCorpusRequest para excluir um corpus de usuários e todos os Documents e Chunks.

O corpora não vazio vai gerar um erro sem especificar uma flag force=True. Se você definir force=True, todos os Chunks e objetos relacionados a esse Document também serão excluídos.

Se force=False (padrão) e Document contiverem Chunks, um erro FAILED_PRECONDITION será retornado.

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

Resumo e outros materiais de leitura

Este guia introduziu os recursos de Recuperador Semântico e Pergunta e APIs Answering (AQA) da API Generative Language e mostramos como usá-las para recuperar informações semânticas nos seus dados de texto personalizados. Essa API também funciona com o framework de dados LlamaIndex. Consulte o tutorial para saber mais.

Consulte também os documentos da API para saber mais sobre as outras funcionalidades disponíveis.

Apêndice: configurar o OAuth com credenciais de usuário

Siga as etapas abaixo do Guia de início rápido do OAuth para configurar a autenticação OAuth.

Configure a tela de permissão OAuth.
Autorizar credenciais para um aplicativo de computador Para executar este notebook no Colab, primeiro renomeie o arquivo de credencial (geralmente client_secret_*.json) para apenas client_secret.json. Em seguida, faça o upload do arquivo usando o ícone de arquivo na barra lateral esquerda e, em seguida, o ícone de upload, como mostrado na captura de tela abaixo.

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

Inicialize a biblioteca de cliente e execute novamente o notebook, começando em Criar um corpus.

import google.ai.generativelanguage as glm

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