FAISS

import faiss
import numpy as np

# Generate sample vectors (1M vectors, 768 dimensions)
d = 768  # dimension
nb = 1000000  # database size
np.random.seed(1234)
xb = np.random.random((nb, d)).astype('float32')
xb[:, 0] += np.arange(nb) / 1000.

# Build index
index = faiss.IndexFlatL2(d)   # L2 distance
print(index.is_trained)       # True for Flat index

# Add vectors to index
index.add(xb)
print(index.ntotal)           # 1000000

# Search
k = 4  # top-k results
xq = np.random.random((5, d)).astype('float32')
D, I = index.search(xq, k)    # distances, indices
print(I[:5])                  # neighbors of first 5 queries

import faiss

# Create IVF index
d = 768
nlist = 1024  # number of clusters
quantizer = faiss.IndexFlatL2(d)
index = faiss.IndexIVFFlat(quantizer, d, nlist, faiss.METRIC_L2)

# Train the index (clustering)
print(index.is_trained)  # False - needs training
index.train(xb)
print(index.is_trained)  # True after training

# Add vectors
index.add(xb)

# Search with different nprobe values
for nprobe in [1, 10, 100]:
    index.nprobe = nprobe
    start = time.time()
    D, I = index.search(xq, k)
    elapsed = time.time() - start
    
    # Evaluate accuracy against ground truth
    accuracy = evaluate_recall(I, ground_truth)
    print(f"nprobe={nprobe}, time={elapsed:.3f}s, recall@{k}={accuracy:.3f}")

# Output example:
# nprobe=1, time=0.002s, recall@10=0.621
# nprobe=10, time=0.011s, recall@10=0.952  
# nprobe=100, time=0.087s, recall@10=0.991

import faiss
from flask import Flask, request, jsonify
import numpy as np
import pickle
from concurrent.futures import ThreadPoolExecutor

class FAISSService:
    def __init__(self, index_paths, shard_config):
        self.shards = []
        self.executor = ThreadPoolExecutor(max_workers=8)
        
        # Load multiple index shards
        for path in index_paths:
            index = faiss.read_index(path)
            if hasattr(index, 'nprobe'):
                index.nprobe = shard_config.get('nprobe', 32)
            self.shards.append(index)
    
    def search_shard(self, shard_idx, query_vectors, k):
        """Search single shard"""
        index = self.shards[shard_idx]
        distances, indices = index.search(query_vectors, k)
        
        # Adjust indices for global IDs
        global_indices = indices + shard_idx * self.shard_size
        return distances, global_indices
    
    def search(self, query_vectors, k=10):
        """Parallel search across all shards"""
        futures = []
        
        # Submit search tasks for each shard
        for i, shard in enumerate(self.shards):
            future = self.executor.submit(
                self.search_shard, i, query_vectors, k
            )
            futures.append(future)
        
        # Collect results from all shards
        all_distances, all_indices = [], []
        for future in futures:
            distances, indices = future.result()
            all_distances.append(distances)
            all_indices.append(indices)
        
        # Merge and re-rank top-k results
        return self.merge_results(all_distances, all_indices, k)
    
    def merge_results(self, distances_list, indices_list, k):
        """Merge results from multiple shards"""
        batch_size = distances_list[0].shape[0]
        merged_distances = np.zeros((batch_size, k))
        merged_indices = np.zeros((batch_size, k), dtype=np.int64)
        
        for i in range(batch_size):
            # Collect all candidates from all shards
            candidates = []
            for shard_distances, shard_indices in zip(distances_list, indices_list):
                for j in range(k):
                    candidates.append((shard_distances[i,j], shard_indices[i,j]))
            
            # Sort and take top-k
            candidates.sort(key=lambda x: x[0])
            for j in range(k):
                merged_distances[i,j] = candidates[j][0]
                merged_indices[i,j] = candidates[j][1]
        
        return merged_distances, merged_indices

# Flask API wrapper
app = Flask(__name__)
faiss_service = FAISSService(
    index_paths=['shard_0.index', 'shard_1.index'], 
    shard_config={'nprobe': 32}
)

@app.route('/search', methods=['POST'])
def search():
    data = request.json
    query_vectors = np.array(data['vectors'], dtype=np.float32)
    k = data.get('k', 10)
    
    distances, indices = faiss_service.search(query_vectors, k)
    
    return jsonify({
        'distances': distances.tolist(),
        'indices': indices.tolist()
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)