Verse Reading

# From main.py:24-56
def load_all_verses_from_pinecone() -> list[dict]:
    """Load all verses from Pinecone vector database"""
    try:
        verses = []
        # Pinecone doesn't have a "fetch all" - we query with a dummy vector and high top_k
        # Since we have ~700 verses, we fetch in batches by chapter
        for chapter_num in range(1, 19):
            logging.info(f"Fetching chapter {chapter_num} from Pinecone...")
            results = index.query(
                vector=[0] * EMBEDDING_DIMENSION,
                top_k=100,  # Max verses per chapter is 78 (chapter 18)
                include_metadata=True,
                filter={"chapter": chapter_num},
            )
            logging.info(f"Chapter {chapter_num}: got {len(results['matches'])} verses")

            for match in results["matches"]:
                meta = match["metadata"]
                verses.append(
                    {
                        "chapter": meta["chapter"],
                        "verse": meta["verse"],
                        "translation": meta["translation"],
                        "summary": meta.get("summary", "")[:500],
                    }
                )

        # Sort by chapter and verse
        verses.sort(key=lambda v: (v["chapter"], v["verse"]))
        return verses
    except Exception as e:
        logging.error(f"Failed to load verses from Pinecone: {e}")
        return []

# From main.py:59-74
@asynccontextmanager
async def lifespan(app: FastAPI):
    global all_verses_cache
    # Load all verses from Pinecone on startup
    logging.info("Loading all verses from Pinecone...")
    all_verses_cache = load_all_verses_from_pinecone()
    logging.info(f"Loaded {len(all_verses_cache)} verses")

    # Load model on startup (before any requests)
    logging.info("Loading embedding model...")
    from clients import embedding_model

    # Warm up the model with a dummy query
    embedding_model.encode("warmup")
    logging.info("Model loaded and ready!")
    yield

# From main.py:166-174
@app.get("/api/all-verses")
@limiter.limit("10/minute")
async def get_all_verses(request: Request):
    """
    Get all verses for client-side search.
    Returns chapter, verse, translation, and summary for all 703 verses.
    """
    return {"status": "success", "data": all_verses_cache}

{
  "status": "success",
  "data": [
    {
      "chapter": 1,
      "verse": 1,
      "translation": "Dhritarashtra said: O Sanjaya...",
      "summary": "King Dhritarashtra inquires about..."
    },
    // ... 702 more verses
  ]
}

# From main.py:146-163
@app.post("/api/verse", response_model=dict)
@limiter.limit("30/minute")
async def get_specific_verse(request: Request, verse_req: VerseRequest) -> dict:
    """
    Get a specific verse by chapter and verse number.
    """
    try:
        from model import get_verse

        result = get_verse(verse_req.chapter, verse_req.verse)
        if not result:
            raise HTTPException(status_code=404, detail="Verse not found")
        return {"status": "success", "data": result}
    except HTTPException:
        raise
    except Exception as e:
        logging.error(f"Error fetching verse: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal Server Error")

# From main.py:105-107
class VerseRequest(BaseModel):
    chapter: int = Field(..., ge=1, le=18)
    verse: int = Field(..., ge=1, le=78)

# From model.py:10-33
def get_verse(chapter: int, verse: int):
    """Fetch a specific verse by chapter and verse number."""
    # Query Pinecone for the specific verse using metadata filter
    results = index.query(
        vector=[0] * EMBEDDING_DIMENSION,  # Dummy vector, we're filtering by metadata
        top_k=1,
        include_metadata=True,
        filter={"chapter": chapter, "verse": verse},
    )

    if not results["matches"]:
        return None

    metadata = results["matches"][0]["metadata"]
    result = {
        "chapter": metadata["chapter"],
        "verse": metadata["verse"],
        "translation": metadata["translation"],
        "summarized_commentary": metadata.get("summary", ""),
    }
    # Include full commentary if available
    if "commentary" in metadata and metadata["commentary"]:
        result["full_commentary"] = metadata["commentary"]
    return result

# From utils.py:12-31
def summarize(commentary_text: str) -> str:
    """Generate a summary of the commentary using GPT-4o-mini."""
    if not commentary_text or len(commentary_text) < 10:
        return ""

    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant that summarizes text concisely but completely.",
            },
            {
                "role": "user",
                "content": f"Summarize the following commentary: {commentary_text}",
            },
        ],
        max_tokens=500,
    )
    return response.choices[0].message.content.strip()

# From main.py:30-38
for chapter_num in range(1, 19):
    logging.info(f"Fetching chapter {chapter_num} from Pinecone...")
    results = index.query(
        vector=[0] * EMBEDDING_DIMENSION,
        top_k=100,  # Max verses per chapter is 78 (chapter 18)
        include_metadata=True,
        filter={"chapter": chapter_num},
    )
    logging.info(f"Chapter {chapter_num}: got {len(results['matches'])} verses")

# From model.py:100-118
# Related verses (next 3 unique verses)
related = []
seen = {(best["chapter"], best["verse"])}
for match in semantic_matches[1:]:
    key = (match["chapter"], match["verse"])
    if key not in seen:
        related.append(
            {
                "chapter": match["chapter"],
                "verse": match["verse"],
                "translation": match["translation"],
                "summarized_commentary": match["summary"],
            }
        )
        seen.add(key)
        if len(related) >= 3:
            break

main_result["related"] = related

703 verses × ~2KB per verse (with summary) = ~1.4MB total

# From main.py:20-21
# Cache for all verses (loaded once on startup)
all_verses_cache: list[dict] = []

[
  {
    "chapter": 1,
    "verse": 1,
    "translation": "...",
    "summary": "..."  # Truncated to 500 chars
  },
  # ... 702 more verses
]

{
  "chapter": 2,
  "verse": 47,
  "translation": "You have a right to perform your prescribed duties...",
  "summarized_commentary": "This verse teaches the principle of karma yoga...",
  "full_commentary": "In this verse, Lord Krishna instructs Arjuna about..."  # Optional
}

# From main.py:155-157
result = get_verse(verse_req.chapter, verse_req.verse)
if not result:
    raise HTTPException(status_code=404, detail="Verse not found")

# From main.py:105-107
class VerseRequest(BaseModel):
    chapter: int = Field(..., ge=1, le=18)
    verse: int = Field(..., ge=1, le=78)

# From main.py:116 and 167
@limiter.limit("30/minute")  # Search queries
@limiter.limit("10/minute")  # All verses fetch

vector=[0] * EMBEDDING_DIMENSION  # All zeros