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 tasa 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.

LangChain es un framework de datos diseñado para facilitar la integración de modelos de lenguaje grandes (LLM) como Gemini en aplicaciones.

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 utilizando datos de un sitio web con la ayuda de Gemini, LangChain y Chroma.

Configuración

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

Instalación

Instala la biblioteca de Python de LangChain, langchain y el paquete de integración de LangChain para Gemini, langchain-google-genai. Luego, instala el SDK cliente de Python de Chroma, chromadb.

%pip install --quiet langchain-core==0.1.23
%pip install --quiet langchain==0.1.1
%pip install --quiet langchain-google-genai==0.0.6
%pip install --quiet -U langchain-community==0.0.20
%pip install --quiet chromadb
%pip install --quiet bs4

from langchain import PromptTemplate
from langchain import hub
from langchain.docstore.document import Document
from langchain.document_loaders import WebBaseLoader
from langchain.schema import StrOutputParser
from langchain.schema.prompt_template import format_document
from langchain.schema.runnable import RunnablePassthrough
from langchain.vectorstores import Chroma

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 utilizar 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).

Utilizarás este enfoque para crear un asistente de preguntas y respuestas utilizando el modelo de texto Gemini integrado a través de LangChain. Se espera que el asistente responda preguntas sobre el modelo Gemini. Para que esto sea posible, agregarás más contexto al asistente utilizando 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.

Recuperador

En esta etapa, realizarás los siguientes pasos:

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

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. Utilizará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 utilizará para pasar embeddings relevantes del sitio web al LLM junto con las consultas del usuario.

Lee y analiza los datos del sitio web

LangChain ofrece una amplia variedad de cargadores de documentos. Para leer los datos del sitio web como un documento, usarás el WebBaseLoader de LangChain.

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

loader = WebBaseLoader("https://blog.google/technology/ai/google-gemini-ai/")
docs = loader.load()

Si solo quieres seleccionar una porción específica de los datos del sitio web para agregar contexto al prompt, puedes usar expresiones regulares, segmentación de texto o división de texto.

En este ejemplo, usarás la función split() de Python para extraer la porción de texto requerida. El texto extraído debe convertirse de nuevo al formato Document de LangChain.

# Extract the text from the website data document
text_content = docs[0].page_content

# The text content between the substrings "code, audio, image and video." to
# "Cloud TPU v5p" is relevant for this tutorial. You can use Python's `split()`
# to select the required content.
text_content_1 = text_content.split("code, audio, image and video.",1)[1]
final_text = text_content_1.split("Cloud TPU v5p",1)[0]

# Convert the text to LangChain's `Document` format
docs = [Document(page_content=final_text, metadata={"source": "local"})]

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 GoogleGenerativeAIEmbeddings de LangChain. Para saber más sobre el modelo de embedding, lee la documentación de lenguaje de Google AI.

from langchain_google_genai import GoogleGenerativeAIEmbeddings

gemini_embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-001")

Almacena los datos usando Chroma

Para crear una base de datos vectorial Chroma a partir de los datos del sitio web, usarás la función from_documents de Chroma. Internamente, esta función crea embeddings a partir de los documentos creados por el cargador de documentos de LangChain utilizando cualquier modelo de embedding especificado y los almacena en una base de datos vectorial Chroma.

Debes especificar los docs que creaste a partir de los datos del sitio web usando WebBasedLoader de LangChain y el gemini_embeddings como modelo de embedding al invocar la función from_documents para crear la base de datos vectorial a partir de los datos del sitio web. También puedes especificar un directorio en el argumento persist_directory para almacenar el almacén de vectores en el disco. Si no especificas un directorio, los datos serán efímeros en la memoria.

# Save to disk
vectorstore = Chroma.from_documents(
                     documents=docs,                 # Data
                     embedding=gemini_embeddings,    # Embedding model
                     persist_directory="./chroma_db" # Directory to save data
                     )

Crea un recuperador usando Chroma

Ahora crearás un recuperador que pueda recuperar embeddings de datos del sitio web del almacén de vectores Chroma recién creado. Este recuperador se podrá usar más tarde para pasar embeddings que proporcionen más contexto al LLM para responder las consultas del usuario.

Para cargar el almacén de vectores que almacenaste previamente en el disco, puedes especificar el nombre del directorio que contiene el almacén de vectores en persist_directory y el modelo de embedding en los argumentos embedding_function del inicializador de Chroma.

Luego puedes invocar la función as_retriever de Chroma en el almacén de vectores para crear un recuperador.

