Bases de datos vectoriales: El motor de la IA moderna

Las bases de datos vectoriales pueden almacenar e indexar incrustaciones de datos de alta dimensión generadas por modelos de aprendizaje automático. Son la piedra angular de la IA moderna, ya que permiten almacenar información contextual y realizar búsquedas semánticas significativas.

Aunque a menudo se asocian con la generación aumentada de recuperación (RAG), sus aplicaciones van mucho más allá. En concreto, potencian la búsqueda semántica, los sistemas de recomendación, la detección de anomalías y muchas más aplicaciones.

Siga esta guía para entender qué son las bases de datos vectoriales, cómo funcionan, cómo utilizarlas en un ejemplo completo y qué les depara el futuro.

¿Qué son las bases de datos vectoriales?

Las bases de datos vectoriales son sistemas de almacenamiento diseñados para contener datos vectoriales. En este contexto, un vector se refiere a una incrustación numérica que representa datos no estructurados como texto, imágenes o audio, generalmente producidos por un modelo de aprendizaje automático.

A diferencia de las bases de datos tradicionales, las bases de datos vectoriales almacenan datos de alta dimensión como vectores numéricos densos y los indexan en un espacio de N dimensiones, lo que permite optimizar las búsquedas basadas en similitudes.

La creciente importancia de las bases de datos vectoriales en IA/ML

En la mayoría de los casos, las bases de datos SQL tradicionales no son adecuadas para las tareas de IA y aprendizaje automático. La razón es que almacenan datos estructurados y sólo admiten consultas de coincidencia exacta o búsquedas de similitud limitadas. Por lo tanto, tienen dificultades para manejar contenidos no estructurados y capturar las relaciones semánticas entre puntos de datos.

Ahora, las aplicaciones de IA requieren una comprensión contextual de los datos. Esto puede lograrse con incrustaciones, que las bases de datos relacionales no están optimizadas para almacenar o consultar. Las bases de datos vectoriales abordan estas limitaciones mediante búsquedas basadas en similitudes que reflejan el significado y el contexto, abriendo la puerta a la comprensión semántica de los datos.

Aunque el escenario más común para esta tecnología es la generación aumentada por recuperación (RAG), hay otros casos de uso posibles:

• Buscadores semánticos
• Sistemas de recomendación
• Detección de anomalías en series temporales de datos
• Clasificación y búsqueda de imágenes en visión por ordenador
• Aplicaciones de procesamiento del lenguaje natural (PLN)

Cómo funcionan las bases de datos vectoriales

Las bases de datos vectoriales gestionan los datos como incrustaciones vectoriales, que existen en un espacio de alta dimensión. Cada dimensión representa un rasgo de los datos, que corresponde a una característica específica de los datos originales (representados como una incrustación) tal y como los interpreta el modelo ML. Cuanto mayor es la dimensionalidad de la incrustación, más detallada es la representación, lo que permite una comprensión más rica de la estructura de los datos.

Para encontrar datos semánticamente similares, las bases de datos vectoriales utilizan métricas de similitud como:

• Coseno de similitud: Mide el coseno del ángulo entre dos vectores para evaluar la similitud de su dirección. Se suele utilizar para datos de texto.
• Distancia euclidiana: Mide la distancia en línea recta entre dos vectores, útil para datos espaciales en los que importan tanto la dirección como la magnitud.
• Producto punto desimilitud: Calcula el producto de los componentes vectoriales correspondientes; un producto punto más alto indica una mayor similitud. Resulta útil en sistemas de recomendación y tareas de clasificación.

Al igual que las bases de datos SQL y NoSQL utilizan índices para acelerar la consulta de datos, las bases de datos vectoriales pueden utilizar técnicas de indexación avanzadas como:

• Vecino más próximo aproximado (RNA): Hace más rápidas las búsquedas de similitud aproximando los vectores más cercanos, reduciendo el coste computacional en comparación con las búsquedas exactas.
• Pequeño mundo navegable jerárquico (HNSW): Representa vectores en una estructura de grafos para agilizar la navegación en espacios grandes y de gran dimensión.

Además, pueden aplicarse técnicas de partición y agrupación para organizar los datos vectoriales en grupos más pequeños y manejables. Estos métodos mejoran tanto la eficiencia del almacenamiento como el rendimiento de la búsqueda.

Opciones populares de bases de datos vectoriales

