Entendendo os bancos de dados vetoriais: O mecanismo por trás da IA moderna

Os bancos de dados vetoriais podem armazenar e indexar dados de alta dimensão incorporados gerados por modelos de aprendizado de máquina. Eles são a base da IA moderna, oferecendo suporte ao armazenamento de informações contextuais e à pesquisa semântica significativa.

Embora frequentemente associados à geração aumentada por recuperação (RAG), seus aplicativos vão muito além disso. Em detalhes, eles potencializam a pesquisa semântica, os sistemas de recomendação, a detecção de anomalias e muitos outros aplicativos.

Siga este guia para entender o que são bancos de dados vetoriais, como eles funcionam, como usá-los em um exemplo completo e o que o futuro reserva para eles!

O que são bancos de dados vetoriais?

Os bancos de dados vetoriais são sistemas de armazenamento projetados para armazenar dados vetoriais. Nesse contexto, um vetor refere-se a uma incorporação numérica que representa dados não estruturados, como texto, imagens ou áudio, geralmente produzidos por um modelo de aprendizado de máquina.

Diferentemente dos bancos de dados tradicionais, os bancos de dados vetoriais armazenam dados de alta dimensão como vetores numéricos densos e os indexam em um espaço N-dimensional, permitindo pesquisas otimizadas baseadas em similaridade.

A crescente importância dos bancos de dados vetoriais em IA/ML

Na maioria dos casos, os bancos de dados SQL tradicionais não são adequados para tarefas de IA e aprendizado de máquina. O motivo é que eles armazenam dados estruturados e suportam apenas consultas de correspondência exata ou pesquisas de similaridade limitadas. Assim, eles têm dificuldade para lidar com conteúdo não estruturado e capturar as relações semânticas entre os pontos de dados.

Agora, os aplicativos de IA exigem uma compreensão contextual dos dados. Isso pode ser obtido com embeddings – que os bancos de dados relacionais não são otimizados para armazenar ou consultar. Os bancos de dados vetoriais abordam essas limitações oferecendo suporte a pesquisas baseadas em similaridade que refletem o significado e o contexto, abrindo a porta para a compreensão semântica dos dados.

Embora o cenário mais comum para essa tecnologia seja a geração aumentada por recuperação (RAG), outros casos de uso possíveis são:

• Mecanismos de pesquisa semântica
• Sistemas de recomendação
• Detecção de anomalias em dados de séries temporais
• Classificação e pesquisa de imagens em visão computacional
• Aplicativos de processamento de linguagem natural (NLP)

Como funcionam os bancos de dados vetoriais

Os bancos de dados vetoriais gerenciam os dados como incorporações de vetores, que existem em um espaço de alta dimensão. Cada dimensão representa um recurso dos dados, correspondendo a uma característica específica dos dados originais (representados como uma incorporação), conforme interpretado pelo modelo de ML. Quanto maior a dimensionalidade da incorporação, mais detalhada será a representação, permitindo uma compreensão mais rica da estrutura dos dados.

Para encontrar dados semanticamente semelhantes, os bancos de dados vetoriais usam métricas de similaridade como:

• Similaridade de cosseno: Mede o cosseno do ângulo entre dois vetores para avaliar a similaridade de suas direções. Isso é comumente usado para dados de texto.
• Distância euclidiana: Mede a distância em linha reta entre dois vetores, útil para dados espaciais em que tanto a direção quanto a magnitude são importantes.
• Similaridade do produto escalar: Calcula o produto dos componentes vetoriais correspondentes, com um produto escalar mais alto indicando maior similaridade. Isso é útil em sistemas de recomendação e tarefas de classificação.

Assim como os bancos de dados SQL e NoSQL usam índices para acelerar a consulta de dados, os bancos de dados vetoriais podem utilizar técnicas avançadas de indexação, como:

• Vizinho mais próximo aproximado (ANN): Torna as pesquisas de similaridade mais rápidas ao aproximar os vetores mais próximos, reduzindo o custo computacional em comparação com as pesquisas exatas.
• Hierarchical Navigable Small World (HNSW): Representa vetores em uma estrutura de gráfico para navegação mais rápida em espaços grandes e de alta dimensão.

Além disso, técnicas de particionamento e agrupamento podem ser aplicadas para organizar os dados vetoriais em grupos menores e mais gerenciáveis. Esses métodos melhoram a eficiência do armazenamento e o desempenho da pesquisa.

