Creación de conjuntos de datos vectoriales listos para la IA para LLM: Guía con Bright Data, Google Gemini y Pinecone

Los grandes modelos lingüísticos (LLM) están transformando la forma en que accedemos a la información y creamos aplicaciones inteligentes. Para aprovechar todo su potencial, especialmente con conocimientos específicos del dominio o datos propios, es fundamental crear conjuntos de datos vectoriales estructurados de alta calidad. El rendimiento y la precisión de un LLM están directamente relacionados con la calidad de sus datos de entrada. Los conjuntos de datos mal preparados pueden dar lugar a resultados mediocres, mientras que los bien seleccionados pueden convertir a un LLM en un verdadero experto del dominio.

En esta guía, explicaremos paso a paso cómo crear un proceso automatizado para generar conjuntos de datos vectoriales listos para la IA.

El reto: obtener y preparar datos para los LLM

Aunque los LLM se entrenan en grandes corpus de texto de uso general, a menudo se quedan cortos cuando se aplican a tareas o dominios específicos, como responder a consultas relacionadas con productos, analizar noticias del sector o interpretar los comentarios de los clientes. Para que sean realmente útiles, se necesitan datos de alta calidad adaptados a cada caso de uso.

Estos datos suelen estar repartidos por toda la web, ocultos tras complejas estructuras de sitios o protegidos por medidas anti-bot.

Nuestro flujo de trabajo automatizado lo resuelve con un proceso optimizado que se ocupa de las partes más difíciles de la creación de conjuntos de datos:

• Extracción de datos web. Utiliza Bright Data para extraer datos a escala, aprovechando su infraestructura centrada en la IA para sortear retos como los CAPTCHA y los bloqueos de IP.
• Estructuración de datos. Utiliza Google Gemini para analizar, limpiar y convertir contenido sin procesar en JSON bien estructurado.
• Incrustación semántica. Transforma el texto en incrustaciones vectoriales que captan el rico significado contextual.
• Almacenamiento y recuperación. Indexa vectores en Pinecone, una base de datos de búsqueda semántica rápida y escalable.
• Resultados listos para la IA. Produce conjuntos de datos de alta calidad listos para el ajuste fino, la GAR u otras aplicaciones de IA específicas del dominio.

Tecnologías básicas

Antes de construir la canalización, echemos un vistazo rápido a las principales tecnologías implicadas y cómo cada una de ellas apoya el flujo de trabajo.

Bright Data: Recopilación escalable de datos web

El primer paso para crear un conjunto de datos vectoriales listos para la IA es recopilar datos fuente relevantes y de alta calidad. Aunque algunos de ellos pueden proceder de sistemas internos, como bases de conocimientos o documentación, una gran parte suele proceder de la web pública.

Sin embargo, los sitios web modernos utilizan sofisticados mecanismos anti-bot, como CAPTCHAs, limitación de la tasa de IP y huellas dactilares del navegador, que dificultan el scraping a escala.

Bright Data resuelve este problema con su API Web Unlocker, que elimina la complejidad de la recopilación de datos. Se encarga automáticamente de la rotación de proxy, la resolución de CAPTCHA y la emulación del navegador, lo que le permite centrarse por completo en los datos en lugar de en cómo acceder a ellos.

Google Gemini: Transformación inteligente de contenidos

Gemini es una familia de potentes modelos de IA multimodal desarrollados por Google que destacan en la comprensión y el procesamiento de diversos tipos de contenido. En nuestro proceso de extracción de datos, Gemini desempeña tres funciones clave:

1. Análisis de contenidos: Procesa contenidos HTML sin procesar o, preferiblemente, Markdown depurado.
2. Extracción de información: Identifica y extrae puntos de datos específicos basándose en un esquema predefinido.
3. Estructuración de datos: Transforma la información extraída en un formato JSON limpio y estructurado.

Este enfoque basado en la IA ofrece grandes ventajas sobre los métodos tradicionales que se basan en selectores CSS frágiles o expresiones regulares frágiles, especialmente en casos de uso como:

• Páginas web dinámicas: páginas en las que el diseño o el DOM cambian con frecuencia (común en sitios de comercio electrónico, portales de noticias y otros dominios de alta velocidad).
• Contenido no estructurado: Extracción de datos estructurados de bloques de texto largos o mal organizados.
• Lógica de análisis compleja: Evita la necesidad de mantener y depurar reglas de raspado personalizadas para cada sitio o variación de contenido.

Si desea profundizar en cómo la IA está transformando el proceso de extracción de datos, explore Uso de la IA para el raspado web. Si está buscando un tutorial práctico que lo guíe a través de la implementación de Gemini en su flujo de trabajo de scraping, consulte nuestra guía completa: Web Scraping con Gemini.

Transformadores de frases: Generación de incrustaciones semánticas

Las incrustaciones son representaciones vectoriales densas de texto (u otros tipos de datos) en un espacio de alta dimensión. Estos vectores captan el significado semántico y permiten representar fragmentos de texto similares mediante vectores cercanos entre sí, medidos con métricas como la similitud coseno o la distancia euclídea. Esta propiedad es importante para aplicaciones como la búsqueda semántica, la agrupación y la generación aumentada de recuperación (RAG), en las que encontrar contenido relevante depende de la proximidad semántica.

La biblioteca Sentence Transformers proporciona una interfaz fácil de usar para generar incrustaciones de frases y párrafos de alta calidad. Construida sobre Hugging Face Transformers, admite una amplia gama de modelos preentrenados y ajustados para tareas semánticas.

Uno de los modelos más populares y eficaces de este ecosistema es all-MiniLM-L6-v2. He aquí por qué destaca:

• Arquitectura: Basada en la arquitectura MiniLM, optimizada para aumentar la velocidad y el tamaño, manteniendo un gran rendimiento.
• Dimensión de incrustación: Mapea las entradas a un espacio vectorial de 384 dimensiones, lo que la hace eficiente y compacta.
• Objetivo de formación: Puesta a punto en más de 1.000 millones de pares de frases utilizando un enfoque de aprendizaje contrastivo para mejorar la comprensión semántica.
• Rendimiento: Ofrece resultados punteros o casi punteros en tareas como la similitud de frases, la agrupación semántica y la recuperación de información.
• Longitud de la entrada: admite hasta 256 trozos de palabras (tokens), truncando automáticamente el texto más largo, algo importante a la hora de fragmentar el texto.

Aunque los modelos más grandes pueden ofrecer incrustaciones ligeramente más matizadas, all-MiniLM-L6-v2 proporciona un equilibrio excepcional entre rendimiento, eficiencia y coste. Sus vectores de 384 dimensiones son:

• Mayor rapidez de cálculo.
• Requiere menos recursos.
• Más fácil de almacenar e indexar.

Para la mayoría de los casos prácticos, especialmente en las primeras fases de desarrollo o en entornos con recursos limitados, este modelo es más que suficiente. La reducción marginal de la precisión en los casos extremos suele verse compensada por las importantes ganancias en velocidad y escalabilidad. Por tanto, se recomienda utilizar all-MiniLM-L6-v2 al crear la primera iteración de su aplicación de IA o al optimizar el rendimiento en infraestructuras modestas.

Pinecone: Almacenamiento y búsqueda de incrustaciones vectoriales

Una vez que el texto se transforma en incrustaciones vectoriales, se necesita una base de datos especializada para almacenarlos, gestionarlos y consultarlos de forma eficiente.Las bases de datos tradicionales no están diseñadas para esto:las bases de datos vectoriales se han creado específicamente para manejar la naturaleza altamente dimensional de los datos incrustados, lo que permite la búsqueda de similitudes en tiempo real, esencial para las canalizaciones RAG, la búsqueda semántica, la personalización y otras aplicaciones impulsadas por la IA.

Pinecone es una popular base de datos vectorial conocida por su interfaz fácil de usar para desarrolladores, su rendimiento de búsqueda de baja latencia y su infraestructura totalmente gestionada. Gestiona eficazmente las complejidades de la indexación vectorial y la búsqueda a escala, abstrayendo las complejidades de la infraestructura de búsqueda vectorial. Sus componentes clave son:

