Por que os sistemas de IA usam bancos de dados vetoriais para melhorar o desempenho e reduzir os custos

O treinamento em IA consome muitos recursos. São necessários conjuntos de dados enormes, algoritmos avançados e hardware especializado (leia-se: GPUs caras) para ensinar um modelo a entender linguagem, imagens ou áudio. Porém, mesmo após a conclusão do treinamento, a execução de inferências (o processo de geração de resultados) pode ser igualmente desgastante.

Consultar um LLM em tempo real para cada solicitação de usuário não é apenas caro, é ineficiente. Especialmente quando a resposta já pode existir. Para resolver esse desafio, as equipes de desenvolvimento recorreram aos bancos de dados vetoriais.

Diferentemente dos bancos de dados tradicionais, que dependem de correspondências exatas de palavras-chave, os bancos de dados vetoriais armazenam informações como incorporações de alta dimensão, como representações numéricas de dados como texto, imagens ou som. Isso possibilita a realização de pesquisas semânticas. Portanto, em vez de procurar por palavras exatas, você está procurando por significado.

Essa distinção é essencial em casos de uso como:

• Geração aumentada por recuperação (RAG)
• Mecanismos de recomendação
• Sistemas de resposta a perguntas
• Pesquisa semântica
  

Com os bancos de dados vetoriais, os sistemas de IA podem recuperar informações relevantes com mais rapidez e eficiência, ignorando chamadas de inferência desnecessárias quando a resposta já existe no índice vetorial. Há muitas soluções diferentes de bancos de dados vetoriais, mas hoje falarei sobre o pgvector, uma extensão do PostgreSQL de código aberto que eu pessoalmente uso e recomendo. Vamos explicar por que eu acho que é uma ferramenta tão boa e como você pode começar a usá-la.

Por que o pgvector é uma ótima ferramenta para desenvolvedores

Para começar, o pgvector integra recursos de pesquisa vetorial diretamente no PostgreSQL, um dos bancos de dados relacionais mais amplamente adotados no mundo. Para os desenvolvedores e as equipes que já trabalham em um ambiente baseado no PostgreSQL, isso representa uma opção perfeita e de menor atrito para a criação de aplicativos inteligentes.

Em vez de introduzir uma pilha nova e separada para gerenciar, o pgvector permite que as equipes armazenem e consultem dados relacionais e vetoriais em um só lugar. Essa unificação elimina a complexidade da sincronização de bancos de dados diferentes e permite um ciclo de vida de desenvolvimento mais simples. Os aplicativos de IA geralmente exigem a combinação de diferentes tipos de consultas, como filtros estruturados, pesquisa de texto completo e similaridade semântica, tudo em uma única operação. O pgvector oferece suporte nativo a esse padrão de pesquisa híbrida, permitindo que os desenvolvedores combinem a pontuação de similaridade vetorial com filtros e junções baseados em SQL. Isso permite que você pesquise um corpus de documentos não apenas por palavra-chave, mas também por significado semântico, tudo isso enquanto aplica filtros como categoria de documento ou permissões de usuário, em uma única consulta SQL.

O pgvector foi desenvolvido para ter escalabilidade e desempenho no mundo real. Para aplicativos que precisam fornecer resultados rápidos em milhões de incorporações, o pgvector oferece suporte à pesquisa aproximada do vizinho mais próximo (ANN) por meio do método de indexação IVFFlat. Isso permite respostas rápidas para aplicativos sensíveis à latência, como barras de pesquisa alimentadas por IA ou sistemas de recomendação, mantendo um bom equilíbrio entre precisão e velocidade. Para as equipes que desenvolvem em Python, o pgvector se integra facilmente às bibliotecas de clientes populares do PostgreSQL, como psycopg2, asyncpg e SQLAlchemy, facilitando a inserção em seus pipelines de dados e fluxos de trabalho de ML existentes.