Ahora que ya sabe qué son las bases de datos vectoriales y cómo funciona su infraestructura de datos de IA, está preparado para explorar las opciones de bases de datos vectoriales más populares. Analizaremos cada una de ellas en función de los siguientes aspectos:

• Arquitectura
• Características de rendimiento
• Capacidad de integración
• Modelo de precios
• Mejores casos de uso

Si desea saber qué bases de datos vectoriales destacan, eche un vistazo a la tabla resumen que figura a continuación:

Es hora de profundizar en las opciones de la base de datos vectorial seleccionada.

Piña

• Arquitectura: Totalmente gestionada, sin servidor
• Características de rendimiento

  :El marcador de posición Polylang no se modifica

• Capacidades de integración

  :Marcador de posición Polylang no modificar

• Modelo de precios

  :Marcador de posición Polylang no modificar

• Mejores casos de uso

  :Marcador de posición Polylang no modificar

Weaviate

• Arquitectura: Modular, nativa en la nube
• Características de rendimiento

  :El marcador de posición Polylang no se modifica

• Capacidades de integración

  :Marcador de posición Polylang no modificar

• Modelo de precios

  :Marcador de posición Polylang no modificar

• Mejores casos de uso

  :Marcador de posición Polylang no modificar

Milvus

• Arquitectura: Arquitectura de almacenamiento compartido con desagregación de almacenamiento y computación para una escalabilidad horizontal.
• Características de rendimiento

  :El marcador de posición Polylang no se modifica

• Capacidades de integración

  :Marcador de posición Polylang no modificar

• Modelo de precios

  :Marcador de posición Polylang no modificar

• Mejores casos de uso

  :Marcador de posición Polylang no modificar

Croma

• Arquitectura: Servidor de un solo nodo para aplicaciones pequeñas o distribuido en la nube para aplicaciones más grandes.
• Características de rendimiento

  :El marcador de posición Polylang no se modifica

• Capacidades de integración

  :Marcador de posición Polylang no modificar

• Modelo de precios

  :Marcador de posición Polylang no modificar

• Mejores casos de uso

  :Marcador de posición Polylang no modificar

Qdrant

• Arquitectura: Autoalojamiento local o despliegue distribuido en la nube para aplicaciones de mayor tamaño y multitenencia.
• Características de rendimiento

  :El marcador de posición Polylang no se modifica

• Capacidades de integración

  :Marcador de posición Polylang no modificar

• Modelo de precios

  :Marcador de posición Polylang no modificar

• Mejores casos de uso

  :Marcador de posición Polylang no modificar

Alimentar las bases de datos vectoriales con Bright Data

Los dos aspectos clave que influyen en la calidad de las incrustaciones vectoriales son:

1. El modelo de aprendizaje automático utilizado para generar las incrustaciones.
2. La calidad de los datos de entrada introducidos en ese modelo.

Esto demuestra que la potencia de una base de datos vectorial depende de los datos que la alimentan. Si las incrustaciones se producen a partir de datos de baja calidad, incompletos o ruidosos, incluso los mejores modelos de ML y bases de datos vectoriales ofrecerán resultados pobres.

Ahora entiende por qué es tan importante recopilar datos limpios, ricos y completos, y aquí es donde Bright Data entra en juego.

Bright Data es una plataforma líder en raspado web y recopilación de datos que permite recopilar datos web de alta calidad de forma ética y eficiente a escala. Sus soluciones de recopilación de datos pueden extraer datos estructurados en tiempo real de cientos de dominios. Además, estas soluciones pueden integrarse directamente en sus propios flujos de trabajo para mejorar el rendimiento de sus scripts de scraping personalizados.

La principal ventaja de este enfoque de la obtención de datos es que Bright Data se encarga de todo. Gestiona la infraestructura, se encarga de la rotación de IP, elude las protecciones anti-bot, analiza los datos HTML y garantiza una cobertura total del cumplimiento.

Estas herramientas de web scraping permiten acceder a datos frescos y estructurados directamente desde las páginas web. Teniendo en cuenta que la web es la mayor fuente de datos, aprovecharla es ideal para generar incrustaciones vectoriales ricas en contexto. Estas incrustaciones pueden alimentar una amplia gama de aplicaciones de IA y búsqueda, como:

• Información sobre productos para recomendaciones de comercio electrónico
• Artículos de noticias para la búsqueda semántica y contextual
• Contenido de las redes sociales para la detección y el análisis de tendencias
• Listados de empresas para experiencias basadas en la ubicación

De datos brutos a incrustaciones vectoriales: El proceso de transformación

El proceso de transformación de datos brutos en incrustaciones vectoriales requiere dos pasos:

1. Preprocesamiento de datos
2. Generación de incrustaciones

Vamos a desglosarlas para entender mejor cómo funciona cada paso y qué implica.

Etapa 1. Preprocesamiento de datos

Los datos brutos suelen ser ruidosos, redundantes o desestructurados. El primer paso para transformar los datos brutos en incrustaciones es limpiarlos y normalizarlos. Este proceso aumenta la calidad y la coherencia de los datos de entrada antes de introducirlos en un modelo de aprendizaje automático para generar incrustaciones.

Por ejemplo, cuando se trata de utilizar datos web en el aprendizaje automático, los pasos comunes de preprocesamiento incluyen:

• Análisis de HTML sin procesar para extraer contenido estructurado.
• Recorte de espacios en blanco y normalización de formatos de datos (por ejemplo, precios, fechas y símbolos monetarios).
• Normalizar el texto convirtiéndolo a minúsculas, eliminando los signos de puntuación y tratando los caracteres HTML especiales.
• Deduplicar contenidos para evitar información redundante.

Segundo paso Generación de incrustaciones

Una vez limpios y preprocesados los datos, pueden pasarse por un modelo de incrustación ML. Éste los transformará en un vector numérico denso.

La elección del modelo de incrustación depende del tipo de datos de entrada y de la calidad de salida deseada. A continuación se presentan algunos métodos populares:

• Modelos de incrustación de OpenAI: Generan vectores de uso general de alta calidad con una excelente comprensión semántica.
• Transformadores de frases: Un marco de trabajo en Python de código abierto para la incrustación de frases, texto e imágenes de última generación. Se ejecuta localmente y admite muchos modelos preentrenados.
• Modelos de incrustación específicos de cada dominio: Perfeccionados en conjuntos de datos nicho como informes financieros, documentos jurídicos o textos biomédicos para lograr un alto rendimiento en escenarios específicos.

Por ejemplo, así es como se pueden utilizar los modelos de incrustación de OpenAI para generar una incrustación

# requirement: pip install openai

from openai import OpenAI

client = OpenAI() # Reading the OpenAI key from the "OPENAI_API_KEY" env

# Sample input data (replace it with your input data)
input_data = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
"""

# Use an OpenAI embedding model for embedding generation
response = client.embeddings.create(
    model="text-embedding-3-large",
    input=input_data
)

# Get the embedding and print it
embedding = response.data[0].embedding
print(embedding)

La salida será un vector de 3072 dimensiones como:

[
  -0.005813355557620525,  
  # other 3070 elements..., 
  -0.006388738751411438
]

Del mismo modo, puede producir incrustaciones con transformadores de frases:

# requirement: pip install sentence_transformers

from sentence_transformers import SentenceTransformer

# Sample input data (replace it with your input data)
input_data = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
"""
# Load a pretrained Sentence Transformer model
model = SentenceTransformer("all-MiniLM-L6-v2")

# Embedding generation
embedding = model.encode(input_data)
# Print the resulting embedding
print(embedding)

Esta vez, la salida será un vector más corto de 384 dimensiones:

[
  -0.034803513, 
  # other 381 elements..., 
  -0.046595078
]

Hay que tener en cuenta que existe un equilibrio entre la calidad de la incrustación y la eficiencia computacional. Los modelos de gran tamaño, como los que ofrece OpenAI, producen incrustaciones ricas y de gran precisión, pero pueden llevar algún tiempo e incluso requerir llamadas de red a modelos de IA de primera calidad. Por otro lado, los modelos locales como los de SentenceTransformers son gratuitos y mucho más rápidos, pero pueden sacrificar matices semánticos.

La elección de la estrategia de incrustación adecuada depende de sus requisitos de rendimiento y del nivel de precisión semántica que desee alcanzar.

Integración práctica: Guía paso a paso

Siga los pasos que se indican a continuación y aprenda a pasar de los datos brutos de una página web a una búsqueda semántica eficaz con un script de Python.

Esta sección tutorial le guiará a través del proceso de:

1. Uso de la API Web Scraper de Bright Data para recuperar artículos de noticias de la BBC.
2. Preprocesamiento de los datos raspados y preparación para la generación de incrustaciones.
3. Generación de incrustaciones de texto mediante SentenceTransformers.
4. Preparando a Milvus.
5. Rellenar la base de datos vectorial con el texto procesado y las incrustaciones.
6. Realización de búsquedas para recuperar artículos de noticias semánticamente relevantes a partir de una consulta de búsqueda.

Sumerjámonos.

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente:

• Python 3+ instalado localmente
• Docker instalado localmente
• Una cuenta de Bright Data

Si aún no lo ha hecho, instale Python y Docker en su máquina, y cree una cuenta gratuita de Bright Data.

Paso 1: Recopilación de datos mediante la API Web Scraper de Bright Data

El raspado de artículos de noticias no siempre es sencillo, ya que muchos portales de noticias protegen sus páginas con medidas anti-scraping y anti-bot. Para eludir esas protecciones de forma fiable y recuperar datos frescos de la BBC, utilizaremos la API Web Scraper de Bright Data.

Esta API expone puntos finales específicos para recopilar datos estructurados de más de 120 sitios web populares, incluida la BBC. Así es como funciona el proceso de scraping:

1. Realice una solicitud POST al punto final adecuado para activar una tarea de scraping para las URL especificadas en un dominio determinado.
2. Bright Data realiza la tarea de scraping en la nube.
3. Usted sondea periódicamente otro punto final hasta que los datos raspados estén listos (en JSON, CSV u otros formatos).

Antes de saltar al código Python, asegúrate de instalar la biblioteca Requests:

pip install requests

A continuación, consulte la documentación de Bright Data para familiarizarse con Web Scraper API. Además, recupere su clave API.

Ahora, utiliza el siguiente código para recuperar datos de BBC news:

import requests
import json
import time


def trigger_bbc_news_articles_scraping(api_key, urls):
    # Endpoint to trigger the Web Scraper API task
    url = "https://api.brightdata.com/datasets/v3/trigger"

    params = {
      "dataset_id": "gd_ly5lkfzd1h8c85feyh", # ID of the BBC web scraper
      "include_errors": "true",
    }

    # Convert the input data in the desired format to call the API
    data = [{"url": url} for url in urls]

    headers = {
      "Authorization": f"Bearer {api_key}",
      "Content-Type": "application/json",
    }

    response = requests.post(url, headers=headers, params=params, json=data)

    if response.status_code == 200:
        snapshot_id = response.json()["snapshot_id"]
        print(f"Request successful! Response: {snapshot_id}")
        return response.json()["snapshot_id"]
    else:
        print(f"Request failed! Error: {response.status_code}")
        print(response.text)

def poll_and_retrieve_snapshot(api_key, snapshot_id, output_file, polling_timeout=20):
    snapshot_url = f"https://api.brightdata.com/datasets/v3/snapshot/{snapshot_id}?format=json"
    headers = {
        "Authorization": f"Bearer {api_key}"
    }

    print(f"Polling snapshot for ID: {snapshot_id}...")

    while True:
        response = requests.get(snapshot_url, headers=headers)

        if response.status_code == 200:
            print("Snapshot is ready. Downloading...")
            snapshot_data = response.json()

            # Write the snapshot to an output json file
            with open(output_file, "w", encoding="utf-8") as file:
                json.dump(snapshot_data, file, indent=4)

            print(f"Snapshot saved to {output_file}")
            return
        elif response.status_code == 202:
            print(F"Snapshot is not ready yet. Retrying in {polling_timeout} seconds...")
            time.sleep(polling_timeout)
        else:
            print(f"Request failed! Error: {response.status_code}")
            print(response.text)
            break

if __name__ == "__main__":
    BRIGHT_DATA_API_KEY = "<YOUR_BRIGHT_DATA_API_KEY>" # Replace it with your Bright Data's Web Scraper API key
    # URLs of BBC articles to retrieve data from
    urls = [
        "https://www.bbc.com/sport/formula1/articles/c9dj0elnexyo",
        "https://www.bbc.com/sport/formula1/articles/cgenqvv9309o",
        "https://www.bbc.com/sport/formula1/articles/c78jng0q2dxo",
        "https://www.bbc.com/sport/formula1/articles/cdrgdm4ye53o",
        "https://www.bbc.com/sport/formula1/articles/czed4jk7eeeo",
        "https://www.bbc.com/sport/football/articles/c807p94r41do",
        "https://www.bbc.com/sport/football/articles/crgglxwge10o",
        "https://www.bbc.com/sport/tennis/articles/cy700xne614o",
        "https://www.bbc.com/sport/tennis/articles/c787dk9923ro",
        "https://www.bbc.com/sport/golf/articles/ce3vjjq4dqzo"
    ]
    snapshot_id = trigger_bbc_news_articles_scraping(BRIGHT_DATA_API_KEY, urls)
    poll_and_retrieve_snapshot(BRIGHT_DATA_API_KEY, snapshot_id, "news-data.json")