• Índices: Contenedores de almacenamiento para tus vectores.
• Vectores: Las incrustaciones reales con los metadatos asociados.
• Colecciones: Instantáneas estáticas de índices para copias de seguridad y versionado.
• Espacios de nombres: Partición de datos dentro de un índice para multi-tenancy.

Pinecone ofrece dos arquitecturas de despliegue: Serverless y Pod-Based. Para la mayoría de los casos de uso, especialmente cuando se empieza o se trata de cargas dinámicas, Serverless es la opción recomendada debido a su simplicidad y rentabilidad.

Configuración y requisitos previos

Antes de construir la canalización, asegúrese de que los siguientes componentes están correctamente configurados.

Requisitos previos

• Python 3.9 o posterior debe estar instalado en su sistema
• Reúna las siguientes credenciales API

  :Marcador de posición Polylang no modificar

Consulte las secciones de configuración específicas de cada herramienta para obtener instrucciones sobre la generación de cada clave API.

Instalar las bibliotecas necesarias

Instala las librerías de Python para este proyecto:

pip install requests python-dotenv google-generativeai sentence-transformers pinecone

Estas bibliotecas proporcionan:

• requests: Un popular cliente HTTP para interactuar con APIs(guía de requests)
• python-dotenv: Carga segura de claves API desde variables de entorno
• google-generativeai: SDK Gemini oficial de Google (también compatible con JavaScript, Go y otros lenguajes).
• transformadores de frases: Modelos preformados para generar incrustaciones de vectores semánticos
• pinecone: SDK para la base de datos vectorial de Pinecone(SDKs de lenguaje disponibles para Python, Node.js, Go y más).

Configurar variables de entorno

Crea un archivo .env en el directorio raíz de tu proyecto y añade tus claves API:

BRIGHT_DATA_API_KEY="your_bright_data_api_key_here"
GEMINI_API_KEY="your_gemini_api_key_here"
PINECONE_API_KEY="your_pinecone_api_key_here"

Configuración de Bright Data

Para utilizar el Desbloqueador Web de Bright Data:

1. Crear un token de API
2. Configureuna zona de desbloqueo web desde su panel de Bright Data

Para ver ejemplos de implementación y código de integración, explore el repositorio GitHub de Web Unlocker.

Si todavía está comparando soluciones, esta comparativa de herramientas de raspado de IA le ofrece información sobre cómo Bright Data se compara con otras plataformas.

Configuración Gemini

Para generar una clave API Gemini:

1. Ir a Google AI Studio
2. Haga clic en “+ Crear clave API”.
3. Copia la clave y guárdala en un lugar seguro

Consejo: El nivel gratuito es suficiente para desarrollo y pruebas a pequeña escala. Para uso en producción, donde puede necesitar un mayor rendimiento (RPM/RPD), ventanas de token más grandes (TPM) o privacidad de nivel empresarial y acceso a modelos avanzados, consulte los límites de tarifa y los planes de precios.

Instalación de piñas

1. Regístrate en Pinecone.io
2. Copie su clave API desde el panel de control
3. Para crear un nuevo

   marcador de posición

   index

   :Polylang no modifique

Verá el índice con un estado verde e inicialmente con cero registros una vez finalizada la configuración.

Construir la canalización: Aplicación paso a paso

Ahora que nuestros requisitos previos están configurados, vamos a construir nuestra canalización de datos utilizando las reseñas de productos MacBook Air M1 de Walmart como ejemplo práctico.

Paso 1: Adquisición de datos con Bright Data Web Unlocker

La base de nuestro pipeline consiste en obtener contenido HTML sin procesar de las URL de destino. El Web Unlocker de Bright Data se destaca por eludir las sofisticadas medidas anti-scraping empleadas habitualmente por sitios de comercio electrónico como Walmart.

Empecemos con esta implementación para obtener el contenido de una página web:

import requests
import os
from dotenv import load_dotenv

# Load API key from environment
load_dotenv()
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

def fetch_page(url: str) -> str:
    """Fetch page content using Bright Data Web Unlocker (Markdown format)"""
    try:
        response = requests.post(
            "https://api.brightdata.com/request",
            headers={
                "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
                "Content-Type": "application/json",
            },
            json={
                "zone": "web_unlocker2",
                "url": url,
                "format": "raw",
                "data_format": "markdown",  # Direct HTML-to-Markdown conversion
            },
            timeout=60,
        )

        if response.status_code == 200 and len(response.text) > 1000:
            return response.text

    except Exception as e:
        print(f"Request failed: {str(e)}")

    return None