# Load from disk
vectorstore_disk = Chroma(
                        persist_directory="./chroma_db",       # Directory of db
                        embedding_function=gemini_embeddings   # Embedding model
                   )
# Get the Retriever interface for the store to use later.
# When an unstructured query is given to a retriever it will return documents.
# Read more about retrievers in the following link.
# https://python.langchain.com/docs/modules/data_connection/retrievers/
#
# Since only 1 document is stored in the Chroma vector store, search_kwargs `k`
# is set to 1 to decrease the `k` value of chroma's similarity search from 4 to
# 1. If you don't pass this value, you will get a warning.
retriever = vectorstore_disk.as_retriever(search_kwargs={"k": 1})

# Check if the retriever is working by trying to fetch the relevant docs related
# to the word 'MMLU' (Massive Multitask Language Understanding). If the length is greater than zero, it means that
# the retriever is functioning well.
print(len(retriever.get_relevant_documents("MMLU")))

1

Generador

El Generador solicita una respuesta al LLM cuando el usuario hace una pregunta. El recuperador que creaste en la etapa anterior a partir del almacén de vectores de Chroma se utilizará 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. Encadena lo siguiente:

   • Un prompt para extraer los embeddings relevantes usando el recuperador.
   • Un prompt para responder cualquier pregunta usando LangChain.
   • Un modelo LLM de Gemini para el prompting.

2. Ejecuta la cadena creada con una pregunta como entrada para solicitar una respuesta al modelo.

Inicializa Gemini

Debes importar ChatGoogleGenerativeAI de LangChain para inicializar tu modelo. En este ejemplo, usarás gemini-3.7-flash, ya que admite la sumarización de texto. Para saber más sobre el modelo de texto, lee la documentación de lenguaje de Google AI.

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

from langchain_google_genai import ChatGoogleGenerativeAI

# 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 = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

Crea plantillas de prompt

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

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

# Prompt template to query Gemini
llm_prompt_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: {question} \nContext: {context} \nAnswer:"""

llm_prompt = PromptTemplate.from_template(llm_prompt_template)

print(llm_prompt)

input_variables=['context', 'question'] template="You are an assistant for question-answering tasks.\nUse the following context to answer the question.\nIf you don't know the answer, just say that you don't know.\nUse five sentences maximum and keep the answer concise.\n\nQuestion: {question} \nContext: {context} \nAnswer:"

Crea una cadena de documentos "stuff"

LangChain proporciona Cadenas para encadenar LLM entre sí u otros componentes para aplicaciones complejas. Crearás una cadena de documentos "stuff" para esta aplicación. Una cadena de documentos "stuff" te permite combinar todos los documentos relevantes, insertarlos en el prompt y pasar ese prompt al LLM.

Puedes crear una cadena de documentos "stuff" usando el Lenguaje de Expresión de LangChain (LCEL).

Para obtener más información sobre los diferentes tipos de cadenas de documentos, lee la guía de cadenas de LangChain.

La cadena de documentos "stuff" para esta aplicación recupera los datos relevantes del sitio web y los pasa como contexto a un prompt de LLM junto con la pregunta de entrada.

# Combine data from documents to readable string format.
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# Create stuff documents chain using LCEL.
#
# This is called a chain because you are chaining together different elements
# with the LLM. In the following example, to create the stuff chain, you will
# combine the relevant context from the website data matching the question, the
# LLM model, and the output parser together like a chain using LCEL.
#
# The chain implements the following pipeline:
# 1. Extract the website data relevant to the question from the Chroma
#    vector store and save it to the variable `context`.
# 2. `RunnablePassthrough` option to provide `question` when invoking
#    the chain.
# 3. The `context` and `question` are then passed to the prompt where they
#    are populated in the respective variables.
# 4. This prompt is then passed to the LLM (`gemini-3.7-flash`).
# 5. Output from the LLM is passed through an output parser
#    to structure the model's response.
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | llm_prompt
    | llm
    | StrOutputParser()
)

Pide al modelo

Ahora puedes consultar el LLM pasando cualquier pregunta a la función invoke() de la cadena de documentos "stuff" que creaste anteriormente.

from IPython.display import Markdown

Markdown(rag_chain.invoke("What is Gemini?"))

<IPython.core.display.Markdown object>

Conclusión

Eso es todo. Has creado con éxito una aplicación LLM que responde preguntas utilizando datos de un sitio web con la ayuda de Gemini, LangChain y Chroma.