Batch querying and reporting

main.py

@@ -8,11 +8,18 @@ It supports both commercial APIs and open-source models.
 
 import json
 import asyncio
+from asyncio import Semaphore
 from pathlib import Path
 from typing import List, Dict, Any, Optional, Tuple
 from abc import ABC, abstractmethod
 import argparse
 import numpy as np
+import yaml
+import faiss
+import csv
+from datetime import datetime
+
+
 
 
 class EmbeddingProvider(ABC):
@@ -58,7 +65,34 @@ class OpenAIProvider(EmbeddingProvider):
     async def embed_batch(self, texts: List[str]) -> List[List[float]]:
         client = await self._get_client()
         response = await client.embeddings.create(input=texts, model=self.model_name)
+        # OpenAI embeddings are automatically normalized to unit length
         return [data.embedding for data in response.data]
+    
+    async def embed_queries_batch(self, queries: List[str], batch_size: int = 100) -> List[List[float]]:
+        """Efficiently embed multiple queries using OpenAI's batch API capability."""
+        all_embeddings = []
+        
+        # Process in batches to respect API limits
+        for i in range(0, len(queries), batch_size):
+            batch = queries[i:i + batch_size]
+            print(f"Embedding batch {i//batch_size + 1}/{(len(queries) + batch_size - 1)//batch_size} ({len(batch)} queries)")
+            
+            try:
+                batch_embeddings = await self.embed_batch(batch)
+                all_embeddings.extend(batch_embeddings)
+            except Exception as e:
+                print(f"Error in batch embedding: {e}")
+                # Fall back to individual embedding for this batch
+                for query in batch:
+                    try:
+                        embedding = await self.embed_text(query)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        print(f"Error embedding query '{query}': {e2}")
+                        # Add zero embedding as placeholder
+                        all_embeddings.append([0.0] * 1536)  # Default dimension for text-embedding models
+        
+        return all_embeddings
 
 
 class GeminiProvider(EmbeddingProvider):
@@ -86,7 +120,33 @@ class GeminiProvider(EmbeddingProvider):
     async def embed_batch(self, texts: List[str]) -> List[List[float]]:
         client = await self._get_client()
         result = client.embed_content(model=f"models/{self.model_name}", content=texts)
+        # Gemini embeddings are automatically normalized to unit length
         return [embedding["embedding"] for embedding in result["embedding"]]
+    
+    async def embed_queries_batch(self, queries: List[str], batch_size: int = 100) -> List[List[float]]:
+        """Efficiently embed multiple queries using Gemini's batch capability."""
+        all_embeddings = []
+        
+        for i in range(0, len(queries), batch_size):
+            batch = queries[i:i + batch_size]
+            print(f"Embedding batch {i//batch_size + 1}/{(len(queries) + batch_size - 1)//batch_size} ({len(batch)} queries)")
+            
+            try:
+                batch_embeddings = await self.embed_batch(batch)
+                all_embeddings.extend(batch_embeddings)
+            except Exception as e:
+                print(f"Error in batch embedding: {e}")
+                # Fall back to individual embedding for this batch
+                for query in batch:
+                    try:
+                        embedding = await self.embed_text(query)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        print(f"Error embedding query '{query}': {e2}")
+                        # Add zero embedding as placeholder
+                        all_embeddings.append([0.0] * 768)  # Default dimension for Gemini models
+        
+        return all_embeddings
 
 
 class VoyageProvider(EmbeddingProvider):
@@ -113,7 +173,33 @@ class VoyageProvider(EmbeddingProvider):
     async def embed_batch(self, texts: List[str]) -> List[List[float]]:
         client = await self._get_client()
         response = await client.embed(texts, model=self.model_name)
+        # Voyage AI embeddings are automatically normalized to unit length
         return response.embeddings
+    
+    async def embed_queries_batch(self, queries: List[str], batch_size: int = 100) -> List[List[float]]:
+        """Efficiently embed multiple queries using Voyage's batch capability."""
+        all_embeddings = []
+        
+        for i in range(0, len(queries), batch_size):
+            batch = queries[i:i + batch_size]
+            print(f"Embedding batch {i//batch_size + 1}/{(len(queries) + batch_size - 1)//batch_size} ({len(batch)} queries)")
+            
+            try:
+                batch_embeddings = await self.embed_batch(batch)
+                all_embeddings.extend(batch_embeddings)
+            except Exception as e:
+                print(f"Error in batch embedding: {e}")
+                # Fall back to individual embedding for this batch
+                for query in batch:
+                    try:
+                        embedding = await self.embed_text(query)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        print(f"Error embedding query '{query}': {e2}")
+                        # Add zero embedding as placeholder
+                        all_embeddings.append([0.0] * 1024)  # Default dimension for Voyage models
+        
+        return all_embeddings
 
 
 class HuggingFaceProvider(EmbeddingProvider):
@@ -147,8 +233,37 @@ class HuggingFaceProvider(EmbeddingProvider):
 
     async def embed_batch(self, texts: List[str]) -> List[List[float]]:
         model = await self._get_model()
-        embeddings = model.encode(texts)
+        # Use native normalization parameter for sentence-transformers
+        embeddings = model.encode(texts, normalize_embeddings=True)
         return [emb.tolist() for emb in embeddings]
+    
+    async def embed_queries_batch(self, queries: List[str], batch_size: int = 500) -> List[List[float]]:
+        """Efficiently embed multiple queries using HuggingFace's batch capability."""
+        all_embeddings = []
+        
+        # HuggingFace can handle larger batches efficiently since it's local
+        for i in range(0, len(queries), batch_size):
+            batch = queries[i:i + batch_size]
+            print(f"Embedding batch {i//batch_size + 1}/{(len(queries) + batch_size - 1)//batch_size} ({len(batch)} queries)")
+            
+            try:
+                batch_embeddings = await self.embed_batch(batch)
+                all_embeddings.extend(batch_embeddings)
+            except Exception as e:
+                print(f"Error in batch embedding: {e}")
+                # Fall back to individual embedding for this batch
+                for query in batch:
+                    try:
+                        embedding = await self.embed_text(query)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        print(f"Error embedding query '{query}': {e2}")
+                        # Add zero embedding as placeholder based on model
+                        model = await self._get_model()
+                        dim = getattr(model, 'get_sentence_embedding_dimension', lambda: 384)()
+                        all_embeddings.append([0.0] * dim)
+        
+        return all_embeddings
 
 
 class JinaProvider(EmbeddingProvider):
@@ -487,6 +602,67 @@ async def main():
     query_parser = subparsers.add_parser(
         "query", help="Search Bible verses using embeddings"
     )