# Example usage
walmart_url = "https://www.walmart.com/reviews/product/609040889?page=1"
page_content = fetch_page(walmart_url)

if page_content:
    print(f"Success! Retrieved {len(page_content)} characters")
else:
    print("Failed to fetch page")

¿Por qué utilizar Markdown en lugar de HTML sin formato? En nuestro sistema, solicitamos contenidos en formato Markdown(data_format: 'markdown') por varias razones importantes. Markdown elimina las etiquetas HTML, los estilos y otros elementos molestos, reduciendo la complejidad y dejando sólo el contenido esencial. El resultado es un número de tokens significativamente menor, lo que hace que el procesamiento LLM sea más eficiente. También conserva la estructura semántica en un formato más limpio y legible, lo que mejora tanto la claridad como la velocidad de procesamiento. Operaciones como la generación de incrustaciones y la indexación de vectores se vuelven más rápidas y ligeras.

Para saber por qué los agentes de IA modernos prefieren Markdown, lea Por qué los nuevos agentes de IA prefieren Markdown a HTML.

Paso 2: Gestión de la paginación

Walmart distribuye las reseñas de productos en numerosas páginas. Para capturar conjuntos de datos completos, implemente el manejo de la paginación. Es necesario:

1. Construya la URL de página correcta (?page=1, ?page=2, etc.)
2. Obtener el contenido de cada página
3. Detectar si hay “página siguiente” o no
4. Continúe hasta que no haya más páginas disponibles

He aquí un sencillo bucle de paginación que obtiene contenido hasta que no se encuentra ninguna referencia page=n+1:

current_page = 1

while True:
    url = f"https://www.walmart.com/reviews/product/609040889?page={current_page}"
    page_content = fetch_page(url)

    if not page_content:
        print(f"Stopping at page {current_page}: fetch failed or no content.")
        break

    # Do something with the fetched content here
    print(f"Fetched page {current_page}")

    # Check for presence of next page reference
    if f"page={current_page + 1}" not in page_content:
        print("No next page found. Ending pagination.")
        break

    current_page += 1

Paso 3: Extracción de datos estructurados con Google Gemini

Con el contenido Markdown limpio del paso anterior, ahora utilizaremos Google Gemini para extraer información específica de las reseñas y estructurarla como JSON. Esto transforma el texto no estructurado en datos organizados que nuestra base de datos vectorial puede indexar de forma eficiente.

Utilizaremos el modelo gemini-2.0-flash, que ofrece unas especificaciones impresionantes para nuestro caso de uso:

• Contexto de entrada: 1.048.576 fichas
• Límite de salida: 8.192 fichas
• Soporte multimodal: Texto, código, imágenes, audio y vídeo

En nuestro caso, el texto markdown de la página de reseñas de Walmart suele contener unos 3.000 tokens, muy por debajo del límite del modelo. Esto significa que podemos enviar toda la página de una vez sin dividirla en trozos más pequeños.

Si tus documentos superan la ventana contextual, tendrás que aplicar estrategias de fragmentación. Pero para las páginas web típicas, la capacidad de Gemini hace que esto sea innecesario.

A continuación se muestra una función Python de ejemplo que utiliza Gemini para extraer reseñas en un formato JSON estructurado:

import google.generativeai as genai
import json

# Initialize Gemini with JSON output configuration
model = genai.GenerativeModel(
    model_name="gemini-2.0-flash",
    generation_config={"response_mime_type": "application/json"},
)

