Add Files

.dockerignore

@@ -0,0 +1,26 @@
+.git
+.gitignore
+README.md
+DEPLOYMENT.md
+render.yaml
+start.sh
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis 

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,61 @@
+# Environment variables
+.env
+.env.local
+.env.production
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.cache
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.temp
+
+# FAISS index files
+*.index
+*.faiss
+
+# PDF files (if you don't want to commit them)
+*.pdf 
+
+DEPLOYMENT.md

Dockerfile

@@ -0,0 +1,39 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    tesseract-ocr \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    poppler-utils \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN useradd --create-home --shell /bin/bash appuser
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create cache directory with proper permissions
+RUN mkdir -p /app/.cache && chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"] 

app.py

@@ -0,0 +1,244 @@
+import os
+import warnings
+import logging
+import time
+import json
+import hashlib
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+from threading import Lock
+
+# Set up cache directory for HuggingFace models
+cache_dir = os.path.join(os.getcwd(), ".cache")
+os.makedirs(cache_dir, exist_ok=True)
+os.environ['HF_HOME'] = cache_dir
+os.environ['TRANSFORMERS_CACHE'] = cache_dir
+
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+os.environ['TF_LOGGING_LEVEL'] = 'ERROR'
+os.environ['TF_ENABLE_DEPRECATION_WARNINGS'] = '0'
+
+warnings.filterwarnings('ignore', category=DeprecationWarning, module='tensorflow')
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+from fastapi import FastAPI, HTTPException, Depends, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from pdf_parser import parse_pdf_from_url_multithreaded as parse_pdf_from_url, parse_pdf_from_file_multithreaded as parse_pdf_from_file
+from embedder import build_faiss_index, preload_model
+from retriever import retrieve_chunks
+from llm import query_gemini
+import uvicorn
+
+app = FastAPI(title="HackRx Insurance Policy Assistant", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.on_event("startup")
+async def startup_event():
+    print("Starting up HackRx Insurance Policy Assistant...")
+    print("Preloading sentence transformer model...")
+    preload_model()
+    print("Model preloading completed. API is ready to serve requests!")
+
+@app.get("/")
+async def root():
+    return {"message": "HackRx Insurance Policy Assistant API is running!"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+class QueryRequest(BaseModel):
+    documents: str
+    questions: list[str]
+
+class LocalQueryRequest(BaseModel):
+    document_path: str
+    questions: list[str]
+
+def verify_token(authorization: str = Header(None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Invalid authorization header")
+    token = authorization.replace("Bearer ", "")
+    if not token:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    return token
+
+def process_batch(batch_questions, context_chunks):
+    return query_gemini(batch_questions, context_chunks)
+
+def get_document_id_from_url(url: str) -> str:
+    return hashlib.md5(url.encode()).hexdigest()
+
+# Document cache with thread safety
+doc_cache = {}
+doc_cache_lock = Lock()
+
+@app.post("/api/v1/hackrx/run")
+async def run_query(request: QueryRequest, token: str = Depends(verify_token)):
+    start_time = time.time()
+    timing_data = {}
+    try:
+        print("=== INPUT JSON ===")
+        print(json.dumps({"documents": request.documents, "questions": request.questions}, indent=2))
+        print("==================\n")
+
+        print(f"Processing {len(request.questions)} questions...")
+
+        # PDF Parsing and FAISS Caching
+        doc_id = get_document_id_from_url(request.documents)
+        with doc_cache_lock:
+            if doc_id in doc_cache:
+                print("✅ Using cached document...")
+                cached = doc_cache[doc_id]
+                text_chunks = cached["chunks"]
+                index = cached["index"]
+                texts = cached["texts"]
+            else:
+                print("⚙️ Parsing and indexing new document...")
+                pdf_start = time.time()
+                text_chunks = parse_pdf_from_url(request.documents)
+                timing_data['pdf_parsing'] = round(time.time() - pdf_start, 2)
+
+                index_start = time.time()
+                index, texts = build_faiss_index(text_chunks)
+                timing_data['faiss_index_building'] = round(time.time() - index_start, 2)
+
+                doc_cache[doc_id] = {
+                    "chunks": text_chunks,
+                    "index": index,
+                    "texts": texts
+                }
+
+        # Chunk Retrieval
+        retrieval_start = time.time()
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        timing_data['chunk_retrieval'] = round(time.time() - retrieval_start, 2)
+        print(f"Retrieved {len(all_chunks)} unique chunks")
+
+        # LLM Batch Processing
+        questions = request.questions
+        context_chunks = list(all_chunks)
+        batch_size = 10
+        batches = [(i, questions[i:i + batch_size]) for i in range(0, len(questions), batch_size)]
+
+        llm_start = time.time()
+        results_dict = {}
+        with ThreadPoolExecutor(max_workers=min(5, len(batches))) as executor:
+            futures = [executor.submit(process_batch, batch, context_chunks) for _, batch in batches]
+            for (start_idx, batch), future in zip(batches, futures):
+                try:
+                    result = future.result()
+                    if isinstance(result, dict) and "answers" in result:
+                        for j, answer in enumerate(result["answers"]):
+                            results_dict[start_idx + j] = answer
+                    else:
+                        for j in range(len(batch)):
+                            results_dict[start_idx + j] = "Error in response"
+                except Exception as e:
+                    for j in range(len(batch)):
+                        results_dict[start_idx + j] = f"Error: {str(e)}"
+        timing_data['llm_processing'] = round(time.time() - llm_start, 2)
+
+        responses = [results_dict.get(i, "Not Found") for i in range(len(questions))]
+        timing_data['total_time'] = round(time.time() - start_time, 2)
+
+        print(f"\n=== TIMING BREAKDOWN ===")
+        for k, v in timing_data.items():
+            print(f"{k}: {v}s")
+        print(f"=======================\n")
+
+        print(f"=== OUTPUT JSON ===")
+        print(json.dumps({"answers": responses}, indent=2))
+        print(f"==================\n")
+
+        return {"answers": responses}
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@app.post("/api/v1/hackrx/local")
+async def run_local_query(request: LocalQueryRequest):
+    start_time = time.time()
+    timing_data = {}
+    try:
+        print("=== INPUT JSON ===")
+        print(json.dumps({"document_path": request.document_path, "questions": request.questions}, indent=2))
+        print("==================\n")
+
+        print(f"Processing {len(request.questions)} questions locally...")
+
+        pdf_start = time.time()
+        text_chunks = parse_pdf_from_file(request.document_path)
+        timing_data['pdf_parsing'] = round(time.time() - pdf_start, 2)
+        print(f"Extracted {len(text_chunks)} text chunks from PDF")
+
+        index_start = time.time()
+        index, texts = build_faiss_index(text_chunks)
+        timing_data['faiss_index_building'] = round(time.time() - index_start, 2)
+
+        retrieval_start = time.time()
+        all_chunks = set()
+        for question in request.questions:
+            top_chunks = retrieve_chunks(index, texts, question)
+            all_chunks.update(top_chunks)
+        timing_data['chunk_retrieval'] = round(time.time() - retrieval_start, 2)
+        print(f"Retrieved {len(all_chunks)} unique chunks")
+
+        questions = request.questions
+        context_chunks = list(all_chunks)
+        batch_size = 20
+        batches = [(i, questions[i:i + batch_size]) for i in range(0, len(questions), batch_size)]
+
+        llm_start = time.time()
+        results_dict = {}
+        with ThreadPoolExecutor(max_workers=min(5, len(batches))) as executor:
+            futures = [executor.submit(process_batch, batch, context_chunks) for _, batch in batches]
+            for (start_idx, batch), future in zip(batches, futures):
+                try:
+                    result = future.result()
+                    if isinstance(result, dict) and "answers" in result:
+                        for j, answer in enumerate(result["answers"]):
+                            results_dict[start_idx + j] = answer
+                    else:
+                        for j in range(len(batch)):
+                            results_dict[start_idx + j] = "Error in response"
+                except Exception as e:
+                    for j in range(len(batch)):
+                        results_dict[start_idx + j] = f"Error: {str(e)}"
+        timing_data['llm_processing'] = round(time.time() - llm_start, 2)
+
+        responses = [results_dict.get(i, "Not Found") for i in range(len(questions))]
+        timing_data['total_time'] = round(time.time() - start_time, 2)
+
+        print(f"\n=== TIMING BREAKDOWN ===")
+        for k, v in timing_data.items():
+            print(f"{k}: {v}s")
+        print(f"=======================\n")
+
+        print(f"=== OUTPUT JSON ===")
+        print(json.dumps({"answers": responses}, indent=2))
+        print(f"==================\n")
+
+        return {"answers": responses}
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run("app:app", host="0.0.0.0", port=port)

embedder.py

@@ -0,0 +1,45 @@
+import faiss
+import numpy as np
+import os
+from sentence_transformers import SentenceTransformer
+
+cache_dir = os.path.join(os.getcwd(), ".cache")
+os.makedirs(cache_dir, exist_ok=True)
+os.environ['HF_HOME'] = cache_dir
+os.environ['TRANSFORMERS_CACHE'] = cache_dir
+
+_model = None
+
+def preload_model(model_name="paraphrase-MiniLM-L3-v2"):
+    global _model
+    if _model is not None:
+        return _model
+
+    print(f"Preloading sentence transformer model: {model_name}...")
+    try:
+        _model = SentenceTransformer(model_name, cache_folder=cache_dir)
+    except Exception as e:
+        print(f"Primary model load failed: {e}")
+        fallback_name = "sentence-transformers/" + model_name
+        print(f"Trying fallback: {fallback_name}")
+        _model = SentenceTransformer(fallback_name, cache_folder=cache_dir)
+
+    print("✅ Model ready.")
+    return _model
+
+def get_model():
+    return preload_model()
+
+def build_faiss_index(chunks, batch_size=128, show_progress_bar=False):
+    model = get_model()
+    embeddings = model.encode(
+        chunks,
+        batch_size=batch_size,
+        show_progress_bar=show_progress_bar,
+        convert_to_numpy=True,
+        normalize_embeddings=True
+    )
+    dim = embeddings.shape[1]
+    index = faiss.IndexFlatL2(dim)
+    index.add(embeddings)
+    return index, chunks

llm.py

@@ -0,0 +1,122 @@
+import google.generativeai as genai
+import os
+import json
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Support multiple Gemini keys (comma-separated or single key)
+api_keys = os.getenv("GOOGLE_API_KEYS") or os.getenv("GOOGLE_API_KEY")
+if not api_keys:
+    raise ValueError("No Gemini API keys found in GOOGLE_API_KEYS or GOOGLE_API_KEY environment variable.")
+
+api_keys = [k.strip() for k in api_keys.split(",") if k.strip()]
+print(f"Loaded {len(api_keys)} Gemini API key(s)")
+
+def query_gemini(questions, contexts, max_retries=3):
+    import itertools
+
+    context = "\n\n".join(contexts)
+    questions_text = "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
+
+    prompt = f"""
+You are an expert insurance assistant responsible for drafting formal, policy-aligned answers to user questions. Each response must follow structured formatting, proper terminology, and clean grammar. The tone must reflect official insurance documentation but remain simple and understandable to any reader.
+
+FORMAT & STYLE GUIDELINES:
+
+- Use third-person professional language only. Avoid “you”, “we”, or “policyholder”.
+- Begin answers with “Yes,” “No,” or “Can apply” where applicable.
+- Each answer must contain 2–3 clear sentences, each with a defined role:
+  1. First sentence: Direct answer (Yes/No/Definition).
+  2. Second sentence: Clarification, eligibility, limits, or conditions.
+  3. Optional third (if needed): Legal basis or policy clause (e.g., specific Act, PPN rule).
+- Write numbers in word–digit format (e.g., “thirty-six (36) months”).
+- Use formal but human-readable insurance terms (e.g., “Sum Insured”, “grace period”, “renewal”, “direct complications”, “capped”, “continuous coverage”).
+- Avoid passive constructions unless required by tone. Use precise, subject-led sentences.
+- Maintain consistency in describing timeframes and benefits:
+  - “A grace period of thirty (30) days is provided…”
+  - “The benefit is limited to two (2) deliveries during the policy period.”
+- Always include limits, duration, eligibility, and conditions, when relevant.
+
+STRUCTURED ANSWERING BEHAVIOR:
+
+- If an answer is Yes/No/Conditional:
+  - Start with that term and follow up with explanation.
+- If the answer defines a feature (e.g., "What is hospital?"):
+  - Start with the clean definition.
+- Never elaborate with theory, history, or deep medical details.
+- Do not repeat terms or explain known insurance concepts.
+- Avoid vague statements — prefer clarity: "is capped at", "must be", "is covered under", etc.
+
+DO NOT:
+
+- Say “according to the document” or “based on context”.
+- Use markdown, emojis, or formatting symbols like %, ₹, or bullets.
+- Give long explanations, bullet points, or repeat words/ideas.
+- Mention “context”, “source”, or “document” at all.
+- Use uncertain or filler language (e.g., “It might”, “It appears”, “It could be”).
+
+✅ DO:
+- Write in clean, informative language.
+- Give complete answers in 2–3 sentences maximum.
+
+📝 EXAMPLE ANSWERS:
+- "Yes, the policy covers damage to personal property caused by fire, up to a limit of $50,000."
+- "No, the policy does not cover pre-existing conditions."
+- "The waiting period for coverage to begin is 30 days from the start date of the policy."
+
+📤 OUTPUT FORMAT (strict):
+Respond with only the following JSON — no explanations, no comments, no markdown:
+
+{{
+  "answers": [
+    "Answer to question 1",
+    "Answer to question 2",
+    ...
+  ]
+}}
+
+
+📚 CONTEXT:
+{context}
+
+❓ QUESTIONS:
+{questions_text}
+
+Your task: For each question, provide a complete, professional, and clearly written answer in 2–3 sentences using a formal but readable tone.
+"""
+
+    last_exception = None
+    total_attempts = len(api_keys) * max_retries
+    key_cycle = itertools.cycle(api_keys)
+
+    for attempt in range(total_attempts):
+        key = next(key_cycle)
+        try:
+            genai.configure(api_key=key)
+            model = genai.GenerativeModel("gemini-2.5-flash-lite")
+            response = model.generate_content(prompt)
+            response_text = getattr(response, "text", "").strip()
+
+            if not response_text:
+                raise ValueError("Empty response received from Gemini API.")
+
+            if response_text.startswith("```json"):
+                response_text = response_text.replace("```json", "").replace("```", "").strip()
+            elif response_text.startswith("```"):
+                response_text = response_text.replace("```", "").strip()
+
+            parsed = json.loads(response_text)
+            if "answers" in parsed and isinstance(parsed["answers"], list):
+                return parsed
+            else:
+                raise ValueError("Invalid response format received from Gemini.")
+
+        except Exception as e:
+            last_exception = e
+            msg = str(e).lower()
+            print(f"[Retry {attempt+1}/{total_attempts}] Gemini key {key[:8]}... failed: {e}")
+            continue
+
+    print(f"All Gemini API attempts failed. Last error: {last_exception}")
+    return {"answers": [f"Error generating response: {str(last_exception)}"] * len(questions)}

pdf_parser.py

@@ -0,0 +1,86 @@
+import fitz  # PyMuPDF
+import requests
+from io import BytesIO
+from concurrent.futures import ThreadPoolExecutor
+from PIL import Image
+import pytesseract
+import imghdr
+
+def _extract_text(page):
+    text = page.get_text()
+    return text.strip() if text and text.strip() else None
+
+def is_image(content):
+    return imghdr.what(None, h=content) in ["jpeg", "png", "bmp", "gif", "tiff", "webp"]
+
+def extract_text_from_image_bytes(image_bytes):
+    image = Image.open(BytesIO(image_bytes))
+    return pytesseract.image_to_string(image).strip()
+
+def parse_pdf_from_url_multithreaded(url, max_workers=2, chunk_size=1):
+    """
+    Download document (PDF or Image) from URL, extract text accordingly.
+    Gracefully return fallback message if unsupported or failed.
+    """
+    try:
+        res = requests.get(url)
+        content = res.content
+        content_type = res.headers.get("content-type", "").lower()
+    except Exception as e:
+        print(f"❌ Failed to download: {str(e)}")
+        return [f"No data found in this document (download error)"]
+
+    # Check for unsupported content
+    if "zip" in content_type or url.endswith(".zip"):
+        return ["No data found in this document (zip)"]
+    if "octet-stream" in content_type or url.endswith(".bin"):
+        return ["No data found in this document (bin)"]
+
+    # OCR for image files
+    if "image" in content_type or is_image(content):
+        print("📷 Detected image file. Using OCR...")
+        try:
+            text = extract_text_from_image_bytes(content)
+            return [text] if text else ["No data found in this document (image empty)"]
+        except Exception as e:
+            print(f"❌ OCR failed: {str(e)}")
+            return [f"No data found in this document (image/OCR error)"]
+
+    # Try PDF fallback
+    try:
+        with fitz.open(stream=BytesIO(content), filetype="pdf") as doc:
+            pages = list(doc)
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                texts = list(executor.map(_extract_text, pages))
+            if chunk_size > 1:
+                chunks = []
+                for i in range(0, len(texts), chunk_size):
+                    chunk = ' '.join([t for t in texts[i:i+chunk_size] if t])
+                    if chunk:
+                        chunks.append(chunk)
+                return chunks if chunks else ["No data found in this document (empty PDF)"]
+            return [t for t in texts if t] or ["No data found in this document (empty PDF)"]
+    except Exception as e:
+        print(f"❌ Failed to parse as PDF: {str(e)}")
+        return [f"No data found in this document (not PDF or corrupted)"]
+
+def parse_pdf_from_file_multithreaded(file_path, max_workers=2, chunk_size=1):
+    """
+    Parse a local PDF file, extract text in parallel, optionally chunk pages.
+    """
+    try:
+        with fitz.open(file_path) as doc:
+            pages = list(doc)
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                texts = list(executor.map(_extract_text, pages))
+            if chunk_size > 1:
+                chunks = []
+                for i in range(0, len(texts), chunk_size):
+                    chunk = ' '.join([t for t in texts[i:i+chunk_size] if t])
+                    if chunk:
+                        chunks.append(chunk)
+                return chunks if chunks else ["No data found in this document (local PDF empty)"]
+            return [t for t in texts if t] or ["No data found in this document (local PDF empty)"]
+    except Exception as e:
+        print(f"❌ Failed to open local file: {str(e)}")
+        return [f"No data found in this document (local file error)"]

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+requests
+faiss-cpu
+sentence-transformers
+PyMuPDF
+python-dotenv
+tf-keras
+google-generativeai
+pytesseract
+Pillow
+

retriever.py

@@ -0,0 +1,11 @@
+from sentence_transformers.util import cos_sim
+from embedder import get_model
+import numpy as np
+
+def retrieve_chunks(index, texts, question, top_k=15):
+    model = get_model()
+    q_embedding = model.encode([question], convert_to_numpy=True, normalize_embeddings=True)[0]
+
+    scores, indices = index.search(np.array([q_embedding]), top_k)
+    selected = [texts[i] for i in indices[0]]
+    return selected