Make queries very ambigous

configs/prompt_library.yaml

@@ -0,0 +1,41 @@
+# Prompt Library for Search Alchemy
+# Contains system prompts and few-shot examples for various search enhancement stages
+
+query_expansion:
+  system_prompt: |
+    You are a query expansion expert for e-commerce product search across categories: Toys & Games, Home & Kitchen, Clothing Shoes & Jewelry, Sports & Outdoors, and Baby Products.
+
+    Your task is to expand queries with relevant terms, synonyms, and product attributes that improve search quality.
+
+    Rules:
+    - Keep the original query terms
+    - Add 3-5 relevant synonyms, related terms, or product attributes
+    - Include age groups, materials, sizes, or usage contexts when relevant
+    - Use domain-specific terminology (STEM, montessori, organic, etc.)
+    - Return ONLY the expanded query text, no explanations
+    - Keep it concise (max 25 words)
+
+    Examples across categories:
+
+    Query: "learning toy for preschool kids"
+    Expanded: "learning educational toy preschool kids toddlers children ages 3-5 developmental montessori STEM activities play"
+
+    Query: "fun gift for child"
+    Expanded: "fun entertaining gift present toy for child kids children boy girl birthday holiday surprise"
+
+    Query: "cute nursery items"
+    Expanded: "cute nursery items baby room decor decorations accessories wall art bedding essentials infant newborn"
+
+    Query: "backyard play equipment"
+    Expanded: "backyard outdoor play equipment playground set swing slide jungle gym kids children active sports"
+
+    Query: "dress up outfit"
+    Expanded: "dress up costume outfit pretend play kids children toddler princess character role play accessories"
+
+    Query: "bedroom decoration items"
+    Expanded: "bedroom decoration items wall decor art accessories furniture bedding curtains lighting home design"
+
+    Query: "comfortable running shoes"
+    Expanded: "comfortable running shoes athletic sneakers jogging trainers cushioned lightweight breathable sports footwear"
+
+    Now expand the following query:

src/app.py

@@ -9,7 +9,7 @@ from config import (
     EXAMPLE_QUERIES_BY_CATEGORY,
 )
 from src.search.bm25_lexical_search import search_bm25
-from src.search.vector_search import search_vector
+from src.search.vector_search import search_vector, search_vector_with_expansion
 from src.data_prep.data_prep import load_clean_amazon_product_data
 from src.constants.code_snippets import (
     CODE_STAGE_1,
@@ -65,10 +65,8 @@ def format_results(results: List[Dict], stage_name: str, metrics: Dict) -> str:
         stage_name: Name of the search stage
         metrics: Dict with keys: semantic_match, diversity, latency_ms
     """
-    html_parts = [f"## 🔍 {stage_name}\n\n"]
-
-    # Performance metrics at the top with prominent styling
-    html_parts.append(
+    html_parts = [
+        f"## 🔍 {stage_name}\n\n",
         f"""
 <div style="display: flex; gap: 20px; margin-bottom: 28px;">
     <div class="metric-box" style="flex: 1;">
@@ -82,11 +80,13 @@ def format_results(results: List[Dict], stage_name: str, metrics: Dict) -> str:
         <div style="color: #64748B; font-size: 0.8em; margin-top: 4px;">Response time</div>
     </div>
 </div>
-"""
-    )
+""",
+        '<div style="margin-top: 20px;">\n\n',
+    ]
+
+    # Performance metrics at the top with prominent styling
 
     # Results section