def extract_reviews(markdown: str) -> list[dict]:
    """Extract structured review data from Markdown using Gemini."""
    prompt = f"""
    Extract all customer reviews from this Walmart product page content.
    Return a JSON array of review objects with the following structure:

    {{
      "reviews": [
        {{
          "date": "YYYY-MM-DD or original date format if available",
          "title": "Review title/headline",
          "description": "Review text content",
          "rating": <integer from 1–5>
        }}
      ]
    }}

    Rules:
    - Include all reviews found on the page
    - Use null for any missing fields
    - Convert ratings to integers (1–5)
    - Extract the full review text, not just snippets
    - Preserve original review text without summarizing

    Here's the page content:
    {markdown}
    """

    response = model.generate_content(prompt)
    result = json.loads(response.text)

    # Normalize and clean results
    return [
        {
            "date": review.get("date"),
            "title": review.get("title"),
            "description": review.get("description", "").strip(),
            "rating": review.get("rating"),
        }
        for review in result.get("reviews", [])
    ]

Una ingeniería rápida es clave cuando se trabaja con LLMs. En nuestra implementación, establecemos response_mime_type: "application/json" para garantizar que Gemini devuelva un JSON válido, eliminando la necesidad de un complejo análisis sintáctico del texto. El prompt en sí está cuidadosamente diseñado para reducir las alucinaciones, indicando a Gemini que confíe únicamente en el contenido proporcionado. También aplica un esquema JSON estricto para garantizar la coherencia estructural, conserva el texto completo de la reseña sin resumirlo y gestiona los campos que faltan de forma elegante.

Después de procesar una página de revisión de Walmart, recibirá datos estructurados como estos:

[
  {
    "date": "Apr 13, 2025",
    "title": "Better than buying OPEN BOX",
    "description": "I bought an older product OPEN BOX (which I consider UNUSED) from another website. The battery was dead. Walmart offered NEW at a lower price. WOW!!!!",
    "rating": 5
  },
  {
    "date": "Dec 8, 2024",
    "title": "No support",
    "description": "The young man who delivered my laptop gave me the laptop with no receipt or directions. I asked where my receipt and some kind of manual were. He said it would be under my purchases. I would happily change this review if I knew where to go for help and support. The next day I went to the electronics department for help, and he had no idea.",
    "rating": 3
  }
  // ... more reviews
]

Para ver un ejemplo que combina todos los pasos (búsqueda, procesamiento y extracción), consulta la implementación completa en GitHub.

Paso 4: Generación de incrustaciones vectoriales con transformadores de frases

Con datos de reseñas limpios y estructurados en formato JSON, ahora generamos incrustaciones de vectores semánticos para cada reseña. Estas incrustaciones se utilizarán para tareas posteriores como la búsqueda semántica o la indexación en una base de datos vectorial como Pinecone.

Para captar el contexto completo de la opinión de un cliente, combinamos el título y la descripción de la opinión en una sola cadena antes de incrustarla. Esto ayuda al modelo a codificar mejor tanto el sentimiento como el tema.

Este es el código de ejemplo:

from sentence_transformers import SentenceTransformer

# Load the embedding model
model = SentenceTransformer("all-MiniLM-L6-v2")

def generate_embeddings(reviews):
    """Generate 384-dimensional vector embeddings from review titles and descriptions."""
    texts = []
    valid_indices = []

    # Combine title and description into a single string for embedding
    for idx, review in enumerate(reviews):
        text_parts = []
        if review.get("title"):
            text_parts.append(f"Review Title: {review['title']}")
        if review.get("description"):
            text_parts.append(f"Review Description: {review['description']}")

        if text_parts:
            texts.append(". ".join(text_parts))
            valid_indices.append(idx)

    # Generate embeddings using batch processing
    embeddings = model.encode(
        texts, show_progress_bar=True, batch_size=32, convert_to_numpy=True
    ).tolist()

    # Attach embeddings back to original review objects
    for emb_idx, review_idx in enumerate(valid_indices):
        reviews[review_idx]["embedding"] = embeddings[emb_idx]

    return reviews

Qué hace este código:

1. Inicialización del modelo: Carga el modelo all-MiniLM-L6-v2, que devuelve incrustaciones densas de 384 dimensiones.
2. Preparación de la entrada: Combina el título y la descripción de cada reseña en una sola cadena.
3. Codificación por lotes: Utiliza model.encode() con procesamiento por lotes para un procesamiento eficiente

   :Marcador de posición de Polylang no modificar

4. Inyección de incrustación: Adjunta cada vector de nuevo al objeto de revisión correspondiente bajo la clave "incrustación".

