Preguntas y respuestas con Gemini, LangChain y Pinecone

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.

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

Pinecone es una base de datos vectorial nativa de la nube que permite a los usuarios buscar entre miles de millones de embeddings con una latencia de consulta ultrabaja.

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

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 paquete de integración de LangChain para la nueva versión de Pinecone, langchain-pinecone y el pinecone-client, que es el SDK de Python de Pinecone. Finalmente, instala langchain-community para acceder al módulo WebBaseLoader más tarde.

%pip install --quiet -U langchain
%pip install --quiet -U langchain-google-genai
%pip install --quiet -U langchain-pinecone
%pip install --quiet -U pinecone
%pip install --quiet -U langchain-community
%pip install --quiet -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

Configura Pinecone

Para usar Pinecone en tu aplicación, debes tener una clave de API. Para crear una clave de API, tienes que configurar una cuenta de Pinecone. Visita la página de la aplicación de Pinecone e inicia sesión o regístrate en tu cuenta. Luego, navega a la sección "API Keys" y copia tu clave de API.

Para obtener instrucciones más detalladas sobre cómo obtener la clave de API, puedes leer la documentación de inicio rápido de Pinecone.

Establece la variable de entorno PINECONE_API_KEY para configurar Pinecone y usar tu clave de API.

PINECONE_API_KEY=userdata.get('PINECONE_API_KEY')

os.environ['PINECONE_API_KEY'] = PINECONE_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, tienes que 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, añadirá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 añaden 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 langchain import hub
from langchain import PromptTemplate
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.text_splitter import RecursiveCharacterTextSplitter
from langchain_pinecone import PineconeVectorStore
from pinecone import Pinecone as pc
from pinecone import ServerlessSpec

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

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

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

   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, utilizarás el WebBaseLoader de LangChain.

Para saber más sobre cómo leer y analizar datos de entrada de diferentes fuentes utilizando 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 añadir 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, utilizará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, tienes que 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 Pinecone

Para crear una base de datos vectorial de Pinecone, primero, tienes que inicializar tu conexión de cliente de Pinecone usando la clave de API que configuraste previamente.

En Pinecone, los embeddings vectoriales deben almacenarse en índices. Un índice representa la unidad organizativa de nivel superior de los datos vectoriales. Los vectores en cualquier índice deben tener la misma dimensionalidad y métrica de distancia para calcular la similitud. Puedes leer más sobre los índices en la documentación de índices de Pinecone.

Primero, crearás un índice usando la función create_index de Pinecone. Pinecone te permite crear dos tipos de índices: índices sin servidor e índices basados en pods. El plan de inicio gratuito de Pinecone te permite crear solo un proyecto y un índice de inicio basado en pods con recursos suficientes para admitir 100,000 vectores. Para este tutorial, tienes que crear un índice de inicio basado en pods. Para saber más sobre los diferentes índices y cómo se pueden crear, lee la guía de creación de índices de Pinecone.

A continuación, insertarás los documentos que extrajiste anteriormente de los datos del sitio web en el índice recién creado utilizando Pinecone.from_documents de LangChain. 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 inserta en el índice especificado en una base de datos vectorial de Pinecone.

Debes especificar el 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.

# Initialize Pinecone client

pine_client= pc(
    api_key = os.getenv("PINECONE_API_KEY"),  # API key from app.pinecone.io
    )
index_name = "langchain-demo"

# First, check if the index already exists. If it doesn't, create a new one.
if index_name not in pine_client.list_indexes().names():
    # Create a new index.
    # https://docs.pinecone.io/docs/new-api#creating-a-starter-index
    print("Creating index")
    pine_client.create_index(name=index_name,
                      # `cosine` distance metric compares different documents
                      # for similarity.
                      # Read more about different distance metrics from
                      # https://docs.pinecone.io/docs/indexes#distance-metrics.
                      metric="cosine",
                      # The Gemini embedding model `gemini-embedding-001` uses
                      # 3072 dimensions.
                      dimension=3072,
                      # The `pod_type` is the type of pod to use.
                      # Read more about different pod types from
                      # https://docs.pinecone.io/docs/pod-types.
                      # Specify the pod details.
                      spec=ServerlessSpec(
                        cloud="aws",
                        region="us-east-1"
                        ),
    )
    print(pine_client.describe_index(index_name))

vectorstore = PineconeVectorStore.from_documents(docs,
                      gemini_embeddings, index_name=index_name)

Creating index
{'deletion_protection': 'disabled',
 'dimension': 3072,
 'host': 'langchain-demo-u4710cy.svc.aped-4627-b74a.pinecone.io',
 'metric': 'cosine',
 'name': 'langchain-demo',
 'spec': {'serverless': {'cloud': 'aws', 'region': 'us-east-1'}},
 'status': {'ready': True, 'state': 'Ready'},
 'tags': None,
 'vector_type': 'dense'}

Crea un recuperador usando Pinecone

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

Invoca la función as_retriever del almacén de vectores que inicializaste en el último paso para crear un recuperador.

retriever = vectorstore.as_retriever()
# 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.invoke("MMLU")))

1

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 Pinecone 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

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

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

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

Question: {question}
Context: {context}
Answer:"""

llm_prompt = PromptTemplate.from_template(llm_prompt_template)

print(llm_prompt)

input_variables=['context', 'question'] input_types={} partial_variables={} 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" utilizando 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 del 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 a stuff chain,
# you will combine content, prompt, LLM model, and
# output parser together like a chain using LCEL.
#
# The chain implements the following pipeline:
# 1. Extract data from documents and save to the variable `context`.
# 2. Use the `RunnablePassthrough` option to provide question during invoke.
# 3. The `context` and `question` are then passed to the prompt and
#    input variables in the prompt are populated.
# 4. The 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 response.
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | llm_prompt
    | llm
    | StrOutputParser()
)

Solicita 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>

Resumen

La API de Gemini funciona muy bien con LangChain. La integración es perfecta y proporciona una interfaz sencilla para:

• cargar y dividir archivos
• crear una base de datos Pinecone con embeddings
• responder preguntas basadas en el contexto de los archivos

¿Qué sigue?

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