Add query mode to new script

main.py

@@ -7,12 +7,12 @@ It supports both commercial APIs and open-source models.
 """
 
 import json
-import os
 import asyncio
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple
 from abc import ABC, abstractmethod
 import argparse
+import numpy as np
 
 
 class EmbeddingProvider(ABC):
@@ -133,7 +133,9 @@ class HuggingFaceProvider(EmbeddingProvider):
 
             # Some models like jina-embeddings-v3 require trust_remote_code=True
             if "jinaai" in self.model_name:
-                self.model = SentenceTransformer(self.model_name, trust_remote_code=True)
+                self.model = SentenceTransformer(
+                    self.model_name, trust_remote_code=True
+                )
             else:
                 self.model = SentenceTransformer(self.model_name)
         return self.model
@@ -324,7 +326,9 @@ def get_model_provider(provider: EmbeddingProvider) -> str:
         return "unknown"
 
 
-def create_output_directories(verses: List[Dict[str, Any]], provider: EmbeddingProvider) -> None:
+def create_output_directories(
+    verses: List[Dict[str, Any]], provider: EmbeddingProvider
+) -> None:
     """Create the necessary output directory structure."""
     provider_name = get_model_provider(provider)
     model_name = provider.get_name()
@@ -385,7 +389,9 @@ async def generate_embeddings(
     provider_name = get_model_provider(provider)
     model_name = provider.get_name()
 
-    print(f"Generating embeddings for {len(verses)} verses using {model_name} ({provider_name})...")
+    print(
+        f"Generating embeddings for {len(verses)} verses using {model_name} ({provider_name})..."
+    )
 
     # Group verses by book and chapter for organized saving
     verses_by_chapter = {}
@@ -458,21 +464,45 @@ async def generate_embeddings(
 
 async def main():
     """Main entry point."""
-    parser = argparse.ArgumentParser(description="Generate Bible verse embeddings")
-    parser.add_argument("--translation", "-t", help="Translation to use")
-    parser.add_argument("--model", "-m", help="Model to use")
-    parser.add_argument(
+    parser = argparse.ArgumentParser(description="Bible verse embeddings tool")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Embed subcommand
+    embed_parser = subparsers.add_parser(
+        "embed", help="Generate embeddings for Bible verses"
+    )
+    embed_parser.add_argument("--translation", "-t", help="Translation to use")
+    embed_parser.add_argument("--model", "-m", help="Model to use")
+    embed_parser.add_argument(
         "--batch-size", "-b", type=int, default=100, help="Batch size for processing"
     )
-    parser.add_argument(
+    embed_parser.add_argument(
         "--skip-existing",
         "-s",
         action="store_true",
         help="Skip verses that already have embeddings",
     )
 
+    # Query subcommand
+    query_parser = subparsers.add_parser(
+        "query", help="Search Bible verses using embeddings"
+    )
+
     args = parser.parse_args()
 
+    # If no command specified, show help
+    if not args.command:
+        parser.print_help()
+        return
+
+    if args.command == "query":
+        await query_mode()
+        return
+
+    if args.command == "embed":
+        # Continue with embedding generation logic
+        pass
+
     # Select translation
     if args.translation:
         translation = args.translation
@@ -524,5 +554,259 @@ async def main():
     print(f"\nCompleted! Generated embeddings for {len(verses)} verses.")
 
 
+def load_embeddings_for_model(
+    provider: EmbeddingProvider, translation: str
+) -> List[Dict[str, Any]]:
+    """Load all embeddings for a specific model and translation."""
+    provider_name = get_model_provider(provider)
+    model_name = provider.get_name()
+
+    embeddings_dir = Path("embeddings") / provider_name / model_name
+    all_embeddings = []
+
+    if not embeddings_dir.exists():
+        print(f"No embeddings found for {model_name} ({provider_name})")
+        return []
+
+    print(f"Loading embeddings for {model_name} ({provider_name})...")
+
+    # Walk through all book directories
+    for book_dir in embeddings_dir.iterdir():
+        if not book_dir.is_dir():
+            continue
+
+        book_name = book_dir.name
+
+        # Walk through all chapter files
+        for chapter_file in book_dir.glob("*.json"):
+            try:
+                with open(chapter_file, "r", encoding="utf-8") as f:
+                    chapter_embeddings = json.load(f)
+
+                for embedding_data in chapter_embeddings:
+                    # Add metadata for searching
+                    embedding_data["translation"] = translation
+                    embedding_data["model"] = model_name
+                    embedding_data["provider"] = provider_name
+                    all_embeddings.append(embedding_data)
+
+            except (json.JSONDecodeError, KeyError) as e:
+                print(f"Error loading {chapter_file}: {e}")
+                continue
+
+    print(f"Loaded {len(all_embeddings)} verse embeddings")
+    return all_embeddings
+
+
+def cosine_similarity(a: List[float], b: List[float]) -> float:
+    """Calculate cosine similarity between two vectors."""
+    a_np = np.array(a)
+    b_np = np.array(b)
+
+    # Calculate cosine similarity
+    dot_product = np.dot(a_np, b_np)
+    norm_a = np.linalg.norm(a_np)
+    norm_b = np.linalg.norm(b_np)
+
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+
+    return dot_product / (norm_a * norm_b)
+
+
+async def search_embeddings(
+    query: str, provider: EmbeddingProvider, translation: str, top_k: int = 10
+) -> 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)
+
+    if not all_embeddings:
+        return []
+
+    # Generate embedding for the query
+    print(f"Generating embedding for query: '{query}'")
+    query_embedding = await provider.embed_text(query)
+
+    # Calculate similarities
+    results = []
+    for embedding_data in all_embeddings:
+        similarity = cosine_similarity(query_embedding, embedding_data["embedding"])
+        results.append((embedding_data, similarity))
+
+    # Sort by similarity (descending)
+    results.sort(key=lambda x: x[1], reverse=True)
+
+    return results[:top_k]
+
+
+def display_search_results(
+    results: List[Tuple[Dict[str, Any], float]], query: str
+) -> None:
+    """Display search results in a formatted way."""
+    print(f"\nTop {len(results)} results for query: '{query}'")
+    print("=" * 80)
+
+    for i, (verse_data, similarity) in enumerate(results, 1):
+        book = verse_data["book"]
+        chapter = verse_data["chapter"]
+        verse = verse_data["verse"]
+
+        print(f"{i:2d}. {book} {chapter}:{verse} (similarity: {similarity:.4f})")
+
+        # Load the actual verse text
+        try:
+            translation = verse_data["translation"]
+            text_file = Path("text") / f"{translation}.json"
+
+            if text_file.exists():
+                with open(text_file, "r", encoding="utf-8") as f:
+                    verses = json.load(f)
+
+                # Find the matching verse
+                verse_text = None
+                for v in verses:
+                    if (
+                        v["book"] == book
+                        and v["chapter"] == chapter
+                        and v["verse"] == verse
+                    ):
+                        verse_text = v["text"]
+                        break
+
+                if verse_text:
+                    # Wrap text at reasonable length
+                    wrapped_text = "\n    ".join(
+                        [verse_text[i : i + 70] for i in range(0, len(verse_text), 70)]
+                    )
+                    print(f"    {wrapped_text}")
+                else:
+                    print(f"    [Text not found]")
+            else:
+                print(f"    [Translation file not found: {translation}]")
+
+        except Exception as e:
+            print(f"    [Error loading text: {e}]")
+
+        print()
+
+
+def select_translation_for_query() -> str:
+    """Interactive translation selection for querying."""
+    translations = get_available_translations()
+
+    if not translations:
+        print("No translations found in the text directory!")
+        exit(1)
+
+    if len(translations) == 1:
+        print(f"Using translation: {translations[0]}")
+        return translations[0]
+
+    print("Available translations:")
+    for i, translation in enumerate(translations, 1):
+        print(f"  {i}. {translation}")
+
+    while True:
+        try:
+            choice = input(
+                f"\nSelect translation for query (1-{len(translations)}): "
+            ).strip()
+            idx = int(choice) - 1
+            if 0 <= idx < len(translations):
+                return translations[idx]
+            else:
+                print(f"Please enter a number between 1 and {len(translations)}")
+        except (ValueError, KeyboardInterrupt):
+            print("\nExiting...")
+            exit(0)
+
+
+def select_model_for_query() -> EmbeddingProvider:
+    """Interactive model selection for querying."""
+    models = get_available_models()
+
+    print("Available embedding models:")
+    print()
+
+    all_choices = []
+    choice_num = 1
+
+    for provider_name, provider_info in models.items():
+        print(f"{provider_name}:")
+        for model in provider_info["models"]:
+            print(f"  {choice_num}. {model}")
+            all_choices.append((provider_name, model, provider_info["provider_class"]))
+            choice_num += 1
+        print()
+
+    while True:
+        try:
+            choice = input(f"Select model for query (1-{len(all_choices)}): ").strip()
+            idx = int(choice) - 1
+            if 0 <= idx < len(all_choices):
+                provider_name, model_name, provider_class = all_choices[idx]
+                print(f"Selected: {model_name} ({provider_name})")
+                return provider_class(model_name)
+            else:
+                print(f"Please enter a number between 1 and {len(all_choices)}")
+        except (ValueError, KeyboardInterrupt):
+            print("\nExiting...")
+            exit(0)
+
+
+async def query_mode():
+    """Interactive query mode."""
+    print("Bible Verse Search Mode")
+    print("=" * 30)
+    print()
+
+    # Select translation
+    translation = select_translation_for_query()
+    print()
+
+    # Select model
+    provider = select_model_for_query()
+    print()
+
+    # Interactive query loop
+    while True:
+        try:
+            query = input("\nEnter your search query (or 'quit' to exit): ").strip()
+
+            if query.lower() in ["quit", "exit", "q"]:
+                print("Goodbye!")
+                break
+
+            if not query:
+                print("Please enter a query.")
+                continue
+
+            # Get number of results
+            try:
+                top_k_input = input("Number of results to show (default 10): ").strip()
+                top_k = int(top_k_input) if top_k_input else 10
+                top_k = max(1, min(top_k, 50))  # Limit between 1 and 50
+            except ValueError:
+                top_k = 10
+
+            # Perform search
+            results = await search_embeddings(query, provider, translation, top_k)
+
+            if results:
+                display_search_results(results, query)
+            else:
+                print(
+                    "No results found. Make sure embeddings exist for this model and translation."
+                )
+
+        except KeyboardInterrupt:
+            print("\nGoodbye!")
+            break
+        except Exception as e:
+            print(f"Error during search: {e}")
+            print("Please try again.")
+
+
 if __name__ == "__main__":
     asyncio.run(main())

pyproject.toml

@@ -10,6 +10,7 @@ dependencies = [
     "google-generativeai>=0.8.5",
     "voyageai>=0.3.4",
     "jina>=3.0.0",
+    "numpy>=1.21.0",
 ]
 
 [project.optional-dependencies]

uv.lock

@@ -122,6 +122,7 @@ source = { virtual = "." }
 dependencies = [
     { name = "google-generativeai" },
     { name = "jina" },
+    { name = "numpy" },
     { name = "openai" },
     { name = "sentence-transformers" },
     { name = "voyageai" },
@@ -155,6 +156,7 @@ requires-dist = [
     { name = "jina", specifier = ">=3.0.0" },
     { name = "jina", marker = "extra == 'all'", specifier = ">=3.0.0" },
     { name = "jina", marker = "extra == 'jina'", specifier = ">=3.0.0" },
+    { name = "numpy", specifier = ">=1.21.0" },
     { name = "openai", specifier = ">=1.101.0" },
     { name = "openai", marker = "extra == 'all'", specifier = ">=1.0.0" },
     { name = "openai", marker = "extra == 'openai'", specifier = ">=1.0.0" },