A versatilidade do pgvector está se mostrando valiosa em todos os setores. Vemos organizações de comércio eletrônico usarem-no para fazer recomendações personalizadas a fim de aumentar as conversões. Uma grande plataforma de mídia o utiliza para exibir conteúdo relevante, mantendo os usuários envolvidos. As equipes de saúde e ciências biológicas contam com ele para pesquisas mais rápidas, descoberta de compostos e insights de diagnósticos. Em muitas empresas de tecnologia, ele está possibilitando suporte orientado por LLM e ferramentas internas mais inteligentes. 

O que torna o pgvector ainda mais poderoso é implantá-lo em uma plataforma como a Akamai Cloud. A solução de nuvem da Akamai oferece às equipes a infraestrutura gerenciada, a escalabilidade e a vantagem de desempenho global de que precisam para cargas de trabalho de nível de produção. O Managed PostgreSQL na Akamai permite que os desenvolvedores implantem aplicações suportadas por pgvector sem se preocupar com a sobrecarga operacional. Com backups automatizados, segurança integrada e opções de escalonamento automático, sua pilha permanece resiliente enquanto sua equipe se concentra na criação. E como a infraestrutura de computação e rede da Akamai é otimizada para entrega global, as aplicações que dependem de inferência rápida ou de mecanismos de recomendação em tempo real se beneficiam da menor latência e da maior confiabilidade em escala.

Se você já estiver usando o PostgreSQL ou estiver procurando um mecanismo de pesquisa vetorial pronto para IA que não exija uma revisão completa da pilha, na próxima seção, mostrarei como começar a usar o pgvector. 

Primeiros passos com o pgvector na Akamai

1. Provisione um cluster PostgreSQL usando o painel Managed Databases da Akamai.
   1. Faça login no Cloud Manager.
   2. No menu principal, selecione Databases (Bancos de dados).
   3. Clique em Create Database Cluster.
   4. No campo Cluster Label (Rótulo do cluster), insira um rótulo para que você possa identificar facilmente o cluster em sua conta. O rótulo deve ser alfanumérico e ter entre 3 e 32 caracteres.
   5. Selecione o mecanismo de banco de dados para seu novo banco de dados.
   6. Selecione a região em que o cluster do banco de dados residirá. 
   7. Cada nó de um cluster de banco de dados é construído em seu próprio Linode. Na seção Choose a Plan (Escolher um plano ), selecione o tipo de Linode e o plano que os nós usarão. 
   8. Clique em Criar cluster de banco de dados. Leva cerca de 10 a 15 minutos para provisionar totalmente o cluster. Você pode acompanhar o status revisando o Status na lista Database Clusters.
      
      Observação: Você também pode provisionar usando APIs
2. Faça login em seu cluster
   Para se conectar diretamente ao banco de dados a partir da linha de comando, você pode usar a ferramenta psql. Essa ferramenta é incluída como parte da maioria das instalações do servidor PostgreSQL, embora você também possa instalá-la separadamente na maioria dos sistemas operacionais.
   
   Use o comando psql abaixo para se conectar ao seu banco de dados, substituindo [host] e [username] com os valores correspondentes na seção de detalhes da conexão.
   
   psql --host=[host] --username=[username] --password --dbname=postgres
3. Instalar uma extensão
   Para instalar uma das extensões disponíveis em seu banco de dados, use o comando CREATE EXTENSION, substituindo [nome_da_extensão] pelo nome da extensão que deseja instalar. Nesse caso, a extensão é vector.
   
   CREATE EXTENSION vector;
4. Definir colunas de vetores
   Depois de instalar a extensão de vetor, você terá acesso a um novo tipo de dados chamado vetor. O tamanho do vetor (indicado entre parênteses) representa o número de dimensões armazenadas nesse vetor. Para este exemplo, usaremos 13, mas, em um caso de uso real, esse número estaria na casa dos milhares.
   
   CREATE TABLE items ( id serial PRIMARY KEY, description text, embedding vector(13) );
   
