Ver en ai.google.dev | Prueba un notebook de Colab | Ver notebook en GitHub |
Descripción general
Los modelos de lenguaje extensos (LLM) pueden aprender habilidades nuevas sin necesidad de entrenarlos directamente con ellos. Sin embargo, se sabe que los LLM "alucinan" cuando se encargan de brindar respuestas a preguntas para las que no han recibido capacitación. Esto se debe, en parte, a que los LLM no conocen los eventos después del entrenamiento. También es muy difícil rastrear las fuentes de las que los LLM extraen sus respuestas. Para aplicaciones confiables y escalables, es importante que un LLM proporcione respuestas que se basen en hechos y pueda citar sus fuentes de información.
Un enfoque común que se usa para superar estas restricciones es el de generación de aumento de recuperación (RAG), que aumenta la instrucción enviada a un LLM con datos relevantes recuperados de una base de conocimiento externa a través de un mecanismo de recuperación de información (IR). La base de conocimiento puede ser tu propio corpus de documentos, bases de datos o APIs.
En este notebook, se explica un flujo de trabajo para mejorar la respuesta de un LLM aumentando su conocimiento con corpus de texto externo y realizando una recuperación semántica de información para responder preguntas con el recuperador semántico y las preguntas y respuestas APIs de respuesta (AQA) de la API de Generative Language.
Configuración
Importa la API de Generative Language
# Install the Client library (Semantic Retriever is only supported for versions >0.4.0)
pip install -U google.ai.generativelanguage
Autenticar
La API de Semantic Retriever te permite realizar una búsqueda semántica en tus propios datos. Dado que se trata de tus datos, esto requiere controles de acceso más estrictos que las claves de API. Autentica con OAuth mediante cuentas de servicio o tus credenciales de usuario.
En esta guía de inicio rápido, se usa un enfoque de autenticación simplificado destinado a un entorno de pruebas. Por lo general, la configuración de las cuentas de servicio es más fácil de usar. Para un entorno de producción, obtén información sobre la autenticación y autorización antes de elegir las credenciales de acceso que sean apropiadas para tu app.
Configura OAuth con cuentas de servicio
Sigue estos pasos para configurar OAuth con cuentas de servicio:
- Habilita la API de Generative Language.
Sigue las instrucciones de la documentación para crear la cuenta de servicio.
- Después de crear la cuenta de servicio, genera una clave de cuenta de servicio.
Para subir el archivo de la cuenta de servicio, usa el ícono de archivo de la barra lateral izquierda y, luego, el ícono de carga, como se muestra en la siguiente captura de pantalla.
- Cambia el nombre del archivo que subiste a
service_account_key.json
o cambia la variableservice_account_file_name
en el siguiente código.
- Cambia el nombre del archivo que subiste a
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'])
Inicializa la biblioteca cliente con las credenciales de la cuenta de servicio.
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)
Crea un corpus
La API de Semantic Retriever te permite definir hasta 5 corpus de texto personalizados por proyecto. Puedes especificar cualquiera de los siguientes campos mientras defines tu corpus:
name
: Es el nombre (ID) del recursoCorpus
. Debe contener solo un máximo de 40 caracteres alfanuméricos. Si elname
está vacío durante la creación, se generará un nombre único con una longitud máxima de 40 caracteres con un prefijo dedisplay_name
y un sufijo aleatorio de 12 caracteres.display_name
: Es el nombre visible legible delCorpus
. Debe contener solo un máximo de 512 caracteres, incluidos caracteres alfanuméricos, espacios y guiones.
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 }
Obtén el corpus creado
Usa el método GetCorpusRequest
para acceder de manera programática al elemento Corpus
que creaste antes. El valor del parámetro name
hace referencia al nombre completo del recurso de Corpus
y se establece en la celda anterior como corpus_resource_name
. El formato esperado es 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)
Crea un documento
Un Corpus
puede contener hasta 10,000 Document
. Puedes especificar cualquiera de los siguientes campos cuando definas tus documentos:
name
: Es el nombre (ID) del recursoDocument
. Debe contener solo un máximo de 40 caracteres (solo alfanuméricos o guiones). El ID no puede comenzar ni terminar con un y guion. Si el nombre está vacío durante la creación, se derivará un nombre único deldisplay_name
junto con un sufijo aleatorio de 12 caracteresdisplay_name
: Es el nombre visible legible por humanos. Debe contener solo un máximo de 512 caracteres, incluidos caracteres alfanuméricos, espacios y guiones.
Los elementos Document
también admiten hasta 20 campos custom_metadata
especificados por el usuario, especificados como pares clave-valor. Los metadatos personalizados pueden ser cadenas, listas de cadenas o valores numéricos. Ten en cuenta que las listas de cadenas pueden admitir un máximo de 10 valores y los valores numéricos se representan como números de punto flotante en la 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)
Obtén el documento creado
Usa el método GetDocumentRequest
para acceder de manera programática al documento que creaste anteriormente. El valor del parámetro name
hace referencia al nombre completo del recurso del documento y se establece en la celda anterior como document_resource_name
. El formato esperado es 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)
Transferir y Fragmenta un documento
Para mejorar la relevancia del contenido que muestra la base de datos de vectores durante la recuperación semántica, divide los documentos grandes en partes más pequeñas o fragmentos mientras transfieres el documento.
Un Chunk
es una subparte de un Document
que se trata como una unidad independiente para los fines de representación y almacenamiento de vectores. Una Chunk
puede tener un máximo de 2,043 tokens. Un Corpus
puede tener un máximo de 1 millón de Chunk
.
Al igual que los Document
, Chunks
también admite hasta 20 campos custom_metadata
especificados por el usuario, especificados como pares clave-valor. Los metadatos personalizados pueden ser cadenas, listas de cadenas o valores numéricos. Ten en cuenta que las listas de cadenas pueden admitir un máximo de 10 valores y los valores numéricos se representan como números de punto flotante en la API.
En esta guía, se usa HtmlChunker de código abierto de Google.
Otros fragmentos que puedes usar son LangChain o LlamaIndex.
Transferir HTML y fragmentos a través de HtmlChunker
!pip install google-labs-html-chunker
from google_labs_html_chunker.html_chunker import HtmlChunker
from urllib.request import urlopen
Obtén el HTML DOM de un sitio web. Aquí, el HTML se lee directamente, pero
Es mejor obtener renderización posterior de HTML para incluir HTML inyectado 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")
Divide el documento de texto en pasajes y crea Chunk
a partir de ellos. En este paso, se crean los objetos Chunk
y, en la siguiente sección, se suben a la API de 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)
Creación de fragmentos por lotes
Crea fragmentos en lotes. Puedes especificar un máximo de 100 fragmentos por solicitud por lotes.
Usa CreateChunk()
para crear un solo fragmento.
# 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, puedes crear fragmentos sin usar 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)
Genera una lista de objetos Chunk
y obtén un estado
Usa el método ListChunksRequest
para obtener todos los Chunk
disponibles como una lista paginada con un límite de tamaño máximo de 100 Chunk
por página, en orden ascendente de Chunk.create_time
. Si no especificas un límite, se muestra un máximo de 10 Chunk
.
Proporciona el next_page_token
que se muestra en la respuesta de ListChunksRequest
como un argumento para la siguiente solicitud a fin de recuperar la página siguiente. Ten en cuenta que, durante la paginación, todos los demás parámetros proporcionados a ListChunks
deben coincidir con la llamada que proporcionó el token de la página.
Todos los Chunk
muestran un state
. Úsalo para verificar el estado de Chunks
antes de consultar un Corpus
. Los estados de Chunk
incluyen UNSPECIFIED
, PENDING_PROCESSING
, ACTIVE
y FAILED
. Solo puedes consultar ACTIVE
Chunk
s.
# 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}')
Transferir otro documento
Agrega otro Document
a través de HtmlChunker y agrega 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)
Consulta el corpus
Usa el método QueryCorpusRequest
para realizar una búsqueda semántica y obtener pasajes relevantes.
results_count
: Especifica la cantidad de pasajes que se mostrarán. El máximo es 100. Si no se especifica, la API muestra un máximo de 10Chunk
.metadata_filters
: Filtra porchunk_metadata
odocument_metadata
. CadaMetadataFilter
debe corresponder a una clave única. Varios objetosMetadataFilter
se unen medianteAND
lógicos. Las condiciones de filtro de metadatos similares se unen conOR
lógicos. Estos son algunos ejemplos:
(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} }]
}]
Ten en cuenta que solo los valores numéricos admiten “AND” para la misma clave. Cadena solo admiten valores “OR” para la misma clave.
("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)
Respuestas a preguntas atribuidas
Usa el método GenerateAnswer
para ejecutar preguntas atribuidas en tu documento, corpus o un conjunto de pasajes.
Respuestas a preguntas atribuidas (AQA) se refiere a responder preguntas basadas en un contexto determinado y proporcionar atribuciones, a la vez que se minimiza la alucinación.
GenerateAnswer
ofrece varias ventajas en comparación con el uso de un LLM no ajustado, en los casos en que se desea un AQA:
- El modelo subyacente se entrenó para devolver solo respuestas que se basan en el contexto proporcionado.
- Identifica atribuciones (segmentos del contexto proporcionado que contribuyeron a la respuesta). Las atribuciones permiten que el usuario verifique la respuesta.
- Calcula la
answerable_probability
para un par determinado (pregunta, contexto), lo que te permite desviar el comportamiento del producto según la probabilidad de que la respuesta que se muestra esté fundamentada y sea correcta.
answerable_probability
y el problema "No lo sé"
En algunos casos, la mejor respuesta a la pregunta es "No sé". Por ejemplo, si el contexto proporcionado no contiene la respuesta a la pregunta, se considera que no se puede responder.
El modelo AQA es muy hábil para reconocer tales casos. Incluso puede distinguir entre los grados de capacidad de respuesta e incapacidad.
Sin embargo, la API de GenerateAnswer
pone en tus manos el poder final de la toma de decisiones de la siguiente manera:
- Intenta siempre devolver una respuesta fundamentada, incluso cuando es poco probable que esa respuesta sea correcta y esté fundamentada.
- Mostrar un valor
answerable_probability
: la estimación del modelo de la probabilidad de que la respuesta esté basada en fundamentos y sea correcta.
Un answerable_probability
bajo puede explicarse por 1 o más de los siguientes factores:
- El modelo no está seguro de que su respuesta sea correcta.
- El modelo no está seguro de que su respuesta se base en los pasajes citados; La respuesta puede provenir, en cambio, del conocimiento mundial. Por ejemplo:
question="1+1=?", passages=["2+2=4”]
→answer=2, answerable_probability=0.02
- El modelo proporcionó información relevante que no respondió por completo la pregunta. Ejemplo:
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"
- No se hizo ninguna pregunta bien formada en GenerateAnswerRequest.
Dado que un answerable_probability
bajo indica que GenerateAnswerResponse.answer probablemente sea incorrecto o no tenga base, te recomendamos que sigas procesando la respuesta inspeccionando answerable_probability
.
Cuando el valor de answerable_probability
es bajo, es posible que algunos clientes deseen realizar lo siguiente:
- Mostrar un mensaje que indique que no se pudo responder la pregunta al usuario final.
- Recurre a un LLM de uso general que responda a la pregunta del conocimiento mundial. El umbral y la naturaleza de esos resguardos dependerán de casos de uso individuales. Un valor de
answerable_probability
<= 0.5 es un buen umbral de inicio.
Sugerencias útiles sobre AQA
Para ver las especificaciones completas de la API, consulta la Referencia de la API de GenerateAnswerRequest
.
- Longitud del pasaje: Se recomiendan hasta 300 tokens por pasaje.
- Orden de pasajes:
- Si proporcionas
GenerateAnswerRequest.inline_passages
, los pasajes se deben ordenar de forma descendente según su relevancia para la búsqueda. Si se excede el límite de longitud del contexto del modelo, se omitirán los últimos pasajes (menos relevantes). - Si proporcionas el signo
GenerateAnswerRequest.semantic_retriever
, el orden por relevancia se realizará automáticamente.
- Si proporcionas
- Limitaciones: El modelo AQA está especializado para responder preguntas. Para otros casos de uso, como escritura creativa, resúmenes, etc., llama a un modelo de uso general a través de GenerateContent.
- Chat: Si se sabe que la entrada del usuario es una pregunta que se puede responder en un contexto determinado, AQA puede responder las consultas de chat. Pero si la entrada del usuario puede ser de cualquier tipo de entrada, un modelo de uso general podría ser una mejor opción.
- Temperatura:
- Por lo general, se recomienda una temperatura relativamente baja (~0.2) para obtener un AQA preciso.
- Si tu caso de uso se basa en resultados deterministas, establece la 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)
Más opciones: AQA con pasajes intercalados
Como alternativa, puedes usar el extremo AQA directamente, sin usar la API de Semantic Retriever, pasando 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)
Compartir el corpus
Puedes elegir compartir el corpus con otras personas mediante la API de CreatePermissionRequest
.
Restricciones:
- Hay 2 roles para compartir:
READER
yEDITOR
.- Una
READER
puede consultar el corpus. - Un
WRITER
tiene permisos de lector y, además, puede editar y compartir el corpus.
- Una
- Un corpus puede ser público si otorgas
EVERYONE
como acceso de lectura deuser_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)
Borrar el corpus
Usa DeleteCorpusRequest
para borrar un corpus de usuarios y todos los Document
asociados. Chunk
Ten en cuenta que los corpus no vacíos arrojarán un error sin especificar una marca force=True
. Si configuras force=True
, también se borrarán los Chunk
y los objetos relacionados con este Document
.
Si force=False
(el valor predeterminado) y Document
contienen Chunk
, se mostrará un error 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)
Resumen y lecturas adicionales
En esta guía, se presentaron el recuperador semántico, las preguntas atribuidas y APIs de respuesta (AQA) de la API de Generative Language y te mostramos cómo puedes usarla para realizar la recuperación de información semántica en tus datos de texto personalizados. Ten en cuenta que esta API también funciona con el framework de datos LlamaIndex. Consulta el instructivo para obtener más información.
Consulta también los documentos de la API para obtener más información sobre las otras funcionalidades disponibles.
Apéndice: Configura OAuth con credenciales de usuario
Sigue los pasos de la Guía de inicio rápido de OAuth que se indican a continuación para configurar la autenticación de OAuth.
Autoriza credenciales para una aplicación de escritorio. Para ejecutar este notebook en Colab, primero cambia el nombre del archivo de credenciales (generalmente
client_secret_*.json
) aclient_secret.json
. Luego, sube el archivo usando el ícono de archivo de la barra lateral izquierda y, luego, el ícono de carga, como se muestra en la siguiente captura de pantalla.
# 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"
Inicializa la biblioteca cliente y vuelve a ejecutar el notebook desde Crear un corpus.
import google.ai.generativelanguage as glm
generative_service_client = glm.GenerativeServiceClient()
retriever_service_client = glm.RetrieverServiceClient()
permission_service_client = glm.PermissionServiceClient()