Tenga en cuenta que las URL de entrada que hemos elegido se refieren todas a artículos deportivos de la BBC. Ejecute el script anterior y obtendrá un resultado como el siguiente:

Request successful! Response: s_m9in0ojm4tu1v8h78
Polling snapshot for ID: s_m9in0ojm4tu1v8h78...
Snapshot is not ready yet. Retrying in 20 seconds...
# ...
Snapshot is not ready yet. Retrying in 20 seconds...
Snapshot is ready. Downloading...
Snapshot saved to news-data.json

Como puede ver, el script continúa sondeando hasta que los datos están listos. Una vez finalizado el proceso, encontrará un archivo llamado news-data.json en la carpeta del proyecto que contiene los datos de los artículos extraídos en formato JSON estructurado.

Paso 2: Limpieza y preparación de los datos raspados

Si abre el archivo de datos de salida, verá una matriz de noticias como ésta:

[
    {
        "input": {
            "url": "https://www.bbc.com/sport/football/articles/c807p94r41do",
            "keyword": ""
        },
        "id": "c807p94r41do",
        "url": "https://www.bbc.com/sport/football/articles/c807p94r41do",
        "author": "BBC",
        "headline": "Man City Women: What has gone wrong for WSL side this season?",
        "topics": [
            "Football",
            "Women's Football"
        ],
        "publication_date": "2025-04-13T19:35:45.288Z",
        "content": "With their Women's Champions League qualification ...",
        "videos": [],
        "images": [
            // ...
        ],
        "related_articles": [
            // ...
        ],
        "keyword": null,
        "timestamp": "2025-04-15T13:14:27.754Z"
    }
    // ...
]

Ahora que ya tiene sus datos, el siguiente paso es importar este archivo, limpiar el contenido y prepararlo para la generación de incrustaciones ML.

En este caso, Bright Data ya hace la mayor parte del trabajo pesado por usted. Los datos raspados se devuelven en un formato analizado y estructurado, por lo que no tendrá que preocuparse del análisis de datos HTML.

En cambio, lo que sí quieres hacer es:

• Normaliza los espacios en blanco, las nuevas líneas y los tabuladores en el contenido del texto.
• Combine el titular del artículo con el contenido del cuerpo para formar una única cadena de texto limpia adecuada para la generación de incrustaciones.

Para facilitar el manejo de datos, se recomienda utilizar Pandas. Puede instalarlo con:

pip install pandas

Cargue el archivo news-data.json del paso anterior y ejecute la lógica de procesamiento de datos:

import pandas as pd
import json
import re


# Load your JSON array
with open("news-data.json", "r") as f:
    news_data = json.load(f)

# Normalize whitespaces/newlines/tabs for better embedding quality
def clean_text(text):
    text = re.sub(r"\s+", " ", text)
    return text.strip()

# Create a DataFrame
df = pd.DataFrame(news_data)

# Combine headline and cleaned content for embedding input
df["text_for_embedding"] = df["headline"].map(clean_text) + ". " + df["content"].map(clean_text)

# Ensure ID is a string
df["id"] = df["id"].astype(str)

Observe que el nuevo campo text_for_embedding contiene el contenido de texto agregado y depurado, listo para la generación de incrustaciones.

Paso 3: Generación de las incrustaciones

Utilice SentenceTransformer para generar incrustaciones a partir del campo text_for_embedding:

from sentence_transformers import SentenceTransformer

# Step 2 ...

# Initialize a model for embedding generation
model = SentenceTransformer("all-MiniLM-L6-v2")

# Generate embeddings
texts = df["text_for_embedding"].tolist()
embeddings = model.encode(texts, show_progress_bar=True, batch_size=16)

