En este artículo aprenderás:
- Qué son las canalizaciones de IA de Vértice.
- Por qué puede integrar la API SERP de Bright Data en ellos para la comprobación de hechos (y muchos otros casos de uso).
- Cómo crear una canalización de comprobación de hechos en Vertex IA utilizando la API SERP de Bright Data para recuperar el contexto de búsqueda web actualizado.
¡Entremos en materia!
¿Qué son las canalizaciones de Vértice IA?
Vertex IA Pipelines es un servicio gestionado en Google Cloud que automatiza, organiza y reproduce flujos de trabajo de aprendizaje automático de extremo a extremo.
Este servicio le permite dividir procesos complejos de aprendizaje automático, como el procesamiento de datos, el entrenamiento y la implementación, en una serie de componentes modulares que pueden rastrearse, versionarse y ejecutarse en un entorno sin servidor.
En resumen, Vertex IA Pipelines simplifica el ciclo de vida de MLOps, facilitando la creación de sistemas ML repetibles y escalables.
Creación de una canalización de comprobación de hechos en Vertex IA: por qué y cómo
Los LLM son sin duda potentes, pero sus conocimientos son estáticos. Por lo tanto, un LLM formado en 2024 no conoce los movimientos bursátiles de ayer, los resultados deportivos de anoche, etc. Esto da lugar a respuestas “rancias” o “alucinadas”.
Para solucionarlo, se puede construir un sistema que “base” un LLM con datos actualizados de Internet. Antes de que el LLM genere una respuesta, recibe información externa para asegurarse de que su resultado se basa en hechos actuales. En eso consiste la RAG(Retrieval-Augmented Generation).
Ahora bien, Gemini proporciona una herramienta de base para conectar los modelos Gemini a Google Search. Sin embargo, esa herramienta no está preparada para la producción, tiene problemas de escalabilidad y no ofrece un control total sobre la fuente de los datos de base. Vea esa herramienta en acción en nuestro agente de optimización de contenidos GEO/SEO.
Una alternativa más profesional y flexible es la API SERP de Bright Data. Esta API le permite ejecutar mediante programación consultas de búsqueda en motores de búsqueda y recuperar el contenido completo de la SERP. En otras palabras, le proporciona una fuente fiable de contenido fresco y verificable que puede integrarse en sus flujos de trabajo LLM. Descubra todo lo que puede ofrecerle explorando su documentación.
Por ejemplo, puede integrar la API SERP en Vertex IA Pipelines como parte de una cadena de comprobación de hechos. Esto constará de tres pasos:
- Extraer consultas: Un LLM lee el texto de entrada e identifica las principales afirmaciones factuales, convirtiéndolas en consultas que se pueden buscar en Google.
- Obtención del contexto de búsqueda web: Este componente toma estas consultas y llama a la API SERP de Bright Data para obtener resultados de búsqueda en tiempo real.
- Comprobación de hechos: Un último paso de LLM toma el texto original y el contexto de búsqueda recuperado y genera un informe de comprobación de hechos.
Nota: Éste es sólo uno de los muchos casos de uso posibles de la API SERP en una canalización de datos/ML.
Cómo integrar la API SERP de Bright Data para búsquedas web en una canalización de IA de Vértice
En esta sección, se le guiará a través de cada paso necesario para implementar una canalización de comprobación de hechos en canalizaciones de IA de Vértice. Esto se basará en la API SERP de Bright Data, que se utilizará para obtener el contexto de búsqueda web basado en hechos.
Recuerde que la comprobación de hechos es sólo uno de los muchos casos de uso (como el descubrimiento de noticias, el resumen de contenidos, el análisis de tendencias o la ayuda a la investigación) en los que puede utilizar la API SERP en un nodo de canalización de IA de Vértice. Por lo tanto, puede adaptar fácilmente esta implementación a muchos otros escenarios.
Aclarado esto, ¡siga los pasos que se indican a continuación!
Requisitos previos
Para seguir esta sección del tutorial, asegúrese de que dispone de:
- Una cuenta de Google Cloud Console.
- Una cuenta de Bright Data con una clave de API activa (idealmente con permisos de administrador).
Siga la guía oficial de Bright Data para aprender a recuperar su clave de API. Guárdela en un lugar seguro, ya que la necesitará en breve.
Paso 1: Cree y configure un nuevo proyecto de Google Cloud
Inicie sesión en Google Cloud Console y cree un nuevo proyecto. Asegúrese también de que la facturación está activada (también puede utilizar una versión de prueba gratuita).
En este ejemplo, llame al proyecto de Google Cloud “Bright Data API SERP Pipeline” y defina el ID del proyecto como bright-data-pipeline:
Una vez creado el proyecto, selecciónelo para empezar a trabajar en él. Ahora debería ver una vista como esta:
En esta página encontrará el nombre del proyecto, el número del proyecto y el ID del proyecto. Necesitarás tanto el número como el ID del proyecto más adelante en el tutorial, así que anótalos y guárdalos en un lugar seguro.
Ahora que tu proyecto de Google Cloud está listo, el siguiente paso es activar las API necesarias. En la barra de búsqueda, escribe “API y servicios”, llega a la página y haz clic en el botón “Activar API y servicios”:
Busque y active las siguientes API:
Estas dos API son necesarias para utilizar y desarrollar con Vertex IA en Vertex IA Workbench.
Nota: El pipeline también depende de otras API, que suelen estar activadas por defecto. En caso de problemas, verifica que también estén habilitadas:
- “API de gestión de recursos en la nube”
- “API de almacenamiento en la nube
- “API de uso de servicios
- “API de motor de computación
- “API de Gemini para Google Cloud
- “API de registro en la nube”
Si alguna de ellas está deshabilitada, habilítala manualmente antes de continuar.
Listo. Ya tienes un proyecto Google Cloud.
Paso 2: Configurar el cubo de almacenamiento en la nube
Para ejecutar las canalizaciones de Vértice IA, necesita un cubo de almacenamiento en la nube. Esto se debe a que Vertex IA tiene que almacenar artefactos de pipelines, como datos intermedios, archivos de modelos, registros y metadatos generados durante la ejecución de pipelines. En otras palabras, el bucket configurado actúa como el espacio de trabajo en el que los componentes de su canalización leen y escriben datos.
Para crear un bucket, busca “Almacenamiento en la nube” en Google Cloud Console. Abre el primer resultado, selecciona “Buckets” en el menú de la izquierda y, a continuación, pulsa el botón “Crear”:
En el formulario de creación de buckets
- Dale un nombre único global, como
bright-data-pipeline-artifacts. - Elija un tipo de ubicación y una región. Para simplificar, recomendamos seleccionar la opción “us (multiple regions in United States)”.
Una vez creado, anote el nombre del cubo, ya que lo necesitará más adelante en la configuración del pipeline. Ahora debería ver algo como esto:
En este caso, el nombre del cubo es:
bright-data-pipeline-artifacts Mientras que el URI del bucket es
gs://bright-data-pipeline-artifactsComo ha elegido la multirregión “us”, puede acceder a este bucket a través de cualquier región us-* compatible. Esto incluye us-central1, us-east1, …, us-west1…, etc. Recomendamos establecer us-central1.
Ahora, necesita dar permiso a Vertex IA para leer y escribir datos en su bucket. Para ello, haga clic en el nombre del bucket para abrir su página de detalles y, a continuación, vaya a la pestaña “Permisos”:
Haga clic en el botón “Conceder acceso” y añada una nueva regla de permiso como se indica a continuación:
- Titular:
<NÚMERO_DE_PROYECTO_DE_SU_GC>[email protected] - Función:
Administrador de almacenamiento
(Importante: Para entornos de producción, asigne sólo los roles mínimos requeridos. El uso del acceso completo “Administrador de almacenamiento” es sólo por simplicidad en esta configuración).
Haga clic en “Guardar” para confirmar el nuevo rol, que otorga al servicio Compute Engine de su proyecto la capacidad de acceder y gestionar objetos en su bucket Cloud Storage.
Sin ese permiso, su canalización Vertex IA no podría leer o escribir datos durante la ejecución, lo que provocaría errores 403 Forbidden como el que se muestra a continuación:
google.api_core.exceptions.Forbidden: 403 GET https://storage.googleapis.com/storage/v1/b/bright-data-pipeline-artifacts?fields=name&prettyPrint=false: <YOUR_GC_PROJECT_NUMBER>[email protected] no tiene acceso storage.buckets.get al bucket de almacenamiento en la nube de Google. Permiso 'storage.buckets.get' denegado en el recurso (o puede que no exista).Increíble. Cubo de Google Cloud Storage configurado.
Paso #3: Configurar los permisos IAM
Al igual que con el cubo de almacenamiento en la nube, también tiene que dar a la cuenta de servicio Compute Engine de su proyecto los permisos IAM adecuados.
Estos permisos permiten a Vertex IA crear y gestionar trabajos de canalización en su nombre. Sin ellos, la canalización no tendrá autoridad para lanzar o controlar su ejecución dentro de su proyecto de Google Cloud.
Para configurarlos, busque “IAM & Admin” en Google Cloud Console y abra la página.
Haga clic en el botón “Conceder acceso” y, a continuación, añada las dos funciones siguientes a su cuenta de servicio predeterminada de Compute Engine (es decir, <YOUR_GC_PROJECT_NUMBER>[email protected]):
- “Usuario de cuenta de servicio”
- “Usuario de IA de vértice
Una vez asignados los roles, pulse el botón “Guardar”. De este modo, su canalización de Vértice IA podrá utilizar los recursos informáticos de su proyecto y ejecutar cargas de trabajo gestionadas.
En resumen, indica a Google Cloud que sus canalizaciones de IA de vértice están autorizadas a actuar en nombre de la cuenta de servicios informáticos de su proyecto. Sin estos permisos, se encontrará con errores 403 Forbidden como el siguiente al intentar lanzar un trabajo de canalización:
403 POST https://us-central1-aiplatform.googleapis.com/v1/projects/bright-data-pipeline/locations/us-central1/pipelineJobs?pipelineJobId=XXXXXXXXXXXXXXXXXXXXXXX&%24alt=json%3Benum-encoding%3Dint: Permission 'aiplatform.pipelineJobs.create' denied on resource '//aiplatform.googleapis.com/projects/bright-data-pipeline/locations/us-central1' (or it may not exist). [{'@type': 'type.googleapis.com/google.rpc.ErrorInfo', 'reason': 'IAM_PERMISSION_DENIED', 'domain': 'aiplatform.googleapis.com', 'metadata': {'resource': 'projects/bright-data-pipeline/locations/us-central1', 'permission': 'aiplatform.pipelineJobs.create'}}].¡Todo listo! IAM ya está configurado y listo para la ejecución de canalizaciones de IA de Vértice.
Paso 4: Empezar con Vertex IA Workbench
Para simplificar el desarrollo, creará nuestro canal de IA de vértice directamente en la nube, sin necesidad de configuración local.
En concreto, utilizará Vertex IA Workbench, un entorno de desarrollo totalmente gestionado basado en JupyterLab dentro de la plataforma Vertex IA de Google Cloud. Está diseñado para soportar flujos de trabajo completos de ciencia de datos, desde la creación de prototipos hasta el despliegue de modelos.
Nota: Antes de continuar, asegúrese de que la “API de cuadernos” está activada, ya que es necesaria para que Vertex IA Workbench funcione.
Para acceder a Vertex IA Workbench, busque “Vertex IA Workbench” en Google Cloud Console y abra la página. A continuación, en la pestaña “Instancias”, haga clic en “Crear nueva” para iniciar una nueva instancia:
Nota: Aunque Vertex IA Workbench admite Jupyter 4 para nuevas instancias, todos los entornos utilizan actualmente JupyterLab 3 por defecto. Esta versión ya viene con las últimas librerías y controladores de GPU NVIDIA e Intel preinstalados. Por lo tanto, para este tutorial, deberías optar por JupyterLab 3.
En el formulario de creación de instancia, deja todos los valores de configuración por defecto, incluyendo el tipo de máquina por defecto (que debería ser n1-standard-4). Esa máquina es más que suficiente para esta guía.
Haz clic en “Crear” y ten en cuenta que la instancia tardará unos minutos en aprovisionarse e iniciarse. Una vez que esté lista, verás una nueva entrada en la tabla “Instancias” con un enlace llamado “Abrir JupyterLab”. Haz clic en él:
Se te redirigirá a tu entorno JupyterLab basado en la nube, totalmente alojado en Google Cloud:
Aquí, haz clic en “Python 3 (ipykernel)” en “Cuaderno” para crear un nuevo cuaderno. Este cuaderno le servirá como entorno de desarrollo para escribir y probar su canalización Vertex IA integrada con Bright Data:
¡Fantástico! Ya está listo para empezar a codificar y construir la lógica de su canalización de Datos para IA de Vértice.
Paso 5: Instalar e inicializar las librerías Python necesarias
En su notebook, comience añadiendo y ejecutando la siguiente celda para instalar todas las librerías Python que necesitará para este proyecto:
!pip install kfp google-cloud-aiplatform google-genai brightdata-sdk --quiet --upgradeEsto puede tardar unos minutos, así que ten paciencia mientras el entorno lo configura todo.
He aquí lo que hace cada biblioteca y por qué es necesaria:
kfp: Este es el SDK de Kubeflow Pipelines, que le permite definir, compilar y ejecutar tuberías de aprendizaje automático mediante programación en Python. Viene con decoradores y clases para crear componentes de canalización.google-cloud-aiplatform: El SDK de IA de Vertex para Python. Proporciona todo lo necesario para interactuar directamente con los servicios de IA de Vértice de Google Cloud, incluido el entrenamiento de modelos, la implementación de puntos finales y la ejecución de canalizaciones.google-genai: El SDK de IA generativa de Google, que permite utilizar y orquestar Gemini y otros modelos generativos (también en Vertex IA). Esto es útil, ya que el pipeline incluye tareas LLM.(Recuerda: Vertex IA SDK está obsoleto).brightdata-sdk: El SDK de Bright Data, utilizado para conectar y obtener datos en tiempo real a través de la API SERP de Bright Data u otras fuentes de datos web directamente desde su pipeline.
Una vez instaladas todas las bibliotecas, impórtelas e inicialice el SDK de IA de Vértice con el siguiente código en una celda dedicada:
importar kfp
from kfp.dsl import component, pipeline, Input, Output, Artifact
from kfp import compilador
from google.cloud import aiplatform
from typing import Lista
# Reemplazar con los secretos de su proyecto
PROJECT_ID = "<SU_GC_PROJECT_ID>"
REGION = "<SU_REGION>" # (por ejemplo, "us-central1")
BUCKET_URI = "<SU_BUCKET_URI>" # (por ejemplo, "gs://bright-data-pipeline-artifacts")
# Inicializar el SDK de IA de Vértice
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)La función aiplatform.init( ) configura tu entorno Python para comunicarse con Vertex IA. Establece el proyecto, la región y el staging bucket para que todas las operaciones posteriores de Vértice IA, como la creación de pipelines, la formación de trabajos o el despliegue de modelos, utilicen automáticamente el contexto correcto.
En resumen, esa única línea de código conecta la sesión del bloc de notas con el proyecto de Google Cloud e indica a Vertex IA dónde almacenar los artefactos de la canalización y los datos temporales. Bien hecho.
Paso 6: Definir el componente de extracción de consultas
Recuerde que un Canal de Vértice IA se construye a partir de componentes, donde un componente es sólo una función Python que realiza una tarea específica. Como se explicó anteriormente, esta tubería tendrá tres componentes.
Empecemos con el primero, el componente extract_queries.
El componente extract_queries:
- Toma el texto a verificar como entrada.
- Utiliza un modelo Gemini (a través de la biblioteca
google-genai) para generar una lista de consultas de búsqueda en Google que ayuden a verificar las afirmaciones de ese texto. - Devuelve la lista como una matriz de Python
(List[str]).
Impleméntalo como sigue:
@componente(
imagen_base="python:3.10",
packages_to_install=["google-genai"],
)
def extraer_consultas(
texto_entrada: str,
proyecto: str,
ubicación: str,
) -> Lista[str]:
from google import genai
from google.genai.types import GenerateContentConfig, HttpOptions
from typing import List
import json
# Inicializar el SDK de IA de Google Gen con integración Vertex
client = genai.Client(
vertexai=Verdadero
project=proyecto,
location=ubicación,
http_options=HttpOptions(api_version="v1")
)
# El esquema de salida, que es una matriz de cadenas
esquema_respuesta = {
"type": "ARRAY",
"items": {
"type": "STRING"
}
}
# El prompt del extractor de consultas
prompt = f""
Usted es un verificador de hechos profesional. Su trabajo consiste en leer el siguiente texto y extraer
una lista de búsquedas específicas en Google que serían necesarias
para verificar los hechos principales.
Devuelve *sólo* una lista Python de cadenas, y nada más.
Ejemplo:
Entrada: "La Torre Eiffel, construida en 1889 por Gustave Eiffel, tiene 300 metros de altura".
Salida: ["cuándo se construyó la torre eiffel", "quién construyó la torre eiffel", "cuánto mide la torre eiffel"]
Este es el texto a comprobar:
---
"{input_text}"
---
"""
response = client.models.generate_content(
model="gemini-2.5-flash",
contenido=prompt,
config=GenerarContenidoConfig(
# Fuerza al modelo a devolver una matriz JSON de cadenas
response_mime_type="application/json",
response_schema=esquema_de_respuesta,
),
)
# El 'response.text' contendrá de forma fiable una cadena JSON conforme al esquema (por ejemplo, '["query_1", ..., "query_n"]')
lista_consulta: List[str] = json.loads(response.text.strip())
return lista_consultaTen en cuenta que los componentes KFP deben ser autocontenidos. Eso significa que todas las importaciones deben ser declaradas dentro de la función del componente, no globalmente.
Observa que los parámetros vertexai=True, project=proyecto, y location=ubicación en genai.Client() son necesarios para conectar el cliente google-genai con tu entorno Vertex IA. Garantizan que el modelo configurado se ejecute en la misma región y proyecto que tu pipeline.
En cuanto a la elección del modelo, aquí deberías usar Gemini 2.5 Flash porque es ligero y rápido. De todos modos, puede configurar otro modelo Gemini para una mayor precisión si es necesario.
Un componente menos, ¡faltan dos!
Paso #7: Crear el Componente Recuperador de Contexto de Búsqueda Web Potenciado por la API SERP
Ahora que ha generado una lista de consultas aptas para Google, es el momento de buscar contexto en la web. Para ello, utilice la API SERP de Bright Data, que le permite extraer resultados de búsqueda mediante programación (Google, por defecto) de forma estructurada y escalable.
La forma más sencilla de acceder a la API SERP desde Python es a través del SDK oficial y de código abierto de Bright Data. Esta biblioteca le proporciona métodos sencillos para llamar a los productos de Bright Data, incluida la API SERP. Obtenga más información en la documentación.
En particular, el componente fetch_web_search_context:
- Acepta una lista de consultas de búsqueda generadas en el paso anterior.
- Utiliza el SDK de Bright Data para llamar a la API SERP en paralelo para cada consulta.
- Recupera los resultados de la búsqueda (por defecto, de Google).
- Guarda todos los resultados como un artefacto JSON, un archivo que otros componentes de la canalización pueden utilizar.
Cree un componente de este tipo en una celda dedicada del bloc de notas de la siguiente manera
@componente(
imagen_base="python:3.10",
packages_to_install=["brightdata-sdk"],
)
def fetch_web_search_context(
consultas: List[str],
api_key: str,
fichero_salida: Salida[artefacto],
):
"""
Toma una lista de consultas, busca en cada una de ellas utilizando Bright Data SDK
y escribe todos los resultados como un artefacto de archivo JSON.
"""
from brightdata import bdclient
importar json
# Inicializar el cliente del SDK de Bright Data
client = bdclient(api_token=api_key)
# Llamar a la API SERP en las consultas de entrada
resultados = client.search(
consultas,
data_format="markdown"
)
# Escribir los resultados en un archivo de artefactos
with open(ruta_archivo_salida, "w") as f:
json.dump(resultados, f)Tenga en cuenta que la API SERP se ha configurado para devolver el contenido en formato Markdown, que es ideal para la ingestión en LLM.
Además, dado que la salida de este componente puede ser bastante grande, es mejor almacenarla como artefacto. Los artefactos se almacenan en su cubo de Google Cloud Storage y permiten a los componentes de una canalización de IA de Vértice pasar datos entre sí de manera eficiente sin sobrecargar la memoria o exceder los límites de transferencia de datos.
Ya está. Gracias a la potencia de las capacidades de búsqueda web de Bright Data, ahora tiene el contexto de búsqueda respaldado por Google listo para ser utilizado como entrada para el siguiente componente, donde un LLM realizará la comprobación de hechos.
Paso 8: Implementar el componente de comprobación de hechos
De forma similar al componente de extracción de consultas, este paso también implica llamar a un LLM. Sin embargo, en lugar de generar consultas, este componente utiliza los resultados de búsqueda web recopilados en el paso anterior como evidencia contextual para comprobar los hechos del texto de entrada original.
Esencialmente, ejecuta un flujo de trabajo de estilo RAG basado en SERP en el que el contenido web recuperado guía el proceso de verificación del modelo.
En una nueva celda del bloc de notas, defina el componente fact_check_with_web_search_context como sigue:
@componente(
base_image="python:3.10",
packages_to_install=["google-genai"],
)
def fact_check_with_web_search_context(
texto_entrada: str,
archivo_contexto_búsqueda_web: input[artefacto],
proyecto: str,
ubicación: str,
) -> str:
import json
from google import genai
# Cargar el contexto de búsqueda web desde el artefacto
with open(archivo_contexto_búsqueda_web.ruta, "r") as f:
web_search_context = json.load(f)
cliente = genai.Cliente(
vertexai=Verdadero
proyecto=proyecto,
ubicación=ubicación
)
prompt = f"""
Usted es un verificador de hechos de IA. Compara el texto original con el contexto de búsqueda JSON
y elabora un informe en Markdown.
[Texto original]
"{texto_de_entrada}"
[Contexto de búsqueda web]
"{json.dumps(web_search_context)}"
"""
response = client.models.generate_content(
model="gemini-2.5-pro",
contenido=prompt
)
return respuesta.textoEsta tarea es más compleja y requiere razonar sobre múltiples fuentes de pruebas. Por lo tanto, es mejor utilizar un modelo más capaz como Gemini 2.5 Pro.
Muy bien. Ya ha definido los tres componentes que forman su canal de IA de Vértice.
Paso 9: Definir y compilar la canalización
Conecte los tres componentes en un único pipeline Kubeflow. Cada componente se ejecutará secuencialmente, con la salida de un paso que se convierte en la entrada de la siguiente.
Esta es la forma de definir la tubería:
@pipeline(
name="bright-data-fact-checker-pipeline",
description="Obtiene el contexto SERP para comprobar un documento de texto".
)
def fact_check_pipeline(
texto_entrada: str,
bright_data_api_key: str,
proyecto: str = PROJECT_ID,
ubicación: str = REGIÓN,
):
# Paso 1: Extraer consultas aptas para Google del texto de entrada para verificarlas
paso1 = extraer_consultas(
texto_entrada=texto_entrada,
proyecto=proyecto,
ubicación=ubicación
)
# Paso 2: Obtener los resultados SERP de Bright Data sobre las consultas de búsqueda
paso2 = fetch_web_search_context(
consultas=paso1.salida,
bright_data_api_key=bright_data_api_key
)
# Paso 3: Realizar la comprobación de hechos utilizando el contexto de búsqueda web recuperado anteriormente
paso3 = fact_check_with_web_search_context(
texto_entrada=texto_entrada,
web_search_context_file=step2.outputs["output_file"],
project=proyecto,
ubicación=ubicación
) En esencia, esta función enlaza los tres componentes que has creado anteriormente. Comienza generando consultas de comprobación de hechos, luego recupera los resultados de búsqueda para cada consulta utilizando la API SERP de Bright Data y, por último, ejecuta un modelo Gemini para verificar las afirmaciones basándose en las pruebas recopiladas.
A continuación, debe compilar la canalización en una especificación JSON que Vertex IA pueda ejecutar:
compiler.Compiler().compile(
pipeline_func=fact_check_pipeline,
package_path="fact_check_pipeline.json"
)Este comando convierte su definición de canalización Python en un archivo de especificación de canalización JSON llamado fact_check_pipeline.json.
Este archivo JSON es un modelo en el que confían las canalizaciones de IA de Vértice para comprender cómo orquestar el flujo de trabajo. Describe cada componente, sus entradas y salidas, dependencias, imágenes contenedoras y orden de ejecución.
Al ejecutar este archivo JSON en Vertex IA, Google Cloud aprovisiona automáticamente la infraestructura, ejecuta cada componente en el orden correcto y gestiona el paso de datos entre pasos. ¡Pipeline completo!
Paso 10: Ejecutar la canalización
Supongamos que desea probar la canalización de Vértice IA con una afirmación claramente falsa como la siguiente:
“París es la capital de Alemania, que utiliza el yen como moneda”.
Añada la siguiente celda a su cuaderno Jupyter. Este Add define la lógica para lanzar el pipeline:
TEXT_TO_CHECK = """
París es la capital de Alemania, que utiliza el yen como moneda.
"""
# Sustituya con su clave API de Bright Data
BRIGHT_DATA_API_KEY = "<SU_CLAVE_API_DE_BRIGHT_DATA>"
print("Iniciando el trabajo de canalización...")
# Definir el trabajo de canalización
job = aiplatform.PipelineJob(
display_name="fact-check-pipeline-run",
template_path="fact_check_pipeline.json",
pipeline_root=BUCKET_URI,
parameter_values={
"input_text TEXT_TO_CHECK,
"bright_data_api_key": BRIGHT_DATA_API_KEY
}
)
# Ejecutar el trabajo
job.run()
print("¡Trabajo enviado! Puede ver su progreso en la interfaz de usuario de Vértice IA.")Este código crea un nuevo trabajo de canalización de Vértice IA, especificando el JSON de canalización que compiló anteriormente(fact_check_pipeline.json), su bucket de almacenamiento como raíz de canalización y los parámetros necesarios para esta ejecución concreta (es decir, el texto de entrada que debe verificarse y su clave de API de Bright Data).
Una vez que ejecute esta celda, Vertex IA orquestará automáticamente toda su canalización en la nube.
Nota de seguridad: Este ejemplo codifica la clave API de Bright Data directamente en el bloc de notas para simplificar, pero esto no es seguro para entornos de producción. En una implementación real, debe almacenar y recuperar credenciales confidenciales como claves de API mediante Google Cloud Secret Manager para evitar la exposición accidental (por ejemplo, en registros).
Para ejecutar tu pipeline, selecciona todas las celdas y pulsa el botón “▶” en tu cuaderno Jupyter. Obtendrás esta salida en la última celda:
Esto significa que tu pipeline de verificación de hechos de Vértice IA se está ejecutando correctamente. ¡Guau!
Paso 11: Monitorizar la ejecución del pipeline
Para comprobar el estado de su trabajo de canalización, acceda a la página Vertex IA Pipelines en Google Cloud Console para su proyecto:
https://console.cloud.google.com/vertex-ai/pipelines?project={ID_PROYECTO}Así que, en este caso, la URL es
https://console.cloud.google.com/vertex-ai/pipelines?project=bright-data-pipelinePega la URL en el navegador y verás una página como esta:
Haga clic en la primera entrada de la tabla “Runs” para abrir la página de ejecución del trabajo del pipeline:
Aquí puede ver los componentes de su pipeline. También puede comprobar el estado de cada nodo, ver los registros detallados, y observar el flujo de datos desde el principio hasta el final de la tubería a medida que se ejecuta.
Paso nº 12: Explorar el resultado
Una vez finalizada la ejecución de la canalización, cada nodo mostrará una marca de verificación que indica que se ha completado con éxito:
Haga clic en el primer nodo para inspeccionar las consultas que se pueden buscar en Google extraídas del texto de entrada. En este ejemplo, las consultas generadas son:
"¿Cuál es la capital de Alemania?"qué moneda utiliza Alemania
Estas consultas son perfectamente adecuadas para verificar las afirmaciones fácticas del enunciado de entrada:
A continuación, haga clic en el nodo artefacto situado entre el segundo y el tercer nodo. Obtendrá un enlace al archivo JSON almacenado en su bucket configurado de Google Cloud Storage (en este caso, bright-data-pipeline-artifacts).
También puede acceder directamente a la página deseada navegando hasta el bucket en la Cloud Console:
Dentro del bucket, verá una carpeta para cada componente. En concreto, la carpeta del componente fetch_web_search_context contiene un archivo JSON con el contexto de búsqueda web recuperado a través de la API SERP, almacenado como una matriz de cadenas con formato Markdown:
Si descarga y abre el archivo, verá algo parecido a esto:
Este contenido es la representación Markdown de las SERP recuperadas para cada consulta de búsqueda identificada.
De vuelta en la interfaz de usuario del canal de IA de Vértice, haga clic en el nodo de salida para inspeccionar los resultados generales:
Como puede ver, el resultado es un informe detallado de comprobación de hechos en Markdown. El mismo resultado se guarda también en el archivo executor_output.json en la carpeta bucket para la ejecución de la canalización. Descárguelo y ábralo en un IDE como Visual Studio Code para inspeccionarlo:
Copie la cadena Markdown en un archivo .md (por ejemplo, report.md) para verlo con mayor claridad:
El informe proporciona información detallada sobre qué partes de la declaración de entrada eran incorrectas y cuáles son los hechos verificados.
¡Et voilà! Esto demuestra la potencia de la integración de la búsqueda web de Bright Data para recuperar información contextual en una canalización de IA de Vértice basada en RAG.
Próximos pasos
No olvide que éste era sólo un ejemplo sencillo para demostrar la viabilidad de utilizar la recuperación de datos de búsqueda web de Bright Data en una canalización de IA de Vértice. En el mundo real, es probable que estos componentes formen parte de una canalización mucho más larga y compleja.
Los datos de entrada podrían proceder de diversas fuentes, como documentos empresariales, informes internos, bases de datos, archivos, etcétera. Además, el flujo de trabajo podría incluir muchos otros pasos y no terminaría necesariamente con un informe de comprobación de hechos.
Conclusión
En esta entrada de blog, ha aprendido a aprovechar la API SERP de Bright Data para recuperar el contexto de búsqueda web dentro de una canalización de IA de Vértice. El flujo de trabajo de IA presentado aquí es ideal para cualquiera que desee crear un canal de comprobación de hechos programático y fiable para garantizar que sus datos son precisos.
Para crear flujos de trabajo de IA avanzados similares, explore la gama completa de soluciones para recuperar, validar y transformar datos web en tiempo real utilizando la infraestructura de IA de Bright Data.
Cree una cuenta gratuita de Bright Data hoy mismo y empiece a experimentar con nuestras herramientas de datos web preparadas para IA.