Preguntas y respuestas con Gemini, LlamaIndex y Chroma

Copyright 2026 Google LLC.

# @title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Nota: Este notebook requiere límites de tarifa de nivel de pago para ejecutarse correctamente. (Consulta precios para más detalles).

Descripción general

Gemini es una familia de modelos de IA generativa que permite a los desarrolladores generar contenido y resolver problemas. Estos modelos están diseñados y entrenados para manejar tanto texto como imágenes como entrada.

LlamaIndex es un marco de datos simple y flexible que las aplicaciones de modelos de lenguaje grandes (LLM) pueden usar para conectar fuentes de datos personalizadas a los LLM.

Chroma es una base de datos de embeddings de código abierto centrada en la simplicidad y la productividad del desarrollador. Chroma permite a los usuarios almacenar embeddings y sus metadatos, incrustar documentos y consultas, y buscar los embeddings rápidamente.

En este notebook, aprenderás a crear una aplicación que responde preguntas usando datos de un sitio web con la ayuda de Gemini, LlamaIndex y Chroma.

Configuración

Primero, debes instalar los paquetes y establecer las variables de entorno necesarias.

Instalación

Instala la biblioteca de Python de LlamaIndex, llama-index. Instala el paquete de integración de LlamaIndex para Gemini, llama-index-llms-gemini y el paquete de integración para el modelo de embedding de Gemini, llama-index-embeddings-gemini. Luego, instala el lector de páginas web de LlamaIndex, llama-index-readers-web. Finalmente, instala el SDK de cliente de Python de ChromaDB, chromadb y

%pip install -q -U llama-index
%pip install -q -U llama-index-llms-google-genai
%pip install -q -U llama-index-embeddings-google-genai
%pip install -q -U llama-index-readers-web
%pip install -q -U llama-index-vector-stores-chroma
%pip install -q -U chromadb
%pip install -q -U bs4

Configura tu clave de API

Para ejecutar la siguiente celda, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API, o no estás seguro de cómo crear un Secreto de Colab, consulta Autenticación para ver un ejemplo.

import os
from google.colab import userdata
GEMINI_API_KEY=userdata.get('GEMINI_API_KEY')

os.environ["GEMINI_API_KEY"] = GEMINI_API_KEY

Pasos básicos

Los LLM se entrenan sin conexión en un gran corpus de datos públicos. Por lo tanto, no pueden responder preguntas basadas en datos personalizados o privados con precisión sin contexto adicional.

Si quieres usar LLM para responder preguntas basadas en datos privados, debes proporcionar los documentos relevantes como contexto junto con tu prompt. Este enfoque se llama Generación Aumentada por Recuperación (RAG).

Usarás este enfoque para crear un asistente de preguntas y respuestas usando el modelo de texto Gemini integrado a través de LlamaIndex. Se espera que el asistente responda preguntas sobre el modelo Gemini de Google. Para que esto sea posible, agregarás más contexto al asistente usando datos de un sitio web.

En este tutorial, implementarás los dos componentes principales en una arquitectura basada en RAG:

1. Recuperador

   Basado en la consulta del usuario, el recuperador recupera fragmentos relevantes que agregan contexto del documento. En este tutorial, el documento son los datos del sitio web. Los fragmentos relevantes se pasan como contexto a la siguiente etapa: "Generador".

2. Generador

   Los fragmentos relevantes de los datos del sitio web se pasan al LLM junto con la consulta del usuario para generar respuestas precisas.

Aprenderás más sobre estas etapas en las próximas secciones mientras implementas la aplicación.

Importa las bibliotecas requeridas

from bs4 import BeautifulSoup
from IPython.display import Markdown, display
from llama_index.core import Document
from llama_index.core import Settings
from llama_index.core import SimpleDirectoryReader
from llama_index.core import StorageContext
from llama_index.core import VectorStoreIndex
from llama_index.readers.web import SimpleWebPageReader
from llama_index.embeddings.google_genai import GoogleGenAIEmbedding
from llama_index.vector_stores.chroma import ChromaVectorStore

import chromadb
import re

1. Recuperador

En esta etapa, realizarás los siguientes pasos:

1. Lee y analiza los datos del sitio web usando LlamaIndex.

2. Crea embeddings de los datos del sitio web.

   Los embeddings son representaciones numéricas (vectores) de texto. Por lo tanto, el texto con un significado similar tendrá vectores de embedding similares. Usarás el modelo de embedding de Gemini para crear los vectores de embedding de los datos del sitio web.