# Store the resulting emebeddings in the DataFrame
df["embedding"] = embeddings.tolist()

Dado que show_progress_bar está establecido en True, sentence_transformers mostrará una barra de progreso en el terminal durante la generación de la incrustación. Esto es especialmente útil cuando se procesan grandes conjuntos de datos, ya que la operación puede llevar algún tiempo.

Las incrustaciones vectoriales generadas se almacenan directamente en la columna de incrustación del DataFrame original del paso 1.

Paso 4: Elegir y configurar la base de datos de vectores

Milvus es una excelente elección para una base de datos vectorial en este ejemplo porque es gratuita, de código abierto y admite la búsqueda semántica como uno de sus principales casos de uso.

Para instalar Milvus en su máquina local, siga las páginas de la documentación oficial:

• Instalación de Milvus con Docker en Linux
• Instalación de Milvus con Docker en Windows

Debería tener una instancia de Milvus ejecutándose localmente en el puerto 19530.

A continuación, instale pymilvus, elcliente Python de Milvus:

pip install pymilvus

Nota: La versión del servidor Milvus debe coincidir con la versión del cliente Python. Versiones incompatibles pueden provocar errores de conexión. Puede encontrar las combinaciones de versiones compatibles en la página de versiones de Milvus en GitHub. En el momento de escribir esto, funciona la siguiente combinación:

• Versión del servidor Milvus: 2.5.9
• pymilvus versión: 2.5.6

Paso 5: Carga de las incrustaciones en la base de datos vectorial

Utilice pymilvus para conectarse a su servidor Milvus local, crear una colección news_articles, definir su esquema e índice, y rellenarla con las incrustaciones:

from pymilvus import connections, utility, CollectionSchema, FieldSchema, DataType, Collection

# Step 4...

# Connect to Milvus
connections.connect("default", host="localhost", port="19530")

# Drop the "news_articles" collection if it already exists
if utility.has_collection("news_articles"):
    utility.drop_collection("news_articles")

# Define the collection's schema
fields = [
    FieldSchema(name="id", dtype=DataType.VARCHAR, is_primary=True, max_length=64),
    FieldSchema(name="url", dtype=DataType.VARCHAR, max_length=65535),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=384),
]
schema = CollectionSchema(fields, description="News article embeddings for semantic search")
collection = Collection(name="news_articles", schema=schema)

# Create an index on the embedding field
index_params = {
    "metric_type": "COSINE",
    "index_type": "HNSW",
}
collection.create_index(field_name="embedding", index_params=index_params)

# Load the collection for the first time
collection.load()

# Prepare data for insertion
ids = df["id"].tolist()
urls = df["url"].tolist()
texts = df["text_for_embedding"].tolist()
vectors = df["embedding"].tolist()

# Insert the data into the Milvus collection
collection.insert([ids, urls, texts, vectors])
collection.flush()

Después de estas líneas de código, la colección news_articles de su servidor local Milvus contendrá los datos incrustados, listos para soportar consultas de búsqueda semántica.

Paso 6: Realizar búsquedas semánticas

Defina una función para realizar búsquedas semánticas en la colección news_articles:

# Step 5... 

def search_news(query: str, top_k=3, score_threshold=0.5):
    query_embedding = model.encode([query])
    search_params = {"metric_type": "COSINE"}

    results = collection.search(
        data=query_embedding,
        anns_field="embedding",
        param=search_params,
        limit=top_k,
        output_fields=["id", "url", "text"]
    )

    for hits in results:
        for hit in hits:
            if hit.score >= score_threshold:
                print(f"Score: {hit.score:.4f}")
                print(f"URL: {hit.fields["url"]}")
                print(f"Text: {hit.fields["text"][:300]}...\n")

Busca los 3 primeros resultados que coinciden semánticamente con la consulta proporcionada, devolviendo sólo aquellos con una puntuación de similitud superior a 0,5. Dado que utilizamos la similitud coseno, la puntuación oscila entre -1 (totalmente opuesto) y 1 (coincidencia perfecta).

Ahora puede realizar una búsqueda semántica sobre la consulta “Futuro de la escudería Red Bull en la Fórmula 1” con:

search_news("Future of the Red Bull racing team in Formula 1")

La salida será:

Score: 0.5736
URL: https://www.bbc.com/sport/formula1/articles/c9dj0elnexyo
Text: Max Verstappen: Red Bull adviser Helmut Marko has 'great concern' about world champion's future with team. Saudi Arabian Grand PrixVenue: Jeddah Dates: 18-20 April Race start: 18:00 BST on SundayCoverage: Live radio commentary of practice, qualifying and race online and BBC 5 Sports Extra; live text...

Score: 0.5715
URL: https://www.bbc.com/sport/formula1/articles/czed4jk7eeeo
Text: F1 engines: A return to V10 or hybrid - what's the future?. Christian Horner's phone rang. It was Bernie Ecclestone. Red Bull's team principal picked up, switched to speakerphone and placed it on the table in front of the assembled Formula 1 bosses.We're in the F1 Commission, Horner told Ecclestone....

Si lee los artículos recuperados, verá que la consulta no está presente literalmente en el texto. Aun así, los artículos recuperados tratan claramente sobre el futuro de Red Bull en la Fórmula 1, lo quedemuestra el poder de las incrustaciones vectoriales.

Optimización del rendimiento de las bases de datos vectoriales

Para sacar el máximo partido a su base de datos vectorial, empiece por organizar sus datos en colecciones significativas. A continuación, considera la posibilidad de implementar la fragmentación y la agrupación de datos, y de definir estrategias de indexación optimizadas para tus patrones de consulta específicos.

Tenga en cuenta que muchas de estas optimizaciones son más eficaces una vez que su proceso de base de datos vectorial está maduro. Esto ocurre cuando se tiene un conocimiento sólido de los datos que se consultan con más frecuencia. Sólo entonces podrá optimizar el rendimiento basándose en patrones de uso reales, en lugar de en suposiciones prematuras.

Otros problemas de rendimiento habituales son la desviación de la incrustación, las dimensiones de vectores incoherentes y los datos obsoletos o duplicados. Para solucionarlos, vuelva a incrustarlos con regularidad, aplique la coherencia de esquemas a sus datos de alta dimensión y configure tareas de limpieza automatizadas.

A medida que vayan entrando nuevos datos en el sistema, también será necesario que admita actualizaciones de vectores en tiempo real o inserciones programadas por lotes. A este respecto, recuerde que la introducción de datos no verificados puede generar incrustaciones con ruido y resultados de búsqueda poco fiables.

Por último, para optimizar las bases de datos de nodo único, considere la posibilidad de ajustar parámetros como la precisión de los índices, la dimensionalidad de los vectores y el número de fragmentos. A medida que crece la carga de trabajo, se suele preferir el escalado horizontal al vertical. Por lo tanto, es posible que acabe teniendo varios nodos distribuidos, normalmente en la nube.

Tendencias futuras en bases de datos vectoriales

Los sistemas modernos de IA son todavía relativamente nuevos, y el ecosistema evoluciona con rapidez. Dado que las bases de datos vectoriales sirven de motor a muchos de los movimientos de IA, la propia tecnología se adapta continuamente para dar soporte a aplicaciones cada vez más complejas del mundo real.

De cara al futuro, pueden ser interesantes las tendencias que configuren el futuro de las bases de datos vectoriales:

• Integración de búsqueda híbrida: Combinación de búsqueda vectorial con sistemas relacionales o NoSQL tradicionales para permitir consultas más flexibles en datos estructurados y no estructurados.
• Soporte multimodal nativo: Permite el almacenamiento unificado y la consulta de incrustaciones de diversas fuentes como texto, imágenes, audio y vídeo.
• Indexación y ajuste más inteligentes: Uso de funciones como parámetros autoajustados, almacenamiento rentable e integraciones de bases de datos SQL para mejorar la escalabilidad y la preparación de la empresa.

Conclusión

Como ha aprendido en esta guía, las bases de datos vectoriales son un componente esencial del almacenamiento de datos de aprendizaje automático. En concreto, has comprendido qué son las bases de datos vectoriales, cómo funcionan, las principales opciones disponibles actualmente en el sector y su papel fundamental en la infraestructura de datos de IA moderna.

También vio cómo pasar de datos sin procesar a incrustaciones almacenadas en una base de datos vectorial para un caso de uso de búsqueda semántica. Esto resaltó la importancia de comenzar con datos completos, fiables y actualizados, que es exactamente donde entran en juego las soluciones de raspado web de Bright Data.

Inicie una prueba gratuita con Bright Data para obtener datos de alta calidad que impulsen sus aplicaciones de bases de datos vectoriales.