Opções populares de bancos de dados vetoriais

Agora que você já sabe o que são bancos de dados vetoriais e como funciona a infraestrutura de dados de IA, está pronto para explorar as opções mais populares de bancos de dados vetoriais. Analisaremos cada um deles com base nos seguintes aspectos:

• Arquitetura
• Características de desempenho
• Recursos de integração
• Modelo de precificação
• Melhores casos de uso

Se estiver ansioso para descobrir quais bancos de dados vetoriais se destacam, dê uma olhada na tabela de resumo abaixo:

É hora de se aprofundar nas opções selecionadas do banco de dados vetorial!

Pinha

• Arquitetura: Totalmente gerenciada, sem servidor
• Características de desempenho

  : o espaço reservado Polylang não é modificado

• Recursos de integração

  : o espaço reservado Polylang não é modificado

• Modelo de preço

  : espaço reservado Polylang não modificar

• Melhores casos de uso

  : não modificar o espaço reservado da Polylang

Weaviate

• Arquitetura: Modular, nativa da nuvem
• Características de desempenho

  : o espaço reservado Polylang não é modificado

• Recursos de integração

  : o espaço reservado Polylang não é modificado

• Modelo de preço

  : espaço reservado Polylang não modificar

• Melhores casos de uso

  : não modificar o espaço reservado da Polylang

Milvus

• Arquitetura: Arquitetura de armazenamento compartilhado com desagregação de armazenamento e computação para escalabilidade horizontal
• Características de desempenho

  : o espaço reservado Polylang não é modificado

• Recursos de integração

  : o espaço reservado Polylang não é modificado

• Modelo de preço

  : espaço reservado Polylang não modificar

• Melhores casos de uso

  : não modificar o espaço reservado da Polylang

Croma

• Arquitetura: Servidor de nó único para aplicativos pequenos ou distribuído na nuvem para aplicativos maiores
• Características de desempenho

  : o espaço reservado Polylang não é modificado

• Recursos de integração

  : o espaço reservado Polylang não é modificado

• Modelo de preço

  : espaço reservado Polylang não modificar

• Melhores casos de uso

  : não modificar o espaço reservado da Polylang

Qdrant

• Arquitetura: Auto-hospedagem local ou implementação distribuída na nuvem para aplicativos maiores e com vários locatários
• Características de desempenho

  : o espaço reservado Polylang não é modificado

• Recursos de integração

  : o espaço reservado Polylang não é modificado

• Modelo de preço

  : espaço reservado Polylang não modificar

• Melhores casos de uso

  : não modificar o espaço reservado da Polylang

Alimentando bancos de dados vetoriais com dados brilhantes

Os dois principais aspectos que afetam a qualidade dos embeddings de vetores são:

1. O modelo de aprendizado de máquina usado para gerar os embeddings.
2. A qualidade dos dados de entrada inseridos nesse modelo.

Isso destaca como um pipeline de banco de dados vetorial é tão eficiente quanto os dados que o alimentam. Se os embeddings forem produzidos a partir de dados de baixa qualidade, incompletos ou ruidosos, até mesmo os melhores modelos de ML e bancos de dados vetoriais apresentarão resultados ruins.

Agora você entende por que a coleta de dados limpos, ricos e abrangentes é tão importante – e é aqui que entra a Bright Data!

A Bright Data é uma plataforma líder de coleta de dados e raspagem da Web que permite coletar dados da Web de alta qualidade de forma ética e eficiente em escala. Suas soluções de coleta de dados podem extrair dados estruturados e em tempo real de centenas de domínios. Além disso, essas soluções podem ser integradas diretamente em seus próprios fluxos de trabalho para melhorar o desempenho de seus scripts de raspagem personalizados.

A principal vantagem dessa abordagem ao fornecimento de dados é que a Bright Data cuida de tudo. Ela gerencia a infraestrutura, lida com a rotação de IP, ignora as proteções anti-bot, analisa os dados HTML e garante a cobertura total da conformidade.

Essas ferramentas de raspagem da Web ajudam você a acessar dados novos e estruturados diretamente das páginas da Web. Considerando que a Web é a maior fonte de dados, aproveitá-la é ideal para gerar embeddings vetoriais ricos em contexto. Esses embeddings podem, então, alimentar uma ampla gama de aplicativos de pesquisa e IA, como:

• Informações sobre produtos para recomendações de comércio eletrônico
• Artigos de notícias para pesquisa semântica e contextual
• Conteúdo de mídia social para detecção e análise de tendências
• Listagens de empresas para experiências com reconhecimento de local

De dados brutos a embeddings de vetores: O processo de transformação

O processo de transformação de dados brutos em embeddings de vetores requer duas etapas:

1. Pré-processamento de dados
2. Geração de incorporação

Vamos detalhá-las para entender melhor como cada etapa funciona e o que ela implica.

Etapa 1. Pré-processamento de dados

Os dados brutos tendem a ser ruidosos, redundantes ou não estruturados. A primeira etapa na transformação de dados brutos em embeddings é limpá-los e normalizá-los. Esse processo aumenta a qualidade e a consistência dos dados de entrada antes de alimentá-los em um modelo de aprendizado de máquina para geração de embedding.

Por exemplo, quando se trata de usar dados da Web no aprendizado de máquina, as etapas comuns de pré-processamento incluem:

• Análise de HTML bruto para extrair conteúdo estruturado.
• Corte de espaços em branco e padronização de formatos de dados (por exemplo, preços, datas e símbolos de moeda).
• Normalizar o texto convertendo-o em letras minúsculas, removendo a pontuação e manipulando caracteres HTML especiais.
• Deduplicação de conteúdo para evitar informações redundantes.

Etapa 2. Geração de incorporação

Depois que os dados são limpos e pré-processados, eles podem passar por um modelo de incorporação de ML. Isso os transformará em um vetor numérico denso.

A escolha do modelo de incorporação depende do tipo de dados de entrada e da qualidade de saída desejada. Abaixo estão alguns métodos populares:

• Modelos de incorporação da OpenAI: Eles geram vetores de alta qualidade e de uso geral com excelente compreensão semântica.
• Transformadores de frases: Uma estrutura Python de código aberto para embeddings de frases, textos e imagens de última geração. Ele é executado localmente e oferece suporte a vários modelos pré-treinados.
• Modelos de incorporação específicos do domínio: Ajustados em conjuntos de dados de nicho, como relatórios financeiros, documentos jurídicos ou textos biomédicos, para obter alto desempenho em cenários específicos.

Por exemplo, é assim que você pode usar os modelos de incorporação da OpenAI para gerar uma incorporação

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

O resultado será um vetor de 3072 dimensões, como:

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

Da mesma forma, veja como você pode produzir embeddings com 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)

Dessa vez, o resultado será um vetor de 384 dimensões mais curto:

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

Observe que há uma compensação entre a qualidade da incorporação e a eficiência computacional. Modelos grandes, como os oferecidos pela OpenAI, produzem embeddings ricos e de alta precisão, mas podem levar algum tempo e até exigir chamadas de rede para modelos de IA premium. Por outro lado, os modelos locais, como os da SentenceTransformers, são gratuitos e muito mais rápidos, mas podem sacrificar a nuance semântica.

A escolha da estratégia de incorporação correta depende de seus requisitos de desempenho e do nível de precisão semântica que você deseja alcançar.

Integração prática: A Step-by-Step Guide (Guia passo a passo)

Siga as etapas abaixo e saiba como passar de dados brutos em uma página da Web para uma pesquisa semântica eficaz com um script Python.

Esta seção do tutorial o guiará pelo processo de:

1. Usando a API do Web Scraper da Bright Data para recuperar artigos de notícias da BBC.
2. Pré-processamento dos dados extraídos e preparação para a geração de incorporação.
3. Geração de embeddings de texto usando SentenceTransformers.
4. Configurando o Milvus.
5. Preenchimento do banco de dados de vetores com o texto processado e os embeddings.
6. Realização de pesquisas para recuperar artigos de notícias semanticamente relevantes com base em uma consulta de pesquisa.

Vamos mergulhar de cabeça!

Pré-requisitos

Antes de começar, verifique se você tem o seguinte:

• Python 3+ instalado localmente
• Docker instalado localmente
• Uma conta da Bright Data

Se ainda não tiver feito isso, instale o Python e o Docker em seu computador e crie uma conta gratuita na Bright Data.

Etapa 1: coleta de dados usando a API do raspador da Web da Bright Data

A raspagem de artigos de notícias nem sempre é simples, pois muitos portais de notícias protegem suas páginas com medidas anti-raspagem e anti-bot. Para contornar essas proteções de forma confiável e recuperar dados novos da BBC, usaremos a API Web Scraper da Bright Data.

Essa API expõe pontos de extremidade dedicados para coletar dados estruturados de mais de 120 sites populares, incluindo a BBC. É assim que o processo de raspagem funciona:

1. Você faz uma solicitação POST ao endpoint apropriado para acionar uma tarefa de raspagem para URLs especificados em um determinado domínio.
2. A Bright Data executa a tarefa de raspagem na nuvem.
3. Você pesquisa periodicamente outro endpoint até que os dados extraídos estejam prontos (em JSON, CSV ou outros formatos).

Antes de começar a usar o código Python, certifique-se de instalar a biblioteca Requests:

pip install requests

Em seguida, consulte a documentação da Bright Data para se familiarizar com a API do Web Scraper. Além disso, recupere sua chave de API.

Agora, use o código abaixo para recuperar dados da 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")

Observe que todos os URLs de entrada que escolhemos se referem a artigos esportivos da BBC. Execute o script acima e você obterá um resultado como este:

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 você pode ver, o script continua a sondar até que os dados estejam prontos. Quando o processo estiver concluído, você encontrará um arquivo chamado news-data.json na pasta do projeto que contém os dados do artigo extraído no formato JSON estruturado.

Etapa 2: Limpeza e preparação dos dados extraídos

Se você abrir o arquivo de dados de saída, verá uma matriz de itens de notícias como esta:

[
    {
        "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"
    }
    // ...
]

Agora que você tem seus dados, a próxima etapa é importar esse arquivo, limpar o conteúdo e prepará-lo para a geração de incorporação de ML.

Nesse caso, a Bright Data já faz a maior parte do trabalho pesado para você. Os dados extraídos são retornados em um formato analisado e estruturado, portanto, você não precisa se preocupar com a análise de dados HTML.

Em vez disso, o que você quer fazer é:

• Normalize espaços em branco, novas linhas e tabulações no conteúdo do texto.
• Combine o título do artigo com o conteúdo do corpo para formar uma única cadeia de texto limpa, adequada para a geração de incorporação.

Para facilitar o manuseio de dados, é recomendável usar o Pandas. Você pode instalá-lo com:

pip install pandas

Carregue o arquivo news-data.json da etapa anterior e execute a lógica de processamento de dados:

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 o novo campo text_for_embedding contém o conteúdo de texto agregado e limpo, pronto para a geração de incorporação.

Etapa 3: Geração dos embeddings

Use o SentenceTransformer para gerar embeddings a partir do 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()

Como show_progress_bar está definido como True, sentence_transformers exibirá uma barra de progresso no terminal durante a geração da incorporação. Isso é especialmente útil ao processar grandes conjuntos de dados, pois a operação pode levar algum tempo.

Os embeddings de vetores gerados são armazenados diretamente na coluna de embedding do DataFrame original da etapa 1.

Etapa 4: Escolher e configurar o banco de dados de vetores

O Milvus é uma excelente escolha para um banco de dados vetorial neste exemplo, pois é gratuito, de código aberto e oferece suporte à pesquisa semântica como um de seus principais casos de uso.

Para instalar o Milvus em seu computador local, siga as páginas da documentação oficial:

• Instalação do Milvus com o Docker no Linux
• Instalação do Milvus com o Docker no Windows

Você deve ter uma instância do Milvus em execução localmente na porta 19530.

Em seguida, instale o pymilvus, ocliente Python Milvus:

pip install pymilvus

Observação: a versão do servidor Milvus deve corresponder à versão do cliente Python. Versões incompatíveis podem levar a erros de conexão. Você pode encontrar as combinações de versões compatíveis na página de versões do Milvus no GitHub. No momento em que este texto foi escrito, a seguinte combinação funciona:

• Versão do servidor Milvus: 2.5.9
• versãodo pymilvus: 2.5.6

Etapa 5: Carregamento dos embeddings no banco de dados de vetores

Use o pymilvus para se conectar ao servidor Milvus local, criar uma coleção news_articles, definir seu esquema e índice e preenchê-la com os embeddings:

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()

Após essas linhas de código, a coleção news_articles em seu servidor Milvus local conterá os dados incorporados, prontos para suportar consultas de pesquisa semântica.

Etapa 6: Realização de pesquisas semânticas

Defina uma função para executar a pesquisa semântica na coleção 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")

Isso busca os três principais resultados que correspondem semanticamente à consulta fornecida, retornando apenas aqueles com uma pontuação de similaridade acima de 0,5. Como estamos usando a similaridade de cosseno, a pontuação varia de -1 (completamente oposta) a 1 (correspondência perfeita).

Agora você pode realizar uma pesquisa semântica na consulta “Futuro da equipe de corrida Red Bull na Fórmula 1” com:

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

O resultado 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....

Se você ler os artigos recuperados, verá que a consulta não está literalmente presente no texto. Ainda assim, os artigos recuperados são claramente sobre o futuro da Red Bull na Fórmula 1, o quemostra o poder dos embeddings vetoriais!

Otimização do desempenho do banco de dados vetorial

Para aproveitar ao máximo o seu banco de dados vetorial, comece organizando os dados em coleções significativas. Em seguida, considere implementar a fragmentação e o agrupamento de dados e definir estratégias de indexação otimizadas para seus padrões de consulta específicos.

Lembre-se de que muitas dessas otimizações serão mais eficazes quando o processo do banco de dados vetorial estiver maduro. Isso ocorre quando você tem uma sólida compreensão de quais dados são consultados com mais frequência. Só então você deverá otimizar o desempenho com base nos padrões de uso reais, em vez de suposições prematuras.

Outros desafios comuns de desempenho incluem desvio de incorporação, dimensões de vetor inconsistentes e dados obsoletos ou duplicados. Resolva-os por meio de reincorporação regular, reforçando a consistência do esquema para seus dados de alta dimensão e configurando tarefas de limpeza automatizadas.

À medida que novos dados entrarem no seu sistema, você também precisará oferecer suporte a atualizações de vetores em tempo real ou a inserções em lote programadas. A esse respeito, lembre-se de que a ingestão de dados não verificados pode resultar em incorporações ruidosas e resultados de pesquisa não confiáveis.

Por fim, para otimizar os bancos de dados de nó único, considere ajustar parâmetros como precisão do índice, dimensionalidade do vetor e contagem de fragmentos. À medida que sua carga de trabalho cresce, o escalonamento horizontal geralmente é preferível ao escalonamento vertical. Portanto, você pode acabar com vários nós distribuídos, geralmente na nuvem.

Tendências futuras em bancos de dados vetoriais

Os sistemas modernos de IA ainda são relativamente novos, e o ecossistema está evoluindo rapidamente. Como os bancos de dados vetoriais funcionam como o mecanismo por trás de muitos dos movimentos de IA, a própria tecnologia está se adaptando continuamente para dar suporte a aplicativos do mundo real cada vez mais complexos.

Olhando para o futuro, podemos observar tendências interessantes que moldam o futuro dos bancos de dados vetoriais:

• Integração de pesquisa híbrida: Combinação da pesquisa vetorial com sistemas relacionais ou NoSQL tradicionais para permitir consultas mais flexíveis em dados estruturados e não estruturados.
• Suporte multimodal nativo: Permite o armazenamento unificado e a consulta de embeddings de diversas fontes, como texto, imagens, áudio e vídeo.
• Indexação e ajuste mais inteligentes: Usando recursos como parâmetros ajustados automaticamente, armazenamento econômico e integrações de banco de dados SQL para melhorar a escalabilidade e a prontidão empresarial.

Conclusão

Como você aprendeu neste guia, os bancos de dados vetoriais são um componente essencial por trás do armazenamento de dados de aprendizado de máquina. Em particular, você entendeu o que são bancos de dados vetoriais, como eles funcionam, as principais opções disponíveis atualmente no setor e sua função vital na moderna infraestrutura de dados de IA.

Você também viu como passar dos dados brutos para os embeddings armazenados em um banco de dados vetorial para um caso de uso de pesquisa semântica. Isso destacou a importância de começar com dados abrangentes, confiáveis e atualizados – que é exatamente onde as soluções de raspagem da Web da Bright Data entram em ação.

Inicie uma avaliação gratuita com a Bright Data para obter dados de alta qualidade para alimentar seus aplicativos de banco de dados vetoriais!