5. Insira embeddings de seu modelo de ML (como A ou Cara de abraço). Para reunir exemplos de embeddings, você pode usar o script Python abaixo, que foi adaptado da demonstração do Hugging Face. Você precisará obter um token do Hugging Face para que esse exemplo funcione.
   
   import requests
import psycopg2
import os

# Hugging Face Configuration
model_id = "sentence-transformers/all-MiniLM-L6-v2"
hf_token = os.environ.get("HF_TOKEN") # Set an environmental variable called HF_TOKEN with your Hugging Face token
api_url = f"https://router.huggingface.co/hf-inference/models/{model_id}"
headers = {"Authorization": f"Bearer {hf_token}"}

# Database Configuration
db_conn_string = os.environ.get("DB_CONN_STRING") # Replace with your connection string or set an env var

# Source for Embeddings
source_sentence = "How do I get Medicare?"
sentences = [
    "How do I get a replacement Medicare card?",
    "What is the monthly premium for Medicare Part B?",
    "How do I terminate my Medicare Part B (medical insurance)?",
    "How do I sign up for Medicare?",
    "Can I sign up for Medicare Part B if I am working and have health insurance through an employer?",
    "How do I sign up for Medicare Part B if I already have Part A?",
    "What are Medicare late enrollment penalties?",
    "What is Medicare and who can get it?",
    "How can I get help with my Medicare Part A and Part B premiums?",
    "What are the different parts of Medicare?",
    "Will my Medicare premiums be higher because of my higher income?",
    "What is TRICARE ?",
    "Should I sign up for Medicare Part B if I have Veterans' Benefits?"
]

# Hugging Face API Query Function
def get_embeddings(source_sentence, sentences):
    """Queries the Hugging Face API to get sentence embeddings."""
    try:
        response = requests.post(
            Api_url,
            headers=headers,
            json={"inputs": { "source_sentence": source_sentence, "sentences": sentences }, "options": {"wait_for_model": True}}
        )
        response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error querying Hugging Face API: {e}")
        return None

# Main Execution
print("Fetching embeddings from Hugging Face...")
embeddings = get_embeddings(source_sentence, sentences)

if embeddings:
    print(f"Successfully fetched {len(embeddings)} embeddings.")
    conn = None
    Try:
        # Establish connection to the database
        print("Connecting to the PostgreSQL database...")
        conn = psycopg2.connect(db_conn_string)
        cur = conn.cursor()
        print("Connection successful.")

        # Insert descriptions and embeddings into the database
        print("Inserting data into the 'items' table...")
        for description, embedding in zip(sentences, embeddings):
            # The pgvector extension expects the vector as a string representation of a list
            cur.execute(
                "INSERT INTO items (description, embedding) VALUES (%s, %s)",
                (description, embeddings)
            )

        # Commit the transaction to make the changes permanent
        conn.commit()
        print(f"Successfully inserted {cur.rowcount} records into the database.")

    except psycopg2.Error as e:
        print(f"Database error: {e}")
        if conn:
            conn.rollback() # Rollback the transaction on error

    Finally:
        # Ensure the connection is closed
        if conn:
            cur.close()
            conn.close()
            print("Database connection closed.")

   
6. Use a indexação e a pesquisa do pgvector
   Create the index after the table has some data

CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops);

SELECT *, embedding <-> query_embedding AS similarity FROM items ORDER BY similarity LIMIT 5;

Os bancos de dados vetoriais estão ajudando as equipes a otimizar o desempenho, reduzir os custos de inferência e oferecer experiências de usuário mais inteligentes e rápidas, e extensões como o pgvector facilitam a inclusão da pesquisa semântica e das consultas híbridas em ambientes familiares, como o PostgreSQL, sem reformular sua arquitetura. 

Saiba mais sobre como implantar e usar o pgVector e outras extensões disponíveis em nossos documentos.