+    query_parser.add_argument(
+        "--no-hnsw",
+        action="store_true",
+        help="Disable HNSW optimization and use brute-force search"
+    )
+    
+    # Batch subcommand
+    batch_parser = subparsers.add_parser(
+        "batch", help="Run batch queries from YAML file and evaluate results"
+    )
+    
+    # Report subcommand
+    report_parser = subparsers.add_parser(
+        "report", help="Generate markdown report from batch results CSV"
+    )
+    report_parser.add_argument(
+        "--results-file",
+        "-r",
+        default="results.csv",
+        help="CSV file to read results from (default: results.csv)"
+    )
+    report_parser.add_argument(
+        "--output-file",
+        "-o",
+        default="README.md",
+        help="Output markdown file (default: README.md)"
+    )
+    report_parser.add_argument(
+        "--max-queries",
+        "-q",
+        type=int,
+        default=10,
+        help="Maximum number of queries to show in detailed results (default: 10)"
+    )
+    
+    batch_parser.add_argument("--translation", "-t", help="Translation to use")
+    batch_parser.add_argument("--model", "-m", help="Model to use") 
+    batch_parser.add_argument(
+        "--queries-file", 
+        "-q", 
+        default="queries.yaml",
+        help="YAML file containing queries and expected results (default: queries.yaml)"
+    )
+    batch_parser.add_argument(
+        "--results-file",
+        "-r", 
+        default="results.csv",
+        help="CSV file to append results to (default: results.csv)"
+    )
+    batch_parser.add_argument(
+        "--concurrency",
+        "-c",
+        type=int,
+        default=5,
+        help="Number of concurrent queries to process (default: 5)"
+    )
+    batch_parser.add_argument(
+        "--no-hnsw",
+        action="store_true",
+        help="Disable HNSW optimization and use brute-force search"
+    )
 
     args = parser.parse_args()
 
@@ -496,7 +672,15 @@ async def main():
         return
 
     if args.command == "query":
-        await query_mode()
+        await query_mode(args)
+        return
+    
+    if args.command == "batch":
+        await batch_mode(args)
+        return
+    
+    if args.command == "report":
+        generate_report(args)
         return
 
     if args.command == "embed":
@@ -614,12 +798,98 @@ def cosine_similarity(a: List[float], b: List[float]) -> float:
     return dot_product / (norm_a * norm_b)
 
 