-    html_parts.append('<div style="margin-top: 20px;">\n\n')
     for idx, result in enumerate(results, 1):
         category = f"{result.get('main_category', 'N/A')} > {result.get('secondary_category', 'N/A')}"
         html_parts.append(
@@ -103,19 +103,22 @@ def format_results(results: List[Dict], stage_name: str, metrics: Dict) -> str:
     return "".join(html_parts)
 
 
-def run_search_function_and_time(query: str, func: Callable):
+def run_search_function_and_time(query: str, func: Callable, top_n: int = 5):
     start = time.time()
     results = func(query)
     latency = int((time.time() - start) * 1000)
-    return results, latency
+    return results[:top_n], latency
+
+
+def get_average_score(results: List[Dict]) -> float:
+    return sum(r["score"] for r in results) / len(results) if results else 0
 
 
 def search_stage_1(query: str) -> Tuple[str, Dict]:
     """Stage 1: Baseline BM25 keyword search."""
     results, latency = run_search_function_and_time(query, search_bm25)
-
-    avg_score = sum(r["score"] for r in results) / len(results) if results else 0
-    semantic_match = min(1.0, avg_score / 10.0)
+    avg_score = get_average_score(results)
+    semantic_match = min(1.0, avg_score / len(results))
 
     metrics = {
         "semantic_match": semantic_match,
@@ -129,9 +132,7 @@ def search_stage_1(query: str) -> Tuple[str, Dict]:
 def search_stage_2(query: str) -> Tuple[str, Dict]:
     """Stage 2: Vector Embeddings using FAISS."""
     results, latency = run_search_function_and_time(query, search_vector)
-
-    avg_score = sum(r["score"] for r in results) / len(results) if results else 0
-    semantic_match = avg_score
+    semantic_match = get_average_score(results)
 
     metrics = {
         "semantic_match": semantic_match,
@@ -139,34 +140,21 @@ def search_stage_2(query: str) -> Tuple[str, Dict]:
     }
     print(f"Searched vector embeddings for '{query}' in {latency}ms")
 
-    # Return top 5 for display
     return format_results(results[:5], "Stage 2: Vector Embeddings", metrics), metrics
 
 
 def search_stage_3(query: str) -> Tuple[str, Dict]:
-    """Stage 3: BM25 + Embeddings + Query Expansion."""
-    start_time = time.time()
+    """Stage 3: Query Expansion + Vector Embeddings."""
 
-    # Placeholder: Simulated query expansion with correct format
-    results = [
-        {
-            "product_name": product["title"],
-            "description": product["description"],
-            "main_category": product["category"],
-            "secondary_category": "Placeholder",
-            "score": 0.78 + (idx * 0.03),
-        }
-        for idx, product in enumerate(SAMPLE_PRODUCTS[:5])
-    ]
-
-    latency = int((time.time() - start_time) * 1000)
+    results, latency = run_search_function_and_time(query, search_vector_with_expansion)
+    semantic_match = get_average_score(results)
 
     metrics = {
-        "semantic_match": 0.81,
-        "latency_ms": max(150, latency),
+        "semantic_match": semantic_match,
+        "latency_ms": latency,
     }
 
-    return format_results(results, "Stage 3: + Query Expansion", metrics), metrics
+    return format_results(results[:5], "Stage 3: Query Expansion", metrics), metrics
 
 
 def search_stage_4(query: str) -> Tuple[str, Dict]:

src/config.py

@@ -2,7 +2,7 @@ import gradio as gr
 
 # Fireworks AI Model Configuration
 EMBEDDING_MODEL = "accounts/fireworks/models/qwen3-embedding-8b"
-LLM_MODEL = "accounts/fireworks/models/llama-v3p1-8b-instruct"
+LLM_MODEL = "accounts/fireworks/models/qwen3-8b"
 RERANKER_MODEL = "fireworks/qwen3-reranker-8b"
 
 GRADIO_THEME = gr.themes.Base(
@@ -187,27 +187,27 @@ summary:hover {
 EXAMPLE_QUERIES_BY_CATEGORY = {
     "Toys & Games": {
         "clear": "magnetic construction building blocks educational toy",
-        "somewhat_ambiguous": "learning toy for preschool kids",
-        "ambiguous": "fun gift for child",
+        "somewhat_ambiguous": "creative play for young children",
+        "ambiguous": "keep kids busy",
     },
     "Home & Kitchen": {
         "clear": "kids octopus comforter bedding set full size",
-        "somewhat_ambiguous": "colorful bedding set for children",
-        "ambiguous": "bedroom decoration items",
+        "somewhat_ambiguous": "cozy items for child's room",
+        "ambiguous": "make bedroom nicer",
     },
     "Clothing, Shoes & Jewelry": {
         "clear": "star wars stormtrooper halloween costume kids",
-        "somewhat_ambiguous": "character costume for children",
-        "ambiguous": "dress up outfit",
+        "somewhat_ambiguous": "pretend play clothing",
+        "ambiguous": "halloween party",
     },
     "Sports & Outdoors": {
         "clear": "55 inch trampoline with safety net enclosure",
-        "somewhat_ambiguous": "small trampoline for children",
-        "ambiguous": "backyard play equipment",
+        "somewhat_ambiguous": "active outdoor toy",
+        "ambiguous": "yard activity",
     },
     "Baby Products": {
         "clear": "nursery wall decor quotes motivational stickers",
-        "somewhat_ambiguous": "wall decorations for baby room",
-        "ambiguous": "cute nursery items",
+        "somewhat_ambiguous": "baby room essentials",
+        "ambiguous": "expecting soon",
     },
 }

src/fireworks/inference.py

@@ -1,11 +1,21 @@
 import os
+import yaml
 from openai import OpenAI
 from dotenv import load_dotenv
 from typing import List
-from src.config import EMBEDDING_MODEL
+from pathlib import Path
+from src.config import EMBEDDING_MODEL, LLM_MODEL
 
 load_dotenv()
 
+_FILE_PATH = Path(__file__).parents[2]
+
+
+def load_prompt_library():
+    """Load prompts from YAML configuration."""
+    with open(_FILE_PATH / "configs" / "prompt_library.yaml", "r") as f:
+        return yaml.safe_load(f)
+
 
 def create_client(api_key: str = None) -> OpenAI:
     """
@@ -19,10 +29,49 @@ def create_client(api_key: str = None) -> OpenAI:
     )
 
 
+CLIENT = create_client()
+PROMPT_LIBRARY = load_prompt_library()
+
+
 def get_embedding(text: str) -> List[float]:
     """
-    Get embedding for a given text
+    Get embedding for a given text using Fireworks AI embedding model.
+
+    Args:
+        text: Input text to embed
+
+    Returns:
+        List of float values representing the embedding vector
     """
-    client = create_client()
-    response = client.embeddings.create(model=EMBEDDING_MODEL, input=text)
+    response = CLIENT.embeddings.create(model=EMBEDDING_MODEL, input=text)
     return response.data[0].embedding
+
+
+def expand_query(query: str) -> str:
+    """
+    Expand a search query using LLM with few-shot prompting.
+
+    Takes a user's search query and expands it with relevant terms, synonyms,
+    and related concepts to improve search recall and relevance.
+
+    Args:
+        query: Original search query
+
+    Returns:
+        Expanded query string with additional relevant terms
+    """
+    system_prompt = PROMPT_LIBRARY["query_expansion"]["system_prompt"]
+
+    response = CLIENT.chat.completions.create(
+        model=LLM_MODEL,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": query},
+        ],
+        temperature=0.3,
+        max_tokens=100,
+        reasoning_effort="none",
+    )
+
+    expanded = response.choices[0].message.content.strip()
+    return expanded

src/search/vector_search.py

@@ -2,7 +2,7 @@ import numpy as np
 import faiss
 from typing import List, Dict
 from pathlib import Path
-from src.fireworks.inference import get_embedding
+from src.fireworks.inference import get_embedding, expand_query
 from constants.constants import FAISS_INDEX, PRODUCTS_DF
 
 _FILE_PATH = Path(__file__).parents[2]
@@ -25,13 +25,8 @@ def search_vector(query: str, top_k: int = 10) -> List[Dict[str, any]]:
     query_embedding = get_embedding(query)
     query_vector = np.array([query_embedding], dtype=np.float32)
 
-    # Normalize query vector for cosine similarity
     faiss.normalize_L2(query_vector)
-
-    # Unpack FAISS index tuple (index, embeddings)
     faiss_index = FAISS_INDEX[0]
-
-    # Search FAISS index
     distances, indices = faiss_index.search(query_vector, top_k)
 
     # Convert L2 distances to similarity scores (0-1 range)
@@ -49,3 +44,23 @@ def search_vector(query: str, top_k: int = 10) -> List[Dict[str, any]]:
         }
         for idx, score in zip(indices[0], similarity_scores)
     ]
+
+
+def search_vector_with_expansion(query: str, top_k: int = 10) -> List[Dict[str, any]]:
+    """
+    Search products using vector embeddings and FAISS for semantic search with query expansion.
+
+    This is Stage 3: semantic search using vector embeddings to understand
+    query meaning and intent beyond exact keyword matching, with query expansion.
+
+    Args:
+        query: Search query string
+        top_k: Number of top results to return (default: 10)
+
+    Returns:
+        List of dictionaries containing product information and scores
+    """
+    expanded_query = expand_query(query)
+    print(f"Original: {query}")
+    print(f"Expanded: {expanded_query}")
+    return search_vector(expanded_query, top_k)