0Pricing
AI Engineering Academy · Lezione

Scegliere e valutare i vector store

Confronterà Pinecone, pgvector, Chroma, Weaviate e Qdrant in termini di costo, latenza, capacità di filtraggio e complessità operativa, per scegliere lo strumento adatto al proprio caso d'uso.

Scegliere e valutare i vector store è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.

Panoramica dei vector store

L'ecosistema dei database vettoriali è cresciuto enormemente negli ultimi anni. Le opzioni spaziano da servizi cloud specifici come Pinecone a estensioni PostgreSQL come pgvector, server open source come Chroma, Qdrant e Weaviate, fino a librerie in memoria come FAISS. Scegliere lo strumento giusto è importante, perché cambiare in seguito è costoso una volta indicizzati i dati.

Dimensioni chiave da valutare

Quando confronta i vector store, valuti cinque dimensioni: latenza delle query alla scala prevista, throughput di indicizzazione per l'acquisizione in batch, funzionalità di filtraggio per il pre-filtraggio basato sui metadati, complessità operativa (gestito o self-hosted) e costo per milione di vettori memorizzati e sottoposti a query. Nessuno strumento eccelle in ogni dimensione.

Pinecone: semplicità del servizio gestito

Pinecone è un database vettoriale cloud completamente gestito che non richiede alcuna gestione dell'infrastruttura. Eccelle nei carichi di lavoro ad alta concorrenza, offre una ricerca ibrida sparse-dense nativa e garantisce query costanti nell'ordine di pochi millisecondi a qualsiasi scala. Il compromesso è il costo: è più costoso delle opzioni self-hosted e comporta il vincolo verso il fornitore, poiché tutti i dati risiedono nel cloud di Pinecone.

import pinecone

pc = pinecone.Pinecone(api_key='YOUR_API_KEY')
index = pc.Index('my-index')

# Query with metadata filter
results = index.query(
    vector=[0.1, 0.2, 0.3],
    top_k=10,
    filter={'category': {'$eq': 'finance'}},
    include_metadata=True
)

pgvector: embedding in PostgreSQL

pgvector estende PostgreSQL con un tipo di dati vector e indici ANN (approximate nearest neighbor) basati sugli algoritmi HNSW o IVFFlat. È ideale se utilizza già PostgreSQL, perché gli embedding risiedono nello stesso database dei dati relazionali, consentendo potenti join SQL tra la ricerca vettoriale e i filtri strutturati senza infrastruttura aggiuntiva.

-- Create table with embedding column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    category TEXT,
    embedding vector(1536)
);

-- Create HNSW index for fast ANN search
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Query nearest neighbors with SQL filter
SELECT content, 1 - (embedding <=> '[0.1,0.2,...]')
FROM documents
WHERE category = 'finance'
ORDER BY embedding <=> '[0.1,0.2,...]'
LIMIT 10;

Chroma: locale e intuitivo per gli sviluppatori

Chroma è un database di embedding open source progettato per la prototipazione rapida. Per lo sviluppo locale viene eseguito in-process (senza bisogno di un server) e supporta una modalità server persistente per la produzione. Chroma è popolare nei tutorial di LangChain grazie alla sua API estremamente semplice, ma presenta limitazioni su larga scala: non dispone di una modalità distribuita e offre filtri meno avanzati rispetto a Pinecone o Qdrant.

import chromadb

client = chromadb.PersistentClient(path='./chroma_db')
collection = client.get_or_create_collection('my_docs')

# Add documents
collection.add(
    documents=['text one', 'text two'],
    metadatas=[{'source': 'doc1'}, {'source': 'doc2'}],
    ids=['id1', 'id2']
)

# Query
results = collection.query(
    query_texts=['search query'],
    n_results=5
)

Qdrant: filtraggio e ricerca nei payload

Qdrant è un database vettoriale open source scritto in Rust, particolarmente efficace nel filtraggio complesso dei metadati. A differenza dei database che applicano i filtri dopo la ricerca ANN, Qdrant esegue il pre-filtraggio dei vettori candidati in base ai campi del payload prima del calcolo dei punteggi, migliorando notevolmente la precisione quando i filtri sono selettivi. Supporta indici HNSW su disco, risultando adatto a dataset che non possono essere contenuti nella RAM.

from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue

client = QdrantClient(url='http://localhost:6333')

# Search with payload filter
results = client.search(
    collection_name='documents',
    query_vector=[0.1, 0.2, 0.3],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='category',
                match=MatchValue(value='finance')
            )
        ]
    ),
    limit=10
)

Weaviate: GraphQL e multimodalità

Weaviate è un database vettoriale open source con un'esclusiva API GraphQL e supporto integrato per oggetti multimodali (testo, immagini, audio). Si integra direttamente con i provider di modelli di embedding tramite moduli, consentendo di acquisire testo grezzo e lasciare che Weaviate chiami automaticamente l'API di embedding. Questa comodità comporta una configurazione più complessa rispetto a Chroma o Qdrant.

import weaviate

client = weaviate.Client('http://localhost:8080')

# Near-text search using built-in vectorizer
result = client.query.get(
    'Document', ['content', 'category']
).with_near_text(
    {'concepts': ['financial analysis']}
).with_where({
    'path': ['category'],
    'operator': 'Equal',
    'valueString': 'finance'
}).with_limit(10).do()

FAISS: in memoria su larga scala

FAISS (Facebook AI Similarity Search) è una libreria C++ con binding Python che offre una ricerca vettoriale in memoria estremamente veloce. Non è un database (non offre persistenza né un server), ma gestisce ricerche di similarità su scala di miliardi di elementi su una singola macchina con accelerazione GPU. FAISS è la scelta giusta per carichi di lavoro di ricerca batch offline, intensivi in lettura, in cui si controlla l'intero stack.

import faiss
import numpy as np

dimension = 1536
vectors = np.random.random((100000, dimension)).astype('float32')

# Normalize for cosine similarity
faiss.normalize_L2(vectors)

# Build HNSW index
index = faiss.IndexHNSWFlat(dimension, 32)  # M=32 neighbors
index.add(vectors)

# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
D, I = index.search(query, k=10)  # top-10 results

Creazione di un test di benchmark

L'unico modo per scegliere con sicurezza è eseguire benchmark sui propri dati. Un buon benchmark misura: (1) il tempo di indicizzazione dell'intero dataset, (2) la latenza delle query ai percentili p50, p95 e p99 sotto carico concorrente, (3) il recall@K, confrontando i risultati ANN con risultati esatti ottenuti tramite ricerca esaustiva, e (4) memoria e costi alla scala prevista. Esegua le stesse query su ogni vector store candidato.

import time
import numpy as np

def benchmark_store(store, queries, k=10):
    latencies = []
    for q in queries:
        start = time.perf_counter()
        store.search(q, k)
        latencies.append(time.perf_counter() - start)
    latencies.sort()
    n = len(latencies)
    print(f'p50: {latencies[n//2]*1000:.1f}ms')
    print(f'p95: {latencies[int(n*0.95)]*1000:.1f}ms')
    print(f'p99: {latencies[int(n*0.99)]*1000:.1f}ms')

Misurazione del compromesso tra recall e latenza

Gli indici ANN scambiano recall con velocità. Un parametro HNSW ef_search più alto individua vicini più accurati, ma richiede più tempo. Misuri il recall@10 (la frazione dei 10 vicini reali restituiti) con diverse configurazioni dei parametri e rappresenti graficamente recall e latenza. La maggior parte dei sistemi di produzione punta a un recall del 95-99%. Scendere sotto il 90% significa che gli utenti ricevono chunk non pertinenti anche se le query sono veloci.

def compute_recall(approx_ids, exact_ids):
    '''Compute recall@K for one query'''
    return len(set(approx_ids) & set(exact_ids)) / len(exact_ids)

def benchmark_recall(index, brute_force, queries, k=10):
    recalls = []
    for q in queries:
        approx = index.search(q, k)
        exact = brute_force.search(q, k)
        recalls.append(compute_recall(approx, exact))
    print(f'Mean recall@{k}: {sum(recalls)/len(recalls):.3f}')

Metodo decisionale per la scelta

Utilizzi questo albero decisionale: se ha bisogno di zero gestione dell'infrastruttura e il budget non è un vincolo, scelga Pinecone. Se utilizza già PostgreSQL e il dataset contiene meno di 10 milioni di vettori, aggiunga pgvector. Per una soluzione open source self-hosted con filtraggio complesso dei payload, scelga Qdrant. Per la prototipazione rapida e lo sviluppo locale, inizi con Chroma e proceda alla migrazione in seguito. Per i job batch offline su scala di miliardi di elementi, utilizzi FAISS.

Verifica rapida

Verifichi la propria comprensione dei concetti di AI Engineering trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato a conoscere: il panorama dei vector store, tra cui Pinecone, pgvector, Chroma, Qdrant, Weaviate e FAISS; le cinque dimensioni di valutazione, ovvero latenza, throughput, filtraggio, complessità e costo; e un metodo decisionale pratico per scegliere il vector store più adatto in base ai requisiti di infrastruttura e scala. Nella prossima lezione analizzeremo il problema che ha portato all'invenzione di RAG.

Domande Frequenti

La lezione «Scegliere e valutare i vector store» è gratuita?

Sì — il testo completo di «Scegliere e valutare i vector store» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.

Cosa imparerò in «Scegliere e valutare i vector store»?

Confronterà Pinecone, pgvector, Chroma, Weaviate e Qdrant in termini di costo, latenza, capacità di filtraggio e complessità operativa, per scegliere lo strumento adatto al proprio caso d'uso. Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Engineering Academy?

Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Scegliere e valutare i vector store»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?

Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Perché serve un database vettoriale
  2. Iniziare con Pinecone
  3. pgvector: embeddings in PostgreSQL
  4. Scegliere e valutare i vector store
← Torna a AI Engineering Academy