Tutorial do pgvector: Integrar o Vector Search ao PostgreSQL

A pesquisa vetorial tem se tornado cada vez mais popular nos últimos anos, graças a todo o progresso no ecossistema de IA generativa e modelo de linguagem grande. 

A pesquisa vetorial é um método de recuperação de informações no qual os documentos e as consultas são representados como vetores em vez de texto simples. Essa representação numérica é obtida por meio de uma grande rede neural treinada que pode converter dados não estruturados, como texto, imagens e vídeos, em vetores.

Os bancos de dados relacionais tradicionais não são otimizados para lidar com grandes volumes de dados vetoriais. Por isso, muitos bancos de dados de vetores exclusivos de código aberto e proprietários surgiram nos últimos anos. No entanto, talvez não seja ideal para todas as empresas ter um banco de dados dedicado apenas a vetores, separado do banco de dados principal.

Você pode usar o pgvector, uma extensão avançada para o PostgreSQL que traz recursos de pesquisa de similaridade vetorial para um dos bancos de dados relacionais mais populares. 

Neste tutorial, exploraremos os recursos do pgvector e demonstraremos como ele pode ajudar você em seu trabalho.

O que é o pgvector?

O pgvector é uma extensão de código aberto para o PostgreSQL que adiciona suporte a operações vetoriais e pesquisas de similaridade. Ele permite que você armazene, indexe e consulte dados vetoriais diretamente no seu banco de dados PostgreSQL. 

Essa integração traz o poder das operações vetoriais para a infraestrutura existente do PostgreSQL, tornando-o uma excelente opção para aplicativos que envolvem embeddings, sistemas de recomendação e pesquisas de similaridade.

Os recursos do pgvector incluem:

• Armazenamento eficiente de dados vetoriais densos
• Pesquisa rápida de similaridade usando várias métricas de distância
• Integração com o planejador de consultas e os mecanismos de indexação existentes do PostgreSQL
• Suporte para pesquisas exatas e aproximadas de vizinhos mais próximos

A importância dos bancos de dados vetoriais

Os bancos de dados vetoriais são bancos de dados especializados projetados para armazenar e consultar dados vetoriais multidimensionais. Esse recurso é relevante em aplicativos modernos de machine learning, incluindo sistemas de recomendação, recuperação de imagens e casos de uso de processamento de linguagem natural.

Os vetores precisam de um novo tipo de fonte de imagem de banco de dados.

Os bancos de dados relacionais tradicionais têm dificuldades para lidar com dados de alta dimensão e realizar pesquisas de similaridade com eficiência. No entanto, os bancos de dados vetoriais são otimizados especificamente para essas tarefas, permitindo a recuperação rápida e precisa de dados com base na proximidade ou semelhança de vetores. 

Essa abordagem permite pesquisas com base na relevância semântica ou contextual, fornecendo resultados mais significativos em comparação com as pesquisas de correspondência exata dos bancos de dados convencionais.

Por exemplo, um banco de dados vetorial pode:

• Pesquise músicas que se identifiquem com uma determinada melodia com base na melodia e no ritmo.
• Descubra artigos que se alinham com outro artigo específico em termos de tema e perspectiva.
• Identifique os gadgets que refletem as características e as análises de um determinado dispositivo.

Então, como os dados não estruturados, como texto ou imagens, podem ser convertidos em números? A resposta é embeddings.

A incorporação é um processo que transforma dados não estruturados em vetores numéricos de tamanho fixo, capturando a semântica e os relacionamentos inerentes aos dados. Isso é obtido por meio de grandes redes neurais que aprendem a representar os dados em um espaço vetorial contínuo, no qual itens semelhantes são posicionados mais próximos uns dos outros.

Como funciona um banco de dados vetorial? Fonte da imagem.

Tutorial passo a passo do pgvector

Neste tutorial, você verá como configurar o pgvector, usar seus recursos básicos e criar um aplicativo simples, integrando-o ao OpenAI.

Abordaremos a instalação, as operações básicas, a indexação e a integração com Python e LangChain.

1. Pré-requisitos

Para seguir este tutorial, você deve ter conhecimentos básicos de SQL e PostgreSQL e estar familiarizado com a programação em Python.

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

• PostgreSQL 11 ou posterior instalado em seu sistema
• Python 3.7 ou posterior (para a seção de integração)
• Uma chave de API da OpenAI (para o aplicativo de pesquisa semântica)

2. Como instalar o pgvector

1. Primeiro, verifique se você tem os arquivos de desenvolvimento do PostgreSQL instalados. No Ubuntu ou no Debian, você pode instalá-los com:

sudo apt-get install postgresql-server-dev-all

Se você for um usuário do Windows, poderá fazer o download do instalador do PostgreSQL no site oficial.

2. Clone o repositório do GitHub do pgvector:

git clone https://github.com/pgvector/pgvector.git

3. Crie e instale a extensão pgvector:

cd pgvector
make
sudo make install

Se você for um usuário do Windows, certifique-se de ter instalado o suporte a C++ no Visual Studio Code. A documentação oficial de instalação fornece um processo passo a passo.

4. Conecte-se ao seu banco de dados PostgreSQL:

Você tem várias opções para se conectar e interagir com o banco de dados PostgreSQL: o pgAdmin é uma das interfaces mais comumente usadas. Como alternativa, você pode usar o pSQL (interface de linha de comando do PostgreSQL) ou até mesmo uma extensão do VS Code para o PostgreSQL.

5. Depois de se conectar ao banco de dados PostgreSQL, crie a extensão:

CREATE EXTENSION vector;

Interface do pgAdmin

3. Uso básico do pgvector

Agora que temos o pgvector instalado, vamos explorar seu uso básico.

1. Para configurar nosso primeiro banco de dados vetorial no PostgreSQL usando a extensão pgvector, vamos criar uma tabela para armazenar nossos dados vetoriais:

CREATE TABLE items (
  id SERIAL PRIMARY KEY,
  embedding vector(3)
);

Isso cria uma tabela chamada items com uma coluna id e uma coluna embedding do tipo vector(3), que armazenará vetores tridimensionais.

2. Agora, vamos inserir alguns dados em nossa tabela:

INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]'), ('[1,1,1]');

3. Agora, podemos realizar operações vetoriais. Por exemplo, para encontrar o vizinho mais próximo do vetor [2,3,4]:

SELECT * FROM items ORDER BY embedding <-> '[2,3,4]' LIMIT 1;

Essa consulta usa o operador <->, que calcula a distância euclidiana entre os vetores.

4. Também podemos usar outras métricas de distância, como a distância cosseno:

SELECT * FROM items ORDER BY embedding <=> '[2,3,4]' LIMIT 1;

O operador <=> calcula a distância de cosseno entre os vetores.

4. Indexação de dados vetoriais com pgvector

A indexação em bancos de dados vetoriais, incluindo o pgvector, é necessária para melhorar o desempenho da pesquisa, principalmente à medida que o conjunto de dados se expande.

A importância da indexação não pode ser exagerada, pois ela oferece vários benefícios:

• Primeiro, ele aumenta significativamente a velocidade. Sem um índice, cada pesquisa de similaridade exigiria uma varredura completa na tabela, comparando o vetor de consulta com cada vetor no banco de dados. Esse processo se torna cada vez mais demorado à medida que seus dados aumentam. Os índices criam uma estrutura que permite pesquisas muito mais rápidas. 
• Em segundo lugar, a indexação aumenta a escalabilidade, permitindo que seu banco de dados gerencie conjuntos de dados maiores com eficiência. À medida que você continua a adicionar mais vetores, as pesquisas devidamente indexadas mantêm seu desempenho. 
• Por fim, a indexação contribui para a eficiência dos recursos, reduzindo a carga da CPU e de E/S durante as pesquisas. Isso é especialmente importante para sistemas ocupados ou que operam com recursos limitados, garantindo uma operação tranquila mesmo em condições exigentes.

Há dois tipos de índices disponíveis para o pgvector: ivfflat e hnsw. Ambos têm finalidades diferentes:

• Índice IVFFlat (Inverted File Flat):
• Adequado para pesquisas exatas de vizinhos mais próximos
• Divide o espaço vetorial em clusters, acelerando as pesquisas ao identificar primeiro os clusters relevantes
• Bom equilíbrio entre velocidade e precisão da pesquisa

• Índice HNSW (Hierarchical Navigable Small World):
• Projetado para pesquisas aproximadas do vizinho mais próximo
• Cria uma estrutura de gráfico para uma navegação rápida entre vetores
• Extremamente rápido, mas pode ocasionalmente perder o vizinho mais próximo absoluto

Quando você deve usar cada índice:

• Use o IVFFlat quando você precisar de resultados exatos e puder tolerar pesquisas um pouco mais lentas
• Use o HNSW quando você precisar de pesquisas rápidas e puder aceitar pequenas imprecisões

1. Vamos criar um índice ivfflat:

CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

Isso cria um índice usando o algoritmo IVFFlat, que é adequado para pesquisas exatas do vizinho mais próximo.

2. Para pesquisas aproximadas de vizinhos mais próximos, podemos usar o índice hnsw:

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);

Depois de criar um índice, nossas consultas o usarão automaticamente quando for apropriado.

5. integração do pgvector com outras ferramentas

O Pgvector oferece suporte à integração com algumas estruturas, o que facilita a interação com nosso banco de dados de vetores. Vamos analisar duas úteis: Python e LangChain.

Usando o pgvector com Python

O pgvector pode ser facilmente integrado ao Python usando a biblioteca psycopg2. Vamos configurar um ambiente Python e realizar algumas operações básicas.

1. Primeiro, instale as bibliotecas necessárias:

!pip install psycopg2-binary numpy

2. Agora, vamos criar um script Python para interagir com nosso banco de dados de vetores:

import psycopg2
import numpy as np

# Connect to the database
conn = psycopg2.connect("dbname=your_database user=your_username")
cur = conn.cursor()

# Insert a vector
embedding = np.array([1.5, 2.5, 3.5])
cur.execute("INSERT INTO items (embedding) VALUES (%s)", (embedding.tolist(),))

# Perform a similarity search
query_vector = np.array([2, 3, 4])
cur.execute("SELECT * FROM items ORDER BY embedding <-> %s LIMIT 1", (query_vector.tolist(),))
result = cur.fetchone()
print(f"Nearest neighbor: {result}")

conn.commit()
cur.close()
conn.close()

Esse script demonstra como você pode inserir um vetor e realizar uma pesquisa de similaridade usando Python.

Usando pgvector com LangChain

O pgvector também pode ser integrado ao LangChain, uma estrutura popular para o desenvolvimento de aplicativos com grandes modelos de linguagem. 

Aqui está um exemplo simples de como usar o pgvector como um armazenamento de vetores no LangChain:

from langchain_postgres.vectorstores import PGVector
from langchain.embeddings.openai import OpenAIEmbeddings

# Set up the connection string and embedding function
connection_string = "postgresql://user:pass@localhost:5432/db_name"
embedding_function = OpenAIEmbeddings()

# Create a PGVector instance
vector_store = PGVector.from_documents(
    documents,
    embedding_function,
    connection_string=connection_string
)

# Perform a similarity search
query = "Your query here"
results = vector_store.similarity_search(query)

Este exemplo pressupõe que você tenha configurado os embeddings do OpenAI e tenha uma lista de documentos para incorporar.

6. Criando um aplicativo de amostra com pgvector e OpenAI

Agora, vamos criar um mecanismo de pesquisa semântica simples usando o pgvector e as incorporações do OpenAI!

Esse aplicativo permitirá que os usuários pesquisem em uma coleção de documentos de texto usando consultas de linguagem natural.

import openai
import psycopg2
import numpy as np

# Set up OpenAI API (replace with your actual API key)
openai.api_key = "your_openai_api_key"

# Connect to the database
conn = psycopg2.connect("dbname=your_database user=your_username")
cur = conn.cursor()

# Create a table for our documents
cur.execute("""
    CREATE TABLE IF NOT EXISTS documents (
        id SERIAL PRIMARY KEY,
        content TEXT,
        embedding vector(1536)
    )
""")

# Function to get embeddings from OpenAI
def get_embedding(text):
    response = openai.embeddings.create(input=text, model="text-embedding-ada-002")
    return response['data'][0]['embedding']

# Function to add a document
def add_document(content):
    embedding = get_embedding(content)
    cur.execute("INSERT INTO documents (content, embedding) VALUES (%s, %s)", (content, embedding))
    conn.commit()

# Function to search for similar documents
def search_documents(query, limit=5):
    query_embedding = get_embedding(query)
    cur.execute("""
        SELECT content, embedding <-> %s AS distance
        FROM documents
        ORDER BY distance
        LIMIT %s
    """, (query_embedding, limit))
    return cur.fetchall()

# Add some sample documents
sample_docs = [
    "The quick brown fox jumps over the lazy dog.",
    "Python is a high-level programming language.",
    "Vector databases are essential for modern AI applications.",
    "PostgreSQL is a powerful open-source relational database.",
]
for doc in sample_docs:
    add_document(doc)

# Perform a search
search_query = "Tell me about programming languages"
results = search_documents(search_query)
print(f"Search results for: '{search_query}'")
for i, (content, distance) in enumerate(results, 1):
    print(f"{i}. {content} (Distance: {distance:.4f})")

# Clean up
cur.close()
conn.close()

Este aplicativo simples demonstra como você pode usar o pgvector para criar um mecanismo de pesquisa semântica.

Ele incorpora documentos usando o modelo de incorporação de texto da OpenAI e os armazena em um banco de dados PostgreSQL com pgvector. A função de pesquisa encontra os documentos mais semelhantes a uma determinada consulta usando a similaridade de cosseno.

Análise comparativa do pgvector

Vamos comparar o pgvector com outros bancos de dados vetoriais populares. Essa comparação ajudará você a entender as diferenças de recursos, opções de implantação, escalabilidade, integração e custo entre o pgvector e outras soluções disponíveis no mercado.

pgvector versus Pinecone

O Pinecone é um banco de dados vetorial totalmente gerenciado, projetado para alta escalabilidade e facilidade de uso.

O pgvector é uma excelente opção para quem deseja aproveitar a infraestrutura existente do PostgreSQL sem custos adicionais. Ao mesmo tempo, a Pinecone oferece uma solução gerenciada e altamente dimensionável com preços de pagamento conforme o uso para facilitar a utilização.

pgvector versus Milvus

O Milvus é um banco de dados vetorial dedicado que oferece recursos avançados e alta escalabilidade.

Embora o pgvector forneça operações vetoriais básicas no ambiente familiar do PostgreSQL, o Milvus oferece uma solução mais rica em recursos e dimensionável, especificamente para lidar com dados vetoriais em grande escala.

pgvector versus Weaviate

O Weaviate é um banco de dados vetorial com armazenamento de objetos integrado, que oferece modelagem de dados flexível e escalabilidade.

A simplicidade e a integração do pgvector com o PostgreSQL fazem dele uma boa opção para usuários existentes que precisam de funcionalidades vetoriais básicas. Em contrapartida, o modelo de dados mais sofisticado e a escalabilidade da Weaviate são adequados para aplicativos complexos que exigem armazenamento de objetos juntamente com vetores.

Conclusão

O pgvector traz poderosos recursos de pesquisa de similaridade vetorial para o PostgreSQL, tornando-o uma excelente opção para desenvolvedores que desejam adicionar recursos alimentados por IA a seus aplicativos existentes baseados no PostgreSQL. 

Neste tutorial, exploramos sua instalação, uso básico, recursos de indexação e integração com Python e LangChain.

Embora o pgvector possa não oferecer a mesma escalabilidade e recursos especializados que os bancos de dados vetoriais dedicados, como o Pinecone ou o Milvus, sua integração perfeita com o PostgreSQL o torna uma opção atraente para muitos casos de uso. 

Ele é particularmente adequado para projetos que já usam o PostgreSQL e precisam adicionar recursos de pesquisa vetorial sem introduzir um novo sistema de banco de dados.

Recomendamos que você experimente o pgvector em seus próprios projetos. Se você estiver criando um sistema de recomendação, um mecanismo de pesquisa semântica ou qualquer outro aplicativo que exija pesquisas de similaridade, o pgvector pode ser uma ferramenta valiosa no seu kit de ferramentas de ciência de dados.

Para aprender mais, considere explorar esses cursos gratuitos do DataCamp:

• Criação de bancos de dados PostgreSQL
• Desenvolvimento de aplicativos LLM com LangChain
• Introdução aos embeddings com a API OpenAI

Esses cursos ajudarão você a aprofundar seu conhecimento sobre bancos de dados e aplicativos modernos de LLM.