Nota importante: Pinecone no admite valores nulos en los metadatos. Si falta algún campo, debe omitir la clave por completo al cargarlo en Pinecone. No utilice "N/A" o cadenas vacías a menos que tengan un significado específico en su lógica de filtrado.

Aunque la función de limpieza no se muestra aquí (para mantener el código legible), la implementación final incluirá la limpieza de metadatos antes de la ingestión.

Tras la generación de la incrustación, cada objeto de revisión incluye un vector de 384 dimensiones:

{
  "date": "Apr 9, 2024",
  "title": "Amazing Laptop!",
  "description": "This M1 MacBook Air is incredibly fast and the battery lasts forever.",
  "rating": 5,
  "embedding": [0.0123, -0.0456, 0.0789, ..., 0.0345]  // 384 dimensions
}

Con las incrustaciones generadas, nuestras reseñas están listas para el almacenamiento vectorial en Pinecone.

Paso 5: Almacenamiento de incrustaciones y metadatos en Pinecone

El último paso de nuestro proceso consiste en cargar las reseñas incrustadas en Pinecone.

Aquí está el código Python para upsert datos a Pinecone:

import uuid
from pinecone import Pinecone, Index

# Initialize Pinecone client with your API key
pc = Pinecone(api_key="PINECONE_API_KEY")
index = pc.Index("brightdata-ai-dataset")  # Replace with your actual index name

# Sample review data (with embeddings already attached)
reviews_with_embeddings = [
    {
        "date": "Apr 9, 2024",
        "title": "Amazing Laptop!",
        "description": "This M1 MacBook Air is incredibly fast and the battery lasts forever.",
        "rating": 5,
        "embedding": [0.0123, -0.0456, ..., 0.0789],  # 384-dimensional vector
    }
    # ... more reviews
]

# Prepare vector records for upload
vectors = []
for review in reviews_with_embeddings:
    if "embedding" not in review:
        continue  # Skip entries without embeddings

    vectors.append(
        {
            "id": str(uuid.uuid4()),  # Unique vector ID
            "values": review["embedding"],
            "metadata": {
                "title": review.get("title"),
                "description": review.get("description"),
                "rating": review.get("rating"),
                # Add more metadata fields if needed
            },
        }
    )

# Batch upload to Pinecone (100 vectors per request)
for i in range(0, len(vectors), 100):
    batch = vectors[i : i + 100]
    index.upsert(vectors=batch)

Cada vector que insertes en Pinecone debe incluir:

• id: Un identificador de cadena único (obligatorio)
• valores: El propio vector (lista de flotantes, por ejemplo, 384 dimensiones).
• metadatos: Pares clave-valor opcionales para filtrado y contexto (compatible con JSON)

Ejemplo de estructura vectorial:

Una vez finalizada la carga, su índice Pinecone se completará con vectores de revisión:

Tu conjunto de datos vectoriales listos para IA ya está almacenado en Pinecone y está listo para los siguientes pasos 🔥

Para ver un ejemplo práctico que combina todos los pasos (generación de incrustaciones, carga de Pinecone), consulta la implementación completa en GitHub.

(Opcional pero recomendado) Utilización del conjunto de datos AI-Ready

Ahora que tus incrustaciones están indexadas en Pinecone, puedes potenciar aplicaciones como la búsqueda semántica y los sistemas RAG. Este paso muestra cómo consultar tu base de datos vectorial y generar respuestas inteligentes.

Búsqueda semántica

La forma más sencilla de aprovechar su conjunto de datos vectorizados es mediante la búsqueda semántica. A diferencia de la búsqueda por palabras clave, la búsqueda semántica permite a los usuarios realizar consultas en lenguaje natural y recuperar contenidos conceptualmente similares, aunque no compartan las mismas palabras.

Vamos a probar el sistema con consultas en lenguaje natural:

queries = [
    "good price for students",
    "lightweight and good for travel",
]

Para la consulta “buen precio para estudiantes”, podría ver:

#1 (Score: 0.6201)
ID: 75878bdc-8d96-416a-8292-484971c3bd61
Date: Aug 3, 2024
Rating: 5.0
Description: Just what my daughter needed for college and the price was perfect