+class HNSWIndex:
+    """FAISS-based index for fast approximate nearest neighbor search."""
+    
+    def __init__(self, dimension: int, max_elements: int = 100000):
+        self.dimension = dimension
+        self.max_elements = max_elements
+        # Use FAISS HNSW index for cosine similarity (using inner product with normalized vectors)
+        self.index = faiss.IndexHNSWFlat(dimension, 32)  # 32 is M parameter
+        self.index.hnsw.efConstruction = 200
+        self.embeddings_data = []
+        self.built = False
+    
+    def add_embeddings(self, embeddings_data: List[Dict[str, Any]]):
+        """Add embeddings to the index."""
+        embeddings_array = np.array([data["embedding"] for data in embeddings_data]).astype('float32')
+        
+        # All providers now return normalized embeddings, but normalize again to ensure consistency
+        # for FAISS inner product search (which requires normalized vectors for cosine similarity)
+        faiss.normalize_L2(embeddings_array)
+        
+        self.index.add(embeddings_array)
+        self.embeddings_data = embeddings_data
+        self.built = True
+        
+        # Set ef parameter for search (higher = more accurate but slower)
+        self.index.hnsw.efSearch = max(50, min(200, len(embeddings_data) // 10))
+    
+    def search(self, query_embedding: List[float], k: int = 10) -> List[Tuple[Dict[str, Any], float]]:
+        """Search for k nearest neighbors and return with exact cosine similarities."""
+        if not self.built:
+            return []
+        
+        query_array = np.array([query_embedding]).astype('float32').reshape(1, -1)
+        # All providers now return normalized embeddings, but normalize again to ensure consistency
+        # for FAISS inner product search (which requires normalized vectors for cosine similarity)
+        faiss.normalize_L2(query_array)
+        
+        # Get approximate neighbors (returns more than k for exact rescoring)
+        search_k = min(k * 3, len(self.embeddings_data))  # Get 3x candidates for rescoring
+        distances, indices = self.index.search(query_array, search_k)
+        
+        # Calculate exact cosine similarities for the candidates
+        results = []
+        for idx in indices[0]:
+            if idx < len(self.embeddings_data) and idx >= 0:  # FAISS can return -1 for invalid indices
+                embedding_data = self.embeddings_data[idx]
+                exact_similarity = cosine_similarity(query_embedding, embedding_data["embedding"])
+                results.append((embedding_data, exact_similarity))
+        
+        # Sort by exact similarity and return top k
+        results.sort(key=lambda x: x[1], reverse=True)
+        return results[:k]
+
+
+# Global cache for HNSW indices
+_hnsw_cache = {}
+
+def get_hnsw_index(provider: EmbeddingProvider, translation: str, all_embeddings: List[Dict[str, Any]]) -> HNSWIndex:
+    """Get or create FAISS HNSW index for given provider and translation."""
+    cache_key = f"{provider.model_name}_{translation}"
+    
+    if cache_key in _hnsw_cache:
+        return _hnsw_cache[cache_key]
+    
+    if not all_embeddings:
+        return None
+    
+    # Determine embedding dimension from first embedding
+    dimension = len(all_embeddings[0]["embedding"])
+    
+    # Create and build HNSW index
+    print(f"Building FAISS HNSW index for {len(all_embeddings)} embeddings (dimension: {dimension})...")
+    hnsw_index = HNSWIndex(dimension, max_elements=len(all_embeddings) * 2)
+    hnsw_index.add_embeddings(all_embeddings)
+    
+    # Cache the index
+    _hnsw_cache[cache_key] = hnsw_index
+    print(f"FAISS HNSW index built and cached for {cache_key}")
+    
+    return hnsw_index
+
+
 async def search_embeddings(
-    query: str, provider: EmbeddingProvider, translation: str, top_k: int = 10
+    query: str, provider: EmbeddingProvider, translation: str, top_k: int = 10, 
+    pre_loaded_embeddings: List[Dict[str, Any]] = None, use_hnsw: bool = True
 ) -> List[Tuple[Dict[str, Any], float]]:
-    """Search for similar verses using embeddings."""
-    # Load all embeddings for the model
-    all_embeddings = load_embeddings_for_model(provider, translation)
+    """Search for similar verses using embeddings with optional HNSW optimization."""
+    # Use pre-loaded embeddings if provided, otherwise load them
+    if pre_loaded_embeddings is not None:
+        all_embeddings = pre_loaded_embeddings
+    else:
+        all_embeddings = load_embeddings_for_model(provider, translation)
 
     if not all_embeddings:
         return []
@@ -628,7 +898,14 @@ async def search_embeddings(
     print(f"Generating embedding for query: '{query}'")
     query_embedding = await provider.embed_text(query)
 
-    # Calculate similarities
+    # Use HNSW when explicitly requested
+    if use_hnsw:
+        hnsw_index = get_hnsw_index(provider, translation, all_embeddings)
+        if hnsw_index:
+            return hnsw_index.search(query_embedding, top_k)
+    
+    # Fallback to brute-force search for small datasets or when HNSW fails
+    print(f"Using brute-force search for {len(all_embeddings)} embeddings")
     results = []
     for embedding_data in all_embeddings:
         similarity = cosine_similarity(query_embedding, embedding_data["embedding"])
@@ -755,8 +1032,9 @@ def select_model_for_query() -> EmbeddingProvider:
             exit(0)
 
 
-async def query_mode():
+async def query_mode(args):
     """Interactive query mode."""
+    use_hnsw = not args.no_hnsw
     print("Bible Verse Search Mode")
     print("=" * 30)
     print()
@@ -791,7 +1069,7 @@ async def query_mode():
                 top_k = 10
 
             # Perform search
-            results = await search_embeddings(query, provider, translation, top_k)
+            results = await search_embeddings(query, provider, translation, top_k, use_hnsw=use_hnsw)
 
             if results:
                 display_search_results(results, query)
@@ -808,5 +1086,799 @@ async def query_mode():
             print("Please try again.")
 
 
+def load_queries(queries_file: Path) -> List[Dict[str, Any]]:
+    """Load queries from YAML file."""
+    if not queries_file.exists():
+        print(f"Queries file not found: {queries_file}")
+        print("Expected format:")
+        print("""# Simple format - list of query/expected pairs
+- query: "love your enemies"
+  expected: "Matthew 5:44"
+- query: "faith hope love"  
+  expected: "1 Corinthians 13:13"
+
+# Or with expected as list for multiple valid answers
+- query: "god is love"
+  expected: ["1 John 4:8", "1 John 4:16"]
+""")
+        exit(1)
+    
+    try:
+        with open(queries_file, "r", encoding="utf-8") as f:
+            queries = yaml.safe_load(f)
+            
+        # Handle both formats: list directly or under "queries" key
+        if isinstance(queries, dict) and "queries" in queries:
+            queries = queries["queries"]
+        elif not isinstance(queries, list):
+            print(f"Invalid queries file format. Expected list of queries in {queries_file}")
+            exit(1)
+            
+        return queries
+    except Exception as e:
+        print(f"Error loading queries file {queries_file}: {e}")
+        exit(1)
+
+
+def parse_verse_reference(ref: str) -> Tuple[str, int, int]:
+    """Parse a verse reference like 'Matthew 5:44' into (book, chapter, verse)."""
+    try:
+        # Split on the last space to separate book from chapter:verse
+        parts = ref.rsplit(" ", 1)
+        if len(parts) != 2:
+            raise ValueError("Invalid format")
+        
+        book = parts[0].strip()
+        chapter_verse = parts[1]
+        
+        # Split chapter:verse
+        if ":" not in chapter_verse:
+            raise ValueError("Missing verse number")
+            
+        chapter_str, verse_str = chapter_verse.split(":", 1)
+        chapter = int(chapter_str.strip())
+        verse = int(verse_str.strip())
+        
+        return book, chapter, verse
+    except Exception as e:
+        print(f"Error parsing verse reference '{ref}': {e}")
+        return None, None, None
+
+
+def calculate_score(expected_refs, results: List[Tuple[Dict[str, Any], float]]) -> int:
+    """Calculate score based on where expected result appears in top 3 results."""
+    # Handle both single string and list of expected references
+    if isinstance(expected_refs, str):
+        expected_refs = [expected_refs]
+    elif not expected_refs:
+        return 0
+    
+    # Parse all expected references
+    expected_verses = []
+    for ref in expected_refs:
+        book, chapter, verse = parse_verse_reference(ref)
+        if book:
+            expected_verses.append((book, chapter, verse))
+    
+    if not expected_verses:
+        return 0
+    
+    # Check if any expected verse appears in top 3 results
+    for i, (verse_data, similarity) in enumerate(results[:3]):
+        verse_tuple = (verse_data["book"], verse_data["chapter"], verse_data["verse"])
+        if verse_tuple in expected_verses:
+            return 3 - i  # 3 points for 1st, 2 for 2nd, 1 for 3rd
+    
+    return 0  # No points if not in top 3
+
+
+def format_verse_reference(verse_data: Dict[str, Any]) -> str:
+    """Format verse data into a reference string."""
+    return f"{verse_data['book']} {verse_data['chapter']}:{verse_data['verse']}"
+
+
+async def process_single_query(
+    query_data: Dict[str, Any],
+    provider: EmbeddingProvider, 
+    translation: str,
+    query_index: int,
+    total_queries: int,
+    semaphore: Semaphore,
+    pre_loaded_embeddings: List[Dict[str, Any]],
+    use_hnsw: bool = True
+) -> Dict[str, Any]:
+    """Process a single query with concurrency control."""
+    async with semaphore:
+        query = query_data.get("query", "")
+        expected = query_data.get("expected", "")
+        
+        if not query:
+            print(f"Skipping query {query_index}: missing 'query' field")
+            return None
+            
+        print(f"Query {query_index}/{total_queries}: {query}")
+        
+        try:
+            # Get top 3 results using pre-loaded embeddings
+            search_results = await search_embeddings(query, provider, translation, top_k=3, pre_loaded_embeddings=pre_loaded_embeddings, use_hnsw=use_hnsw)
+            
+            if not search_results:
+                print(f"  No results found for query: {query}")
+                return None
+            
+            # Calculate score if expected result is provided
+            score = 0
+            if expected:
+                score = calculate_score(expected, search_results)
+                expected_str = str(expected) if isinstance(expected, list) else expected
+                print(f"  Expected: {expected_str} | Score: {score}/3")
+            
+            # Format results
+            result_data = {
+                "query": query,
+                "expected": expected,
+                "score": score,
+                "results": []
+            }
+            
+            for j, (verse_data, similarity) in enumerate(search_results):
+                result_ref = format_verse_reference(verse_data)
+                result_data["results"].append({
+                    "reference": result_ref,
+                    "similarity": similarity
+                })
+                print(f"  {j+1}. {result_ref} ({similarity:.4f})")
+            
+            return result_data
+            
+        except Exception as e:
+            print(f"Error processing query '{query}': {e}")
+            return None
+
+
+async def run_batch_queries_openai_optimized(
+    queries: List[Dict[str, Any]], 
+    provider: OpenAIProvider, 
+    translation: str,
+    batch_size: int = 100,
+    use_hnsw: bool = True
+) -> List[Dict[str, Any]]:
+    """Run batch queries optimized for OpenAI using their batch embedding capability."""
+    total_queries = len(queries)
+    
+    print(f"Running {total_queries} batch queries using OpenAI batch optimization...")
+    
+    # Load embeddings once for all queries
+    print("Loading verse embeddings for similarity search...")
+    pre_loaded_embeddings = load_embeddings_for_model(provider, translation)
+    
+    if not pre_loaded_embeddings:
+        print("No embeddings found! Make sure embeddings exist for this model and translation.")
+        return []
+    
+    print(f"Loaded {len(pre_loaded_embeddings)} verse embeddings")
+    
+    # Extract all query texts for batch embedding
+    query_texts = []
+    query_data_list = []
+    for query_data in queries:
+        query = query_data.get("query", "")
+        if query:
+            query_texts.append(query)
+            query_data_list.append(query_data)
+    
+    if not query_texts:
+        print("No valid queries found!")
+        return []
+    
+    # Embed all queries in batches using OpenAI's batch API
+    print(f"Embedding {len(query_texts)} queries using OpenAI batch API...")
+    query_embeddings = await provider.embed_queries_batch(query_texts, batch_size)
+    
+    if len(query_embeddings) != len(query_texts):
+        print(f"Warning: Expected {len(query_texts)} embeddings, got {len(query_embeddings)}")
+    
+    # Build HNSW index if requested
+    hnsw_index = None
+    if use_hnsw:
+        hnsw_index = get_hnsw_index(provider, translation, pre_loaded_embeddings)
+    
+    # Process results
+    results = []
+    for i, (query_data, query_embedding) in enumerate(zip(query_data_list, query_embeddings)):
+        query = query_data.get("query", "")
+        expected = query_data.get("expected", "")
+        
+        print(f"Processing query {i+1}/{len(query_texts)}: {query}")
+        
+        # Use HNSW for similarity search if available, otherwise brute-force
+        if hnsw_index:
+            search_results = hnsw_index.search(query_embedding, k=3)
+        else:
+            # Calculate similarities with all verses
+            similarities = []
+            for embedding_data in pre_loaded_embeddings:
+                similarity = cosine_similarity(query_embedding, embedding_data["embedding"])
+                similarities.append((embedding_data, similarity))
+            
+            # Sort by similarity and get top 3
+            similarities.sort(key=lambda x: x[1], reverse=True)
+            search_results = similarities[:3]
+        
+        # Calculate score if expected result is provided
+        score = 0
+        if expected:
+            score = calculate_score(expected, search_results)
+            expected_str = str(expected) if isinstance(expected, list) else expected
+            print(f"  Expected: {expected_str} | Score: {score}/3")
+        
+        # Format results
+        result_data = {
+            "query": query,
+            "expected": expected,
+            "score": score,
+            "results": []
+        }
+        
+        for j, (verse_data, similarity) in enumerate(search_results):
+            result_ref = format_verse_reference(verse_data)
+            result_data["results"].append({
+                "reference": result_ref,
+                "similarity": similarity
+            })
+            print(f"  {j+1}. {result_ref} ({similarity:.4f})")
+        
+        results.append(result_data)
+    
+    print(f"\nProcessed {len(results)} queries successfully")
+    return results
+
+
+async def run_batch_queries_optimized(
+    queries: List[Dict[str, Any]], 
+    provider: EmbeddingProvider, 
+    translation: str,
+    batch_size: int = 100,
+    use_hnsw: bool = True
+) -> List[Dict[str, Any]]:
+    """Run batch queries optimized for providers that support batch embedding."""
+    total_queries = len(queries)
+    
+    print(f"Running {total_queries} batch queries using batch optimization...")
+    
+    # Load embeddings once for all queries
+    print("Loading verse embeddings for similarity search...")
+    pre_loaded_embeddings = load_embeddings_for_model(provider, translation)
+    
+    if not pre_loaded_embeddings:
+        print("No embeddings found! Make sure embeddings exist for this model and translation.")
+        return []
+    
+    print(f"Loaded {len(pre_loaded_embeddings)} verse embeddings")
+    
+    # Extract all query texts for batch embedding
+    query_texts = []
+    query_data_list = []
+    for query_data in queries:
+        query = query_data.get("query", "")
+        if query:
+            query_texts.append(query)
+            query_data_list.append(query_data)
+    
+    if not query_texts:
+        print("No valid queries found!")
+        return []
+    
+    # Embed all queries in batches using provider's batch API
+    print(f"Embedding {len(query_texts)} queries using batch API...")
+    
+    # Adjust batch size based on provider type
+    if isinstance(provider, HuggingFaceProvider):
+        batch_size = 500  # Local models can handle larger batches
+    elif isinstance(provider, (OpenAIProvider, GeminiProvider, VoyageProvider)):
+        batch_size = 100  # API models use smaller batches
+    
+    query_embeddings = await provider.embed_queries_batch(query_texts, batch_size)
+    
+    if len(query_embeddings) != len(query_texts):
+        print(f"Warning: Expected {len(query_texts)} embeddings, got {len(query_embeddings)}")
+    
+    # Build HNSW index if requested
+    hnsw_index = None
+    if use_hnsw:
+        hnsw_index = get_hnsw_index(provider, translation, pre_loaded_embeddings)
+    
+    # Process results
+    results = []
+    for i, (query_data, query_embedding) in enumerate(zip(query_data_list, query_embeddings)):
+        query = query_data.get("query", "")
+        expected = query_data.get("expected", "")
+        
+        print(f"Processing query {i+1}/{len(query_texts)}: {query}")
+        
+        # Use HNSW for similarity search if available, otherwise brute-force
+        if hnsw_index:
+            search_results = hnsw_index.search(query_embedding, k=3)
+        else:
+            # Calculate similarities with all verses
+            similarities = []
+            for embedding_data in pre_loaded_embeddings:
+                similarity = cosine_similarity(query_embedding, embedding_data["embedding"])
+                similarities.append((embedding_data, similarity))
+            
+            # Sort by similarity and get top 3
+            similarities.sort(key=lambda x: x[1], reverse=True)
+            search_results = similarities[:3]
+        
+        # Calculate score if expected result is provided
+        score = 0
+        if expected:
+            score = calculate_score(expected, search_results)
+            expected_str = str(expected) if isinstance(expected, list) else expected
+            print(f"  Expected: {expected_str} | Score: {score}/3")
+        
+        # Format results
+        result_data = {
+            "query": query,
+            "expected": expected,
+            "score": score,
+            "results": []
+        }
+        
+        for j, (verse_data, similarity) in enumerate(search_results):
+            result_ref = format_verse_reference(verse_data)
+            result_data["results"].append({
+                "reference": result_ref,
+                "similarity": similarity
+            })
+            print(f"  {j+1}. {result_ref} ({similarity:.4f})")
+        
+        results.append(result_data)
+    
+    print(f"\nProcessed {len(results)} queries successfully")
+    return results
+
+
+async def run_batch_queries(
+    queries: List[Dict[str, Any]], 
+    provider: EmbeddingProvider, 
+    translation: str,
+    concurrency: int = 5,
+    use_hnsw: bool = True
+) -> List[Dict[str, Any]]:
+    """Run all batch queries with provider-specific optimizations."""
+    # Check if provider supports batch optimization
+    if hasattr(provider, 'embed_queries_batch'):
+        provider_name = type(provider).__name__
+        print(f"Using {provider_name} batch optimization...")
+        return await run_batch_queries_optimized(queries, provider, translation, use_hnsw=use_hnsw)
+    
+    # Fall back to standard concurrent processing for other providers
+    total_queries = len(queries)
+    
+    print(f"Running {total_queries} batch queries with concurrency limit of {concurrency}...")
+    
+    # Load embeddings once for all queries
+    print("Loading embeddings for all queries...")
+    pre_loaded_embeddings = load_embeddings_for_model(provider, translation)
+    
+    if not pre_loaded_embeddings:
+        print("No embeddings found! Make sure embeddings exist for this model and translation.")
+        return []
+    
+    print(f"Loaded {len(pre_loaded_embeddings)} verse embeddings")
+    
+    # Create semaphore to limit concurrent requests
+    semaphore = Semaphore(concurrency)
+    
+    # Create tasks for all queries
+    tasks = []
+    for i, query_data in enumerate(queries, 1):
+        task = process_single_query(
+            query_data, provider, translation, i, total_queries, semaphore, pre_loaded_embeddings, use_hnsw
+        )
+        tasks.append(task)
+    
+    # Run all tasks concurrently
+    print(f"Starting concurrent processing...")
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    
+    # Filter out None results and exceptions
+    valid_results = []
+    for result in results:
+        if isinstance(result, Exception):
+            print(f"Exception in batch processing: {result}")
+        elif result is not None:
+            valid_results.append(result)
+    
+    print(f"\nProcessed {len(valid_results)} queries successfully out of {total_queries}")
+    return valid_results
+
+
+def append_to_csv(
+    results_file: Path, 
+    results: List[Dict[str, Any]], 
+    provider: EmbeddingProvider,
+    translation: str
+):
+    """Append results to CSV file."""
+    provider_name = get_model_provider(provider)
+    model_name = provider.get_name()
+    
+    # Create CSV headers if file doesn't exist
+    file_exists = results_file.exists()
+    
+    with open(results_file, "a", newline="", encoding="utf-8") as f:
+        fieldnames = [
+            "timestamp", "provider", "model", "translation", "query", "expected",
+            "result1", "score1", "result2", "score2", "result3", "score3", "points"
+        ]
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        
+        if not file_exists:
+            writer.writeheader()
+        
+        timestamp = datetime.now().isoformat()
+        
+        for result in results:
+            # Pad results to ensure we have 3 entries
+            padded_results = result["results"] + [{"reference": "", "similarity": 0.0}] * 3
+            padded_results = padded_results[:3]  # Take only first 3
+            
+            row = {
+                "timestamp": timestamp,
+                "provider": provider_name,
+                "model": model_name,
+                "translation": translation,
+                "query": result["query"],
+                "expected": result["expected"],
+                "result1": padded_results[0]["reference"],
+                "score1": f"{padded_results[0]['similarity']:.4f}",
+                "result2": padded_results[1]["reference"],
+                "score2": f"{padded_results[1]['similarity']:.4f}",
+                "result3": padded_results[2]["reference"],
+                "score3": f"{padded_results[2]['similarity']:.4f}",
+                "points": result["score"]
+            }
+            writer.writerow(row)
+
+
+async def batch_mode(args):
+    """Batch query processing mode."""
+    print("Bible Verse Batch Query Mode")
+    print("=" * 35)
+    print()
+    
+    # Load queries
+    queries_file = Path(args.queries_file)
+    queries = load_queries(queries_file)
+    
+    print(f"Loaded {len(queries)} queries from {queries_file}")
+    
+    # Select translation
+    if args.translation:
+        translation = args.translation
+        if translation not in get_available_translations():
+            print(f"Translation '{translation}' not found!")
+            return
+    else:
+        translation = select_translation_for_query()
+    
+    print(f"Using translation: {translation}")
+    print()
+    
+    # Select model
+    if args.model:
+        # Find the model in available models
+        provider = None
+        models = get_available_models()
+        for provider_info in models.values():
+            if args.model in provider_info["models"]:
+                provider = provider_info["provider_class"](args.model)
+                break
+        
+        if provider is None:
+            print(f"Model '{args.model}' not found!")
+            return
+    else:
+        provider = select_model_for_query()
+    
+    provider_name = get_model_provider(provider)
+    model_name = provider.get_name()
+    print(f"Using model: {model_name} ({provider_name})")
+    print()
+    
+    # Run batch queries
+    use_hnsw = not args.no_hnsw
+    results = await run_batch_queries(queries, provider, translation, args.concurrency, use_hnsw)
+    
+    if not results:
+        print("No results to save.")
+        return
+    
+    # Calculate summary statistics
+    total_queries = len(results)
+    total_points = sum(r["score"] for r in results)
+    max_possible_points = total_queries * 3
+    accuracy = (total_points / max_possible_points) * 100 if max_possible_points > 0 else 0
+    
+    print(f"\nBatch Query Summary:")
+    print(f"  Total queries: {total_queries}")
+    print(f"  Total points: {total_points}/{max_possible_points}")
+    print(f"  Accuracy: {accuracy:.1f}%")
+    
+    # Save to CSV
+    results_file = Path(args.results_file)
+    append_to_csv(results_file, results, provider, translation)
+    print(f"\nResults appended to: {results_file}")
+
+
+def read_results_csv(results_file: Path) -> List[Dict[str, Any]]:
+    """Read and parse results from CSV file."""
+    if not results_file.exists():
+        print(f"Results file not found: {results_file}")
+        return []
+    
+    results = []
+    try:
+        with open(results_file, "r", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                # Convert points to integer
+                try:
+                    row["points"] = int(row["points"])
+                except (ValueError, KeyError):
+                    row["points"] = 0
+                results.append(row)
+    except Exception as e:
+        print(f"Error reading CSV file {results_file}: {e}")
+        return []
+    
+    return results
+
+
+def analyze_results(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Analyze results and generate summary statistics."""
+    if not results:
+        return {}
+    
+    # Group by provider and model
+    provider_model_stats = {}
+    
+    for result in results:
+        provider = result.get("provider", "unknown")
+        model = result.get("model", "unknown")
+        translation = result.get("translation", "unknown")
+        points = result.get("points", 0)
+        
+        key = (provider, model, translation)
+        
+        if key not in provider_model_stats:
+            provider_model_stats[key] = {
+                "provider": provider,
+                "model": model,
+                "translation": translation,
+                "total_queries": 0,
+                "total_points": 0,
+                "max_points": 0,
+                "correct_top1": 0,  # 3 points
+                "correct_top2": 0,  # 2 points
+                "correct_top3": 0,  # 1 point
+                "incorrect": 0,     # 0 points
+                "queries": []
+            }
+        
+        stats = provider_model_stats[key]
+        stats["total_queries"] += 1
+        stats["total_points"] += points
+        stats["max_points"] += 3  # Maximum possible points per query
+        
+        # Count by position
+        if points == 3:
+            stats["correct_top1"] += 1
+        elif points == 2:
+            stats["correct_top2"] += 1
+        elif points == 1:
+            stats["correct_top3"] += 1
+        else:
+            stats["incorrect"] += 1
+        
+        # Store query details for detailed table
+        stats["queries"].append({
+            "query": result.get("query", ""),
+            "expected": result.get("expected", ""),
+            "result1": result.get("result1", ""),
+            "result2": result.get("result2", ""),
+            "result3": result.get("result3", ""),
+            "points": points
+        })
+    
+    # Calculate accuracy percentages
+    for stats in provider_model_stats.values():
+        if stats["max_points"] > 0:
+            stats["accuracy"] = (stats["total_points"] / stats["max_points"]) * 100
+        else:
+            stats["accuracy"] = 0
+    
+    return provider_model_stats
+
+
+def generate_summary_table(stats: Dict[tuple, Dict[str, Any]]) -> str:
+    """Generate summary table markdown."""
+    if not stats:
+        return "No results to display.\n\n"
+    
+    markdown = "## Model Performance Summary\n\n"
+    markdown += "| Provider | Model | Translation | Accuracy | Top 1 | Top 2 | Top 3 | Failed | Total |\n"
+    markdown += "|----------|-------|-------------|----------|-------|-------|-------|-----------|-------|\n"
+    
+    # Sort by accuracy (descending)
+    sorted_stats = sorted(stats.items(), key=lambda x: x[1]["accuracy"], reverse=True)
+    
+    for (provider, model, translation), stat in sorted_stats:
+        markdown += f"| {provider} | {model} | {translation} | "
+        markdown += f"{stat['accuracy']:.1f}% | "
+        markdown += f"{stat['correct_top1']} | "
+        markdown += f"{stat['correct_top2']} | "
+        markdown += f"{stat['correct_top3']} | "
+        markdown += f"{stat['incorrect']} | "
+        markdown += f"{stat['total_queries']} |\n"
+    
+    markdown += "\n"
+    return markdown
+
+
+def generate_detailed_table(stats: Dict[tuple, Dict[str, Any]], max_queries: int = 10) -> str:
+    """Generate detailed results with individual sections for each model."""
+    if not stats:
+        return ""
+    
+    markdown = "## Results\n\n"
+    markdown += "✅ denotes accurate result.\n\n"
+    
+    # Sort models by accuracy (best first)
+    sorted_stats = sorted(stats.items(), key=lambda x: x[1]["accuracy"], reverse=True)
+    
+    for (provider, model, translation), stat in sorted_stats:
+        # Create model heading
+        model_display = f"{provider}/{model}" if provider != "HuggingFace" else model
+        markdown += f"### {model_display} ({translation.upper()})\n\n"
+        
+        # Add summary statistics
+        accuracy = stat["accuracy"]
+        total_points = stat["total_points"] 
+        max_points = stat["max_points"]
+        total_queries = len(stat["queries"])
+        
+        markdown += f"**Accuracy: {accuracy:.1f}%** ({total_points}/{max_points} points across {total_queries} queries)\n\n"
+        
+        # Create table for this model
+        markdown += "| Query | Expected | Top Result | Score | ✓ |\n"
+        markdown += "|-------|----------|------------|-------|---|\n"
+        
+        # Show up to max_queries results  
+        queries = stat["queries"][:max_queries]
+        
+        for query_result in queries:
+            query = query_result["query"]
+            # Truncate long queries for table readability
+            display_query = query[:50] + "..." if len(query) > 50 else query
+            expected = query_result["expected"]
+            
+            # Get the top result
+            if "result1" in query_result and query_result["result1"]:
+                result1 = query_result["result1"]
+                score1 = query_result.get("score1", 0.0)
+                points = query_result.get("points", 0)
+                
+                # Add checkmark based on points
+                if points == 3:
+                    checkmark = "✅"  # Perfect match (1st place)
+                elif points == 2:
+                    checkmark = "⚠️"   # Good match (2nd place)  
+                elif points == 1:
+                    checkmark = "❌"   # Poor match (3rd place)
+                else:
+                    checkmark = "❌"   # No match
+                
+                markdown += f"| {display_query} | {expected} | {result1} | {score1:.4f} | {checkmark} |\n"
+            else:
+                markdown += f"| {display_query} | {expected} | No results | 0.0000 | ❌ |\n"
+        
+        if len(stat["queries"]) > max_queries:
+            remaining = len(stat["queries"]) - max_queries
+            markdown += f"\n*... and {remaining} more queries*\n"
+        
+        markdown += "\n"
+    
+    # Add legend
+    markdown += "## Legend\n\n"
+    markdown += "- ✅ **Perfect Match** - Expected result appears as #1 result (3 points)\n"
+    markdown += "- ⚠️ **Good Match** - Expected result appears as #2 result (2 points)\n" 
+    markdown += "- ❌ **Poor/No Match** - Expected result appears as #3 result (1 point) or not in top 3 (0 points)\n\n"
+    
+    return markdown
+
+
+def generate_legend() -> str:
+    """Generate legend for checkmark symbols."""
+    return """## Legend
+
+- ✅ **Perfect Match** - Expected result appears as #1 result (3 points)
+- ⚠️ **Good Match** - Expected result appears as #2 result (2 points)  
+- ❌ **Poor/No Match** - Expected result appears as #3 result (1 point) or not in top 3 (0 points)
+
+"""
+
+
+def generate_report(args):
+    """Generate markdown report and update only the Query Examples section in README.md."""
+    print("Bible Verse Embedding Evaluation Report Generator")
+    print("=" * 55)
+    print()
+    
+    results_file = Path(args.results_file)
+    output_file = Path(args.output_file)
+    
+    print(f"Reading results from: {results_file}")
+    results = read_results_csv(results_file)
+    
+    if not results:
+        print("No results found to process.")
+        return
+    
+    print(f"Loaded {len(results)} result entries")
+    
+    # Analyze results
+    print("Analyzing results...")
+    stats = analyze_results(results)
+    
+    if not stats:
+        print("No statistics to generate.")
+        return
+    
+    print(f"Found results for {len(stats)} model/provider combinations")
+    
+    # Read existing README.md file
+    try:
+        with open(output_file, "r", encoding="utf-8") as f:
+            existing_content = f.read()
+    except FileNotFoundError:
+        print(f"README.md not found at {output_file}, creating new file")
+        existing_content = "# Bible Embeddings\n\n"
+    
+    # Find the Results section (or Query Examples for backward compatibility) and replace it
+    results_section_start = existing_content.find("## Results")
+    if results_section_start == -1:
+        results_section_start = existing_content.find("## Query Examples")
+    
+    if results_section_start == -1:
+        # No Results section found, append to end
+        print("No existing Results section found, appending to end")
+        new_content = existing_content.rstrip() + "\n\n" + generate_detailed_table(stats, args.max_queries)
+    else:
+        # Find the end of the Results section (next ## heading or end of file)
+        next_section_start = existing_content.find("\n## ", results_section_start + 1)
+        if next_section_start == -1:
+            # Results is the last section
+            before_section = existing_content[:results_section_start]
+            after_section = ""
+        else:
+            before_section = existing_content[:results_section_start]
+            after_section = existing_content[next_section_start:]
+        
+        # Replace the Results section
+        new_results_section = generate_detailed_table(stats, args.max_queries)
+        new_content = before_section + new_results_section + after_section
+    
+    # Write updated content to file
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(new_content)
+        print(f"\nResults section updated in: {output_file}")
+    except Exception as e:
+        print(f"Error writing report file: {e}")
+
+
 if __name__ == "__main__":
     asyncio.run(main())

pyproject.toml

@@ -11,6 +11,8 @@ dependencies = [
     "voyageai>=0.3.4",
     "jina>=3.0.0",
     "numpy>=1.21.0",
+    "pyyaml>=6.0",
+    "faiss-cpu>=1.8.0",
 ]
 
 [project.optional-dependencies]

uv.lock

@@ -120,10 +120,12 @@ name = "bible-embeddings"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "faiss-cpu" },
     { name = "google-generativeai" },
     { name = "jina" },
     { name = "numpy" },
     { name = "openai" },
+    { name = "pyyaml" },
     { name = "sentence-transformers" },
     { name = "voyageai" },
 ]
@@ -150,6 +152,7 @@ voyage = [
 
 [package.metadata]
 requires-dist = [
+    { name = "faiss-cpu", specifier = ">=1.8.0" },
     { name = "google-generativeai", specifier = ">=0.8.5" },
     { name = "google-generativeai", marker = "extra == 'all'", specifier = ">=0.8.5" },
     { name = "google-generativeai", marker = "extra == 'gemini'", specifier = ">=0.8.5" },
@@ -160,6 +163,7 @@ requires-dist = [
     { name = "openai", specifier = ">=1.101.0" },
     { name = "openai", marker = "extra == 'all'", specifier = ">=1.0.0" },
     { name = "openai", marker = "extra == 'openai'", specifier = ">=1.0.0" },
+    { name = "pyyaml", specifier = ">=6.0" },
     { name = "sentence-transformers", specifier = ">=5.1.0" },
     { name = "voyageai", specifier = ">=0.3.4" },
     { name = "voyageai", marker = "extra == 'all'", specifier = ">=0.3.4" },
@@ -289,6 +293,42 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/a3/460c57f094a4a165c84a1341c373b0a4f5ec6ac244b998d5021aade89b77/ecdsa-0.19.1-py2.py3-none-any.whl", hash = "sha256:30638e27cf77b7e15c4c4cc1973720149e1033827cfd00661ca5c8cc0cdb24c3", size = 150607, upload-time = "2025-03-13T11:52:41.757Z" },
 ]
 
+[[package]]
+name = "faiss-cpu"
+version = "1.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/80/bb75a7ed6e824dea452a24d3434a72ed799324a688b10b047d441d270185/faiss_cpu-1.12.0.tar.gz", hash = "sha256:2f87cbcd603f3ed464ebceb857971fdebc318de938566c9ae2b82beda8e953c0", size = 69292, upload-time = "2025-08-13T06:07:26.553Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/4e/6be5fbd2ceccd87b168c64edeefa469cd11f095bb63b16a61a29296b0fdb/faiss_cpu-1.12.0-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:c9c79b5f28dcf9b2e2557ce51b938b21b7a9d508e008dc1ffea7b8249e7bd443", size = 8034409, upload-time = "2025-08-13T06:06:22.519Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f0/658012a91a690d82f3587fd8e56ea1d9b9698c31970929a9dba17edd211e/faiss_cpu-1.12.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0db6485bc9f32b69aaccf9ad520782371a79904dcfe20b6da5cbfd61a712e85f", size = 3362034, upload-time = "2025-08-13T06:06:24.052Z" },
+    { url = "https://files.pythonhosted.org/packages/81/8b/9b355309d448e1a737fac31d45e9b2484ffb0f04f10fba3b544efe6661e4/faiss_cpu-1.12.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6db5532831791d7bac089fc580e741e99869122946bb6a5f120016c83b95d10", size = 3834324, upload-time = "2025-08-13T06:06:25.506Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/31/d229f6cdb9cbe03020499d69c4b431b705aa19a55aa0fe698c98022b2fef/faiss_cpu-1.12.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d57ed7aac048b18809af70350c31acc0fb9f00e6c03b6ed1651fd58b174882d", size = 31421590, upload-time = "2025-08-13T06:06:27.601Z" },
+    { url = "https://files.pythonhosted.org/packages/26/19/80289ba008f14c95fbb6e94617ea9884e421ca745864fe6b8b90e1c3fc94/faiss_cpu-1.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:26c29290e7d1c5938e5886594dc0a2272b30728351ca5f855d4ae30704d5a6cc", size = 9762452, upload-time = "2025-08-13T06:06:30.237Z" },
+    { url = "https://files.pythonhosted.org/packages/af/e7/6cc03ead5e19275e34992419e2b7d107d0295390ccf589636ff26adb41e2/faiss_cpu-1.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9b43d0c295e93a8e5f1dd30325caaf34d4ecb51f1e3d461c7b0e71bff3a8944b", size = 24156530, upload-time = "2025-08-13T06:06:32.23Z" },
+    { url = "https://files.pythonhosted.org/packages/34/90/438865fe737d65e7348680dadf3b2983bdcef7e5b7e852000e74c50a9933/faiss_cpu-1.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:a7c6156f1309bb969480280906e8865c3c4378eebb0f840c55c924bf06efd8d3", size = 18169604, upload-time = "2025-08-13T06:06:34.884Z" },
+    { url = "https://files.pythonhosted.org/packages/76/69/40a1d8d781a70d33c57ef1b4b777486761dd1c502a86d27e90ef6aa8a9f9/faiss_cpu-1.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:0b5fac98a350774a98b904f7a7c6689eb5cf0a593d63c552e705a80c55636d15", size = 8012523, upload-time = "2025-08-13T06:06:37.24Z" },
+    { url = "https://files.pythonhosted.org/packages/12/35/01a4a7c179d67bee0d8a027b95c3eae19cb354ae69ef2bc50ac3b93bc853/faiss_cpu-1.12.0-cp314-cp314-macosx_13_0_x86_64.whl", hash = "sha256:ff7db774968210d08cd0331287f3f66a6ffef955a7aa9a7fcd3eb4432a4ce5f5", size = 8036142, upload-time = "2025-08-13T06:06:38.894Z" },
+    { url = "https://files.pythonhosted.org/packages/08/23/bac2859490096608c9d527f3041b44c2e43f8df0d4aadd53a4cc5ce678ac/faiss_cpu-1.12.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:220b5bb5439c64e417b35f9ade4c7dc3bf7df683d6123901ba84d6d764ecd486", size = 3363747, upload-time = "2025-08-13T06:06:40.73Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/e18023e1f43a18ec593adcd69d356f1fa94bde20344e38334d5985e5c5cc/faiss_cpu-1.12.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:693d0bf16f79e8d16a1baaeda459f3375f37da0354e97dc032806b48a2a54151", size = 3835232, upload-time = "2025-08-13T06:06:42.172Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/2b/1c1fea423d3f550f44c5ec3f14d8400919b49c285c3bd146687c63e40186/faiss_cpu-1.12.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bcc6587dee21e17430fb49ddc5200625d6f5e1de2bdf436f14827bad4ca78d19", size = 31432677, upload-time = "2025-08-13T06:06:44.348Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d2/3483e92a02f30e2d8491a256f470f54b7f5483266dfe09126d28741d31ec/faiss_cpu-1.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b80e5965f001822cc99ec65c715169af1b70bdae72eccd573520a2dec485b3ee", size = 9765504, upload-time = "2025-08-13T06:06:46.567Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/2f/d97792211a9bd84b8d6b1dcaa1dcd69ac11e026c6ef19c641b6a87e31025/faiss_cpu-1.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98279f1b4876ef9902695a329b81a99002782ab6e26def472022009df6f1ac68", size = 24169930, upload-time = "2025-08-13T06:06:48.916Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/b8/b707ca4d88af472509a053c39d3cced53efd19d096b8dff2fadc18c4b82d/faiss_cpu-1.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:11670337f9f5ee9ff3490e30683eea80add060c300cf6f6cb0e8faf3155fd20e", size = 18475400, upload-time = "2025-08-13T06:06:51.233Z" },
+    { url = "https://files.pythonhosted.org/packages/77/11/42e41ddebde4dfe77e36e92d0110b4f733c8640883abffde54f802482deb/faiss_cpu-1.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:7ac1c8b53609b5c722ab60f1749260a7cb3c72fdfb720a0e3033067e73591da5", size = 8281229, upload-time = "2025-08-13T06:06:53.735Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/9a/8ae5bbeabe70eb673c37fc7c77e2e476746331afb6654b2df97d8b6d380d/faiss_cpu-1.12.0-cp314-cp314t-macosx_13_0_x86_64.whl", hash = "sha256:110b21b7bb4c93c4f1a5eb2ffb8ef99dcdb4725f8ab2e5cd161324e4d981f204", size = 8087247, upload-time = "2025-08-13T06:06:55.407Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/df/b3d79098860b67b126da351788c04ac243c29718dadc4a678a6f5e7209c0/faiss_cpu-1.12.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:82eb5515ce72be9a43f4cf74447a0d090e014231981df91aff7251204b506fbf", size = 3411043, upload-time = "2025-08-13T06:06:56.983Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2f/b1a2a03dd3cce22ff9fc434aa3c7390125087260c1d1349311da36eaa432/faiss_cpu-1.12.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:754eef89cdf2b35643df6b0923a5a098bdfecf63b5f4bd86c385042ee511b287", size = 3801789, upload-time = "2025-08-13T06:06:58.688Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/a8/16ad0c6a966e93d04bfd5248d2be1d8b5849842b0e2611c5ecd26fcaf036/faiss_cpu-1.12.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7285c71c8f5e9c58b55175f5f74c78c518c52c421a88a430263f34e3e31f719c", size = 31231388, upload-time = "2025-08-13T06:07:00.55Z" },
+    { url = "https://files.pythonhosted.org/packages/62/a1/9c16eca0b8f8b13c32c47a5e4ff7a4bc0ca3e7d263140312088811230871/faiss_cpu-1.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:84a50d7a2f711f79cc8b65aa28956dba6435e47b71a38b2daea44c94c9b8e458", size = 9737605, upload-time = "2025-08-13T06:07:03.018Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/4a/2c2d615078c9d816a836fb893aaef551ad152f2eb00bc258698273c240c0/faiss_cpu-1.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7f3e0a14e4edec6a3959a9f51afccb89e863138f184ff2cc24c13f9ad788740b", size = 23922880, upload-time = "2025-08-13T06:07:05.099Z" },
+    { url = "https://files.pythonhosted.org/packages/30/aa/99b8402a4dac678794f13f8f4f29d666c2ef0a91594418147f47034ebc81/faiss_cpu-1.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8b3239cc371df6826ac43c62ac04eec7cc497bedb43f681fcd8ea494f520ddbb", size = 18750661, upload-time = "2025-08-13T06:07:07.551Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/a2/b546e9a20ba157eb2fbe141289f1752f157ee6d932899f4853df4ded6d4b/faiss_cpu-1.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58b23456db725ee1bd605a6135d2ef55b2ac3e0b6fe873fd99a909e8ef4bd0ff", size = 8302032, upload-time = "2025-08-13T06:07:09.602Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.116.1"