3. Almacena los embeddings en el almacén de vectores de Chroma.

   Chroma es una base de datos vectorial. El almacén de vectores de Chroma ayuda en la recuperación eficiente de vectores similares. Así, para agregar contexto al prompt para el LLM, los embeddings relevantes del texto que coinciden con la pregunta del usuario se pueden recuperar fácilmente usando Chroma.

4. Crea un Recuperador desde el almacén de vectores de Chroma.

   El recuperador se usará para pasar embeddings relevantes del sitio web al LLM junto con las consultas del usuario.

Lee y analiza los datos del sitio web

LlamaIndex proporciona una amplia variedad de cargadores de datos. Para leer los datos del sitio web como un documento, usarás el SimpleWebPageReader de LlamaIndex.

Para saber más sobre cómo leer y analizar datos de entrada de diferentes fuentes usando los cargadores de datos de LlamaIndex, lee la guía de carga de datos de LlamaIndex.

web_documents = SimpleWebPageReader().load_data(
    ["https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/"]
)

# Extract the content from the website data document
html_content = web_documents[0].text

Puedes usar una variedad de analizadores HTML para extraer el texto requerido del contenido HTML.

En este ejemplo, usarás la biblioteca BeautifulSoup de Python para analizar los datos del sitio web. Después del procesamiento, el texto extraído debe convertirse de nuevo al formato Document de LlamaIndex.

# Parse the data.
soup = BeautifulSoup(html_content, 'html.parser')
p_tags = soup.find_all('p')
text_content = ""
for each in p_tags:
    text_content += each.text + "\n"

# Convert back to Document format
documents = [Document(text=text_content)]

Inicializa el modelo de embedding de Gemini

Para crear los embeddings a partir de los datos del sitio web, usarás el modelo de embedding de Gemini, gemini-embedding-001, que admite la creación de embeddings de texto.

Para usar este modelo de embedding, debes importar GeminiEmbedding de LlamaIndex. Para saber más sobre el modelo de embedding, lee la documentación de lenguaje de Google AI.

gemini_embedding_model = GoogleGenAIEmbedding(model_name="models/gemini-embedding-001")

Inicializa Gemini

Debes importar Gemini de LlamaIndex para inicializar tu modelo. En este ejemplo, usarás gemini-3.7-flash, ya que admite la creación de resúmenes de texto. Para saber más sobre el modelo de texto, lee la documentación del modelo de Google AI.

Puedes configurar los parámetros del modelo, como temperature o top_p, usando el parámetro generation_config al inicializar el LLM Gemini. Para obtener más información sobre los parámetros del modelo y sus usos, lee la guía de conceptos de Google AI.

from llama_index.llms.google_genai import GoogleGenAI

# To configure model parameters use the `generation_config` parameter.
# eg. generation_config = {"temperature": 0.7, "topP": 0.8, "topK": 40}
# If you only want to set a custom temperature for the model use the
# "temperature" parameter directly.

llm = GoogleGenAI(model_name="models/gemini-3.7-flash")

Almacena los datos usando Chroma

A continuación, almacenarás los embeddings de los datos del sitio web en el almacén de vectores de Chroma usando LlamaIndex.

Primero, debes iniciar un cliente de Python en chromadb. Dado que el plan es guardar los datos en el disco, usarás el PersistentClient. Puedes leer más sobre los diferentes clientes en Chroma en la guía de referencia del cliente.

Después de inicializar el cliente, debes crear una colección de Chroma. Luego inicializarás la clase ChromaVectorStore en LlamaIndex usando la colección creada en el paso anterior.

A continuación, debes establecer Settings y crear contextos de almacenamiento para el almacén de vectores.

Settings es una colección de recursos de uso común que se utilizan durante la fase de indexación y consulta en una tubería de LlamaIndex. Puedes especificar el LLM, el modelo de Embedding, etc. que se usarán para crear la aplicación en el Settings. Para saber más sobre Settings, lee la guía del módulo para Settings.

StorageContext es una abstracción ofrecida por LlamaIndex sobre diferentes tipos de almacenamiento. Para saber más sobre el contexto de almacenamiento, lee la guía de la API de contexto de almacenamiento.

El paso final es cargar los documentos y construir un índice sobre ellos. LlamaIndex ofrece varios índices que ayudan a recuperar contexto relevante para una consulta de usuario. Aquí usarás el VectorStoreIndex ya que los embeddings del sitio web deben almacenarse en un almacén de vectores.

Para crear el índice, debes pasar el contexto de almacenamiento junto con los documentos a la función from_documents de VectorStoreIndex. El VectorStoreIndex usa el modelo de embedding especificado en el Settings para crear vectores de embedding a partir de los documentos y almacena estos vectores en el almacén de vectores especificado en el contexto de almacenamiento. Para saber más sobre el VectorStoreIndex puedes leer la guía de uso de VectorStoreIndex.

# Create a client and a new collection
client = chromadb.PersistentClient(path="./chroma_db")
chroma_collection = client.get_or_create_collection("quickstart")

# Create a vector store
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)

# Create a storage context
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Set Global settings
Settings.llm = llm
Settings.embed_model = gemini_embedding_model

# Create an index from the documents and save it to the disk.
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)

Crea un recuperador usando Chroma

Ahora crearás un recuperador que pueda recuperar embeddings de datos del almacén de vectores de Chroma recién creado.

Primero, inicializa el PersistentClient con la misma ruta que especificaste al crear el almacén de vectores de Chroma. Luego recuperarás la colección "quickstart" que creaste previamente de Chroma. Puedes usar esta colección para inicializar el ChromaVectorStore en el que almacenas los embeddings de los datos del sitio web. Luego puedes usar la función from_vector_store de VectorStoreIndex para cargar el índice.

from IPython.display import Markdown

# Load from disk
load_client = chromadb.PersistentClient(path="./chroma_db")

# Fetch the collection
chroma_collection = load_client.get_collection("quickstart")

# Fetch the vector store
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)

# Get the index from the vector store
index = VectorStoreIndex.from_vector_store(
    vector_store
)

# Check if the retriever is working by trying to fetch the relevant docs related
# to the phrase 'MMLU' (Multimodal Machine Learning Understanding).
# If the length is greater than zero, it means that the retriever is
# functioning well.
# You can ask questions about your data using a generic interface called
# a query engine. You have to use the `as_query_engine` function of the
# index to create a query engine and use the `query` function of query engine
# to inquire the index.
test_query_engine = index.as_query_engine()
response = test_query_engine.query("AIME")
Markdown(response.response)

<IPython.core.display.Markdown object>

2. Generador

El Generador solicita una respuesta al LLM cuando el usuario hace una pregunta. El recuperador que creaste en la etapa anterior desde el almacén de vectores de Chroma se usará para pasar embeddings relevantes de los datos del sitio web al LLM para proporcionar más contexto a la consulta del usuario.

Realizarás los siguientes pasos en esta etapa:

1. Crea un prompt para responder cualquier pregunta usando LlamaIndex.

2. Usa un motor de consulta para hacer una pregunta y solicitar una respuesta al modelo.

Crea plantillas de prompt

Usarás el PromptTemplate de LlamaIndex para generar prompts al LLM para responder preguntas.

En el llm_prompt, la variable query_str será reemplazada más tarde por la pregunta de entrada, y la variable context_str será reemplazada por el texto relevante del sitio web recuperado del almacén de vectores de Chroma.

from llama_index.core import PromptTemplate

template = (
    """ You are an assistant for question-answering tasks.
Use the following context to answer the question.
If you don't know the answer, just say that you don't know.
Use five sentences maximum and keep the answer concise.\n
Question: {query_str} \nContext: {context_str} \nAnswer:"""
)
llm_prompt = PromptTemplate(template)

Solicita al modelo usando Query Engine

Usarás la función as_query_engine del VectorStoreIndex para crear un motor de consulta a partir del índice usando el llm_prompt pasado como valor para el argumento text_qa_template. Luego puedes usar la función query del motor de consulta para solicitar al LLM. Para saber más sobre la creación de prompts personalizados en LlamaIndex, lee la documentación del patrón de uso de prompts de LlamaIndex.

# Query data from the persisted index
query_engine = index.as_query_engine(text_qa_template=llm_prompt)
response = query_engine.query("What is Gemini?")
Markdown(response.response)

<IPython.core.display.Markdown object>

¿Qué sigue?

Este notebook mostró solo un posible caso de uso para langchain con la API de Gemini. Puedes encontrar muchos más aquí.