#2 (Score: 0.5868)
ID: 758963ae-0927-4e82-bece-d098991f5a73
Date: Jun 13, 2024
Rating: 5.0
Description: The price was right. Perfect graduation present for my grandson

🙌 ¡Funciona de maravilla! Las consultas en lenguaje natural devuelven resultados muy relevantes.

Así funciona la búsqueda semántica:

1. Incrustación de consultas: La consulta de búsqueda se convierte en un vector utilizando el mismo modelo all-MiniLM-L6-v2 utilizado para la indexación.
2. Búsqueda de vectores: Pinecone encuentra los vectores más similares utilizando la similitud coseno.
3. Recuperación de metadatos: Los resultados incluyen tanto las puntuaciones de similitud como los metadatos asociados.

Para la implementación completa de trabajo, echa un vistazo a: Cliente de búsqueda semántica en Python.

Más allá de la búsqueda: Generación Aumentada de Recuperación (RAG)

Una vez que tengas la búsqueda semántica funcionando, estás a un paso de construir un sistema RAG potenciado por LLM. La Generación de Recuperación Aumentada (RAG) permite a tu LLM generar respuestas fundamentadas utilizando un contexto externo, como tu conjunto de datos vectorizado.

Flujo RAG:

1. El usuario formula una pregunta (por ejemplo, “¿Es bueno este MacBook para estudiantes universitarios?”).
2. La búsqueda semántica recupera documentos relevantes de Pinecone.
3. El contexto recuperado + la pregunta se envían a un LLM como Google Gemini.
4. LLM responde con los hechos de su conjunto de datos.

Ejemplos de respuestas RAG:

🤔 User: Is the battery life good for college use?
🤖 Assistant: Yes, users report long battery life—enough to last through full days of classes and study.

🤔 User: How does this compare to a Chromebook?
🤖 Assistant: One review says the MacBook Air "works so smoothly compared to a Chromebook".

Vea el código completo utilizado para RAG y la búsqueda semántica: RAG Chatbot Implementation.

Próximos pasos

Ha creado con éxito un proceso completo para crear conjuntos de datos vectoriales listos para la IA. A continuación te explicamos cómo ampliar y optimizar tu implementación:

1. Adquisición de datos a escala: Para necesidades de datos más amplias, explore la Infraestructura de datos web preparada para IA completa de Bright Data para un acceso a datos web ilimitado y compatible optimizado para modelos y agentes de IA.
2. Experimente con la incrustación de modelos: Aunque all-MiniLM-L6-v2 es eficiente, puedes obtener mejores resultados para ciertos casos de uso cambiando a modelos más grandes o multilingües. También puedes probar a incrustar API de Google Gemini y OpenAI.
3. Afine las instrucciones de extracción: Adapte la solicitud de Gemini a las diferentes estructuras de sitios web o esquemas de datos que necesite extraer.
4. Aproveche las funciones avanzadas de Pinecone: Explore el filtrado, los espacios de nombres, la indexación de metadatos y la búsqueda híbrida sumergiéndose en la documentación oficial de Pinecone.
5. Automatice la canalización: Integre esta canalización en un flujo de trabajo de producción utilizando herramientas como Apache Airflow o Prefect para la orquestación, AWS Step Functions o Google Cloud Workflows para la programación nativa en la nube.
6. Cree una aplicación potenciada por IA: Utilice los componentes de búsqueda semántica o RAG para crear herramientas del mundo real como chatbots de atención al cliente, búsqueda en bases de conocimiento y motores de recomendación.

Conclusión

Ha creado con éxito una canalización completa y robusta que crea y gestiona conjuntos de datos vectoriales listos para la IA, transformando datos web sin procesar en activos valiosos para grandes modelos lingüísticos. Mediante la combinación de Bright Data para el scraping web escalable, Google Gemini para la extracción estructurada inteligente, Sentence Transformers para generar incrustaciones semánticas y Pinecone para el almacenamiento y la recuperación de vectores, ha preparado eficazmente sus datos personalizados para mejorar las aplicaciones LLM.

Este enfoque fundamenta los LLM en el conocimiento de dominios específicos, lo que proporciona soluciones basadas en IA más precisas, relevantes y valiosas.