Salt la conținutul principal
Română— Alege o limbă
Meniu

Vector Store cu FAISS

Lecția 12 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. FAISS: Căutare vectorială de înaltă performanță
  2. Crearea primului index
  3. Alegerea tipului de index potrivit
  4. Interogarea indexului
  5. Trecerea la similaritatea cosinus
  6. Când corpusul devine masiv
  7. Puncte cheie

FAISS: Căutare vectorială de înaltă performanță

Ați calculat și salvat embedding-urile, dar o matrice NumPy nu este un motor de căutare: compararea unei interogări cu 100.000 de vectori folosind o buclă Python ar dura câteva secunde per întrebare. FAISS (Facebook AI Similarity Search) rezolvă exact această problemă. Această bibliotecă open-source de la Meta este concepută pentru căutarea similarității în seturi mari de vectori; este rapidă, eficientă din punct de vedere al memoriei și funcționează la fel de bine cu câteva sute de vectori ca și cu milioane. Instalarea necesită o singură comandă. faiss-cpu este suficient în marea majoritate a cazurilor; faiss-gpu se justifică doar pentru volume unde calculul devine gâtul de sticlă.

# pip install faiss-cpu
# or faiss-gpu for GPU acceleration

import faiss
import numpy as np

Crearea primului index

Cel mai simplu index este IndexFlatL2, care efectuează o căutare exhaustivă folosind distanța L2 (Euclidiană). „Exhaustiv“ înseamnă că compară efectiv interogarea cu fiecare vector stocat: fără aproximări, deci fără rezultate ratate. Îl inițializați cu dimensiunea vectorului—1024 pentru mistral-embed, o valoare pe care o citiți direct din forma matricei, în loc să o codificați rigid. Conversia la float32 nu este opțională: FAISS respinge float64 pe care NumPy îl produce implicit, iar uitarea acestui detaliu este prima eroare pe care o întâlnește orice începător.

# Assume our embeddings are a NumPy matrix
# embeddings.shape = (n_chunks, 1024)

# Create the index
dimension = embeddings.shape[1]  # 1024 for mistral-embed
index = faiss.IndexFlatL2(dimension)

# Add the vectors
index.add(embeddings.astype(np.float32))  # FAISS requires float32

print(f"Index created: {index.ntotal} vectors of dimension {dimension}")

Alegerea tipului de index potrivit

FAISS nu oferă un singur index, ci o familie întreagă, iar alegerea implică un compromis între acuratețe și viteză. Primele două, IndexFlatL2 și IndexFlatIP, sunt exacte: diferă doar prin metrica utilizată, distanța euclidiană pentru unul, produsul scalar pentru celălalt. IndexIVFFlat schimbă logica prin partiționarea spațiului în clustere și căutarea doar în cele mai promițătoare, ceea ce accelerează semnificativ căutarea în detrimentul unei ușoare pierderi de recall—și necesită antrenament prealabil pe datele dumneavoastră. În final, IndexHNSWFlat construiește un graf al vecinilor și se dovedește foarte rapid în timpul interogărilor, parametrul 32 stabilind aici numărul de vecini reținuți per nod.

dimension = 1024

# 1. IndexFlatL2: Exact search, L2 distance
# Most accurate, but slowest for large volumes
index_flat_l2 = faiss.IndexFlatL2(dimension)

# 2. IndexFlatIP: Exact search, dot product (inner product)
# Use with normalized vectors for cosine similarity
index_flat_ip = faiss.IndexFlatIP(dimension)

# 3. IndexIVFFlat: Approximate search with partitioning
# Faster for large volumes, slight loss of accuracy
nlist = 100  # Number of partitions (clusters)
quantizer = faiss.IndexFlatL2(dimension)
index_ivf = faiss.IndexIVFFlat(quantizer, dimension, nlist)
# Requires training before use:
# index_ivf.train(embeddings)
# index_ivf.add(embeddings)

# 4. IndexHNSWFlat: Neighbor graph (very fast search)
index_hnsw = faiss.IndexHNSWFlat(dimension, 32)  # 32 = number of neighbors

Interogarea indexului

Căutarea se desfășoară în trei pași. Mai întâi, codificați întrebarea utilizatorului cu același model ca și corpusul—o interogare codificată de un model diferit ar genera distanțe fără sens. FAISS returnează apoi două tablouri paralele: distanțele și indicii celor k cei mai apropiați vecini. Acești indici reprezintă poziții în lista dumneavoastră de chunk-uri: aici își arată utilitatea disciplina din lecția anterioară, deoarece alinierea dintre matrice și metadate este cea care vă permite să reveniți la text și la sursa sa. Testul if idx >= 0 acoperă cazul în care indexul conține mai puțin de k vectori, situație în care FAISS completează locurile lipsă cu -1.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def search_index(query, index, chunks, k=5):
    """Search for chunks closest to a query."""
    # 1. Encode the query
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[query],
    )
    query_vector = np.array([response.data[0].embedding], dtype=np.float32)

    # 2. Search in FAISS
    distances, indices = index.search(query_vector, k)

    # 3. Format results
    results = []
    for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
        if idx >= 0:  # FAISS returns -1 if not enough results
            results.append({
                "rank": i + 1,
                "distance": float(dist),
                "text": chunks[idx]["text"],
                "source": chunks[idx].get("source", ""),
            })

    return results

# Example search
results = search_index("How does RAG work?", index, chunks)
for r in results:
    print(f"  #{r['rank']} (dist: {r['distance']:.4f}) [{r['source']}]")
    print(f"    {r['text'][:100]}...")

Trecerea la similaritatea cosinus

FAISS nu oferă un index „cosinus“ explicit, dar algebra furnizează un echivalent gratuit: pentru vectorii cu norma 1, produsul scalar este cosinusul. Pur și simplu divideți fiecare vector la norma sa, apoi utilizați IndexFlatIP. Această schimbare este departe de a fi teoretică: distanța L2 este sensibilă la lungimea vectorului, astfel încât un chunk foarte lung poate ajunge artificial departe de o interogare scurtă, chiar dacă subiectele lor coincid. Cosinusul măsoară doar orientarea, deci sensul, și asta este ceea ce doriți, în general, să comparați.

def create_cosine_index(embeddings):
    """Create a FAISS index with cosine similarity."""
    # Normalize vectors (L2 norm = 1)
    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
    normalized = (embeddings / norms).astype(np.float32)

    # Use IndexFlatIP (dot product = cosine for normalized vectors)
    dimension = normalized.shape[1]
    index = faiss.IndexFlatIP(dimension)
    index.add(normalized)

    return index

cosine_index = create_cosine_index(embeddings)

La fel ca în cazul embedding-urilor, indexul persistă pe disc. faiss.write_index produce un fișier binar pe care faiss.read_index îl reîncarcă întocmai, inclusiv structurile interne—ceea ce contează cel mai mult pentru indexurile antrenate, unde reconstrucția ar trebui altfel refăcută.

# Save
faiss.write_index(index, "rag_faiss.index")
print("FAISS index saved")

# Load
index_loaded = faiss.read_index("rag_faiss.index")
print(f"Index loaded: {index_loaded.ntotal} vectors")

Când corpusul devine masiv

Începând de la câteva sute de mii de vectori, căutarea exhaustivă devine prea lentă, iar indexul IVF (Inverted File) devine necesar. Ciclul său de viață include un pas pe care indexurile plate nu îl au: antrenamentul, care analizează distribuția datelor dumneavoastră pentru a plasa centroizii partițiilor nlist. Urmează adăugarea vectorilor, apoi reglarea lui nprobe, butonul care decide câte partiții vor fi explorate per interogare. Creșterea lui nprobe îmbunătățește recall-ul și încetinește căutarea; acesta este parametrul pe care îl veți ajusta măsurând, pe un set reprezentativ de întrebări, punctul în care rezultatele nu se mai îmbunătățesc.

def create_ivf_index(embeddings, nlist=100, nprobe=10):
    """Create an IVF index for large volumes."""
    dimension = embeddings.shape[1]
    data = embeddings.astype(np.float32)

    # Create the quantizer and IVF index
    quantizer = faiss.IndexFlatL2(dimension)
    index = faiss.IndexIVFFlat(quantizer, dimension, nlist)

    # Train the index (required for IVF)
    print("Training index...")
    index.train(data)

    # Add the vectors
    index.add(data)

    # Number of partitions to explore during search
    index.nprobe = nprobe  # Higher = more accurate, slower

    print(f"IVF index created: {index.ntotal} vectors, {nlist} partitions")
    return index

# For 100K+ vectors
# large_index = create_ivf_index(embeddings, nlist=256, nprobe=20)

Puncte cheie

  • FAISS este standardul pentru căutarea vectorială rapidă
  • IndexFlatL2 pentru corpusuri mici (sub 100K vectori), căutare exactă
  • IndexIVFFlat pentru corpusuri mari, căutare aproximativă dar rapidă
  • Normalizați vectorii și utilizați IndexFlatIP pentru similaritatea cosinus
  • Salvați indexul pe disc cu faiss.write_index pentru a evita reconstrucția