Upload 9 files

.env

@@ -0,0 +1,4 @@
+GROQ_API_KEY=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
+NEO4J_URI=neo4j+ssc://3c78cdc0.databases.neo4j.io
+NEO4J_USERNAME=neo4j
+NEO4J_PASSWORD=janN8bYGdza3cFfE3J30goS23zsXOjfw-ajfTe0VXSo

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -0,0 +1,28 @@
+# Use official Python runtime
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install python dependencies - explicit copy for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY chatbot.py .
+COPY ingest.py .
+
+# Expose port (Hugging Face Spaces uses 7860 by default)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "chatbot:app", "--host", "0.0.0.0", "--port", "7860"]

chatbot.py

@@ -0,0 +1,316 @@
+"""
+Hybrid RAG Chatbot for Jain Philosophy
+Features:
+1. Neo4j Graph + Vector Search for Book Knowledge
+2. Fallback to LLM Internal Knowledge (Llama 3.3) if needed
+3. Uses llama-3.3-70b-versatile model
+"""
+
+import os
+import sys
+from typing import List, Dict, Optional
+from dotenv import load_dotenv
+from neo4j import GraphDatabase
+from sentence_transformers import SentenceTransformer
+from groq import Groq
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+
+# Force UTF-8 output on Windows
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+load_dotenv()
+
+# Configuration
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_AUTH = (os.getenv("NEO4J_USERNAME", "neo4j"), os.getenv("NEO4J_PASSWORD", "password"))
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+# Term mappings
+TERM_MAPPINGS = {
+    "anekantavada": ["Anekāntavāda", "Anekānta", "non-absolutism"],
+    "syadvada": ["Syādvāda", "Syād", "conditional predication"],
+    "saptabhangi": ["Saptabhaṅgī", "seven-fold predication"],
+    "naya": ["Nayas", "viewpoints", "7 Naya"],
+    "gunasthana": ["Guṇasthānaka", "stages of spiritual development"],
+    "tirthankara": ["Tīrthaṅkara", "Jina", "Arihanta"],
+    "mahavira": ["Mahāvīra", "Vardhamana"],
+    "jiva": ["Jīvāstikāya", "soul"],
+    "ajiva": ["Ajīva", "non-soul"],
+    "karma": ["Karma", "karmic matter"],
+}
+
+# Initialize FastAPI
+app = FastAPI(title="Jain Philosophy Chatbot API")
+
+# Allow CORS for testing
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatRequest(BaseModel):
+    query: str
+
+class ChatResponse(BaseModel):
+    answer: str
+
+# Global resources
+resources = {}
+
+def get_resources():
+    """Lazy load resources"""
+    if not resources:
+        if not GROQ_API_KEY:
+            raise ValueError("GROQ_API_KEY is not set in .env file or environment variables")
+            
+        try:
+            driver = GraphDatabase.driver(NEO4J_URI, auth=NEO4J_AUTH)
+            driver.verify_connectivity()
+            embedder = SentenceTransformer('all-mpnet-base-v2')
+            retriever = HybridRetriever(driver, embedder)
+            client = Groq(api_key=GROQ_API_KEY)
+            
+            resources['driver'] = driver
+            resources['retriever'] = retriever
+            resources['client'] = client
+            print("✓ Resources loaded")
+        except Exception as e:
+            print(f"✗ Error loading resources: {e}")
+            raise e
+    return resources
+
+def search_neo4j_comprehensive(driver, embedder, query: str) -> List[Dict]:
+    """
+    Enhanced Neo4j Search Strategy:
+    1. Concept Search (Fuzzy & Exact)
+    2. Vector Search (Chunks)
+    3. Keyword/Text Search (Fulltext)
+    4. Chapter/Section Title Search
+    """
+    expanded_terms = []
+    # Simple query expansion
+    query_lower = query.lower()
+    for term, variants in TERM_MAPPINGS.items():
+        if term in query_lower:
+            expanded_terms.extend(variants)
+    
+    embedding = embedder.encode(query).tolist()
+    chunks = []
+    
+    with driver.session() as session:
+        # 1. Concept Node Search (High Priority)
+        try:
+            result = session.run("""
+                CALL db.index.fulltext.queryNodes('concept_name_index', $q)
+                YIELD node, score
+                RETURN 
+                    'Concept: ' + node.name + ' (' + coalesce(node.category, 'General') + ')\n' + 
+                    'Variants: ' + coalesce(toString(node.variants), 'None') as text, 
+                    score + 1.0 as score
+                LIMIT 3
+            """, q=query)
+            chunks.extend([dict(r) for r in result])
+        except Exception: 
+            pass 
+
+        # 2. Gunasthana Specific Search
+        try:
+            result = session.run("""
+                MATCH (g:Gunasthana)
+                WHERE toLower(g.sanskrit_name) CONTAINS toLower($q) 
+                   OR toLower(g.english_name) CONTAINS toLower($q)
+                RETURN g.sanskrit_name + ' (' + g.english_name + ')\n' + g.description as text, 2.0 as score
+            """, q=query)
+            chunks.extend([dict(r) for r in result])
+        except: pass
+
+        # 3. Vector Search
+        indexes = ['chunk_embeddings', 'gunasthana_embeddings']
+        for idx in indexes:
+            try:
+                result = session.run(f"""
+                    CALL db.index.vector.queryNodes('{idx}', 7, $emb)
+                    YIELD node, score
+                    RETURN coalesce(node.text, node.description) as text, score
+                """, emb=embedding)
+                chunks.extend([dict(r) for r in result])
+            except: continue
+
+        # 4. Fulltext Keyword Search
+        lucene_query = query.replace("?", "").replace("!", "")
+        if lucene_query.strip():
+            try:
+                result = session.run("""
+                    CALL db.index.fulltext.queryNodes('chunk_text_index', $q)
+                    YIELD node, score
+                    RETURN node.text as text, score LIMIT 5
+                """, q=lucene_query)
+                chunks.extend([dict(r) for r in result])
+            except: pass
+
+        # 5. Structure/Chapter Search (Table of Contents)
+        # If the user asks for "chapters", "summary", "outline", "structure"
+        structure_keywords = ["chapter", "summary", "outline", "structure", "table of contents", "book"]
+        if any(k in query_lower for k in structure_keywords):
+            try:
+                # Fetch all chapters sorted by number
+                result = session.run("""
+                    MATCH (c:Chapter)
+                    RETURN c.number as number, c.title as title
+                    ORDER BY c.number ASC
+                """)
+                chapters = [f"Chapter {r['number']}: {r['title']}" for r in result]
+                if chapters:
+                    toc_text = "Book Table of Contents (All Chapters):\n" + "\n".join(chapters)
+                    chunks.append({
+                        "text": toc_text,
+                        "score": 2.5 # Very high relevance for structural questions
+                    })
+            except: pass
+
+    # Deduplicate and Sort
+    seen = set()
+    unique_chunks = []
+    
+    # Sort by score descending
+    for c in sorted(chunks, key=lambda x: x['score'], reverse=True):
+        content = c['text']
+        # Simple dedupe (using first 100 chars signature)
+        sig = content[:100] if content else ""
+        if sig and sig not in seen:
+            seen.add(sig)
+            unique_chunks.append(c)
+    
+    # Return top results. 
+    # If we have the TOC (score 2.5), it will be at the top.
+    return unique_chunks[:7]
+
+class HybridRetriever:
+    def __init__(self, driver, embedder):
+        self.driver = driver
+        self.embedder = embedder
+
+    def search_book(self, query: str) -> List[Dict]:
+        return search_neo4j_comprehensive(self.driver, self.embedder, query)
+
+def ask_jain_sage(user_query: str, retriever: HybridRetriever, client: Groq) -> str:
+    """
+    Call llama-3.3-70b-versatile directly with book context + internal knowledge fallback.
+    """
+    # 1. Retrieve from Book
+    book_chunks = retriever.search_book(user_query)
+    book_text = "\n\n".join([c['text'] for c in book_chunks])
+    
+    system_prompt = (
+        "You are an expert scholar on Jain philosophy. "
+        "Use the provided context from the book 'Anekant Syadvad' to answer the question. "
+        "If the book context is insufficient, use your own broad knowledge of Jainism and religion to answer comprehensively. "
+        "Do NOT mention 'According to the text' just give the answer naturally. "
+        "Always define Sanskrit terms."
+        "Ensure the response is logically structured, concise yet comprehensive, and suitable for both "
+        "academic and general readers."
+        "If the available book context is partial or insufficient, responsibly supplement the answer "
+        "using well-established principles of Jain philosophy and comparative religious knowledge, "
+        "without introducing speculation. "
+        "Whenever Sanskrit or Prakrit terms appear, always: "
+        "1) Write the term in standard IAST-style transliteration, "
+        "2) Clearly define the term in simple and precise language at its first occurrence. "
+        "Use the following transliteration standard consistently: "
+        "Vowels: "
+        "अ a, आ ā, इ i, ई ī, उ u, ऊ ū, ऋ ṛ, ए e, ऐ ai, ओ o, औ au, अं ṁ/ṅ, अः ḥ. "
+        "Consonants: "
+        "क् k, ख् kh, ग् g, घ् gh, ङ् ṅ; "
+        "च् c, छ् ch, ज् j, झ् jh, ञ् ñ; "
+        "ट् ṭ, ठ् ṭh, ड् ḍ, ढ् ḍh, ण् ṇ; "
+        "त् t, थ् th, द् d, ध् dh, न् n; "
+        "प् p, फ् ph, ब् b, भ् bh, म् m; "
+        "य् y, र् r, ल् l, व् v; "
+        "श् ś, ष् ṣ, स् s, ह् h. "
+    )
+
+    user_message_content = f"Context from Book:\n{book_text}\n\nQuestion: {user_query}"
+    
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_message_content}
+    ]
+
+    completion = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=messages,
+        temperature=0.5,
+        max_completion_tokens=2048,
+        top_p=0.95,
+    )
+
+    return completion.choices[0].message.content
+
+@app.on_event("startup")
+async def startup_event():
+    # Attempt to load resources on startup (useful for Render to fail early if missing env vars)
+    try:
+        get_resources()
+    except Exception as e:
+        print(f"Warning: Could not initialize resources on startup: {e}")
+
+@app.get("/")
+def read_root():
+    return {"status": "Jain Sage AI is API Ready", "endpoints": "/chat"}
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    try:
+        res = get_resources()
+        retriever = res['retriever']
+        client = res['client']
+        
+        answer = ask_jain_sage(request.query, retriever, client)
+        return ChatResponse(answer=answer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+def main():
+    print("="*60)
+    print("  Jain Philosophy AI Expert")
+    print("  (Neo4j Graph + Llama 3.3 Internal Knowledge)")
+    print("="*60)
+
+    try:
+        res = get_resources()
+        retriever = res['retriever']
+        client = res['client']
+    except Exception as e:
+        print(f"\n✗ Configuration Error: {e}")
+        return
+
+    # Loop
+    while True:
+        try:
+            q = input("\nQ: ").strip()
+            if q.lower() in ['exit', 'quit']: break
+            if not q: continue
+            
+            print("  Thinking...", end='\r')
+            ans = ask_jain_sage(q, retriever, client)
+            print(" "*30, end='\r')
+            print(f"A: {ans}\n")
+            
+        except KeyboardInterrupt:
+            break
+        except Exception as e:
+            print(f"\nError: {e}")
+
+    res['driver'].close()
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "run-server":
+        uvicorn.run(app, host="0.0.0.0", port=10000)
+    else:
+        main()

ingest.py

@@ -0,0 +1,540 @@
+"""
+Hybrid RAG Ingestion Pipeline for "Anekant Syadvad" - Jain Philosophy Book
+
+This script implements a sophisticated knowledge graph-based RAG system with:
+1. Hierarchical chunking (Book → Chapter → Section → Chunk)
+2. Rich metadata extraction
+3. Entity recognition for key Jain concepts
+4. Proper Unicode/transliteration handling
+5. Semantic embeddings with contextual overlap
+"""
+
+import os
+import re
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass, field
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+from neo4j import GraphDatabase
+from sentence_transformers import SentenceTransformer
+
+load_dotenv()
+
+# Configuration
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_AUTH = (os.getenv("NEO4J_USERNAME", "neo4j"), os.getenv("NEO4J_PASSWORD", "password"))
+FILE_PATH = "Anekant Syadvad - Final.txt"
+
+# Key Jain Philosophy Concepts for Entity Recognition
+JAIN_CONCEPTS = {
+    # Core Doctrines
+    "Anekāntavāda": ["Anekantavada", "Anekāntvāda", "Anekānta", "many-sidedness", "non-absolutism"],
+    "Syādvāda": ["Syadvada", "Syād", "conditional predication", "theory of conditioned predication"],
+    "Saptabhaṅgī": ["Saptabhangi", "seven-fold predication", "seven propositions"],
+    "Naya": ["Nayas", "viewpoints", "perspectives", "7 Naya", "seven viewpoints"],
+    
+    # Six Substances (Dravya)
+    "Jīvāstikāya": ["Jivastikaya", "Jīva", "Jiva", "soul", "living being", "consciousness"],
+    "Pudgalāstīkāya": ["Pudgalastikaya", "Pudgala", "matter"],
+    "Dharmāstikāya": ["Dharmastikaya", "Dharma", "motion principle"],
+    "Adharmāstikāya": ["Adharmastikaya", "Adharma", "rest principle"],
+    "Ākāśāstikāya": ["Akashastikaya", "Ākāṡa", "Akasha", "space"],
+    "Kāla": ["Kala", "time"],
+    
+    # Nine Tattvas
+    "Tattvas": ["Tattva", "nine elements", "fundamental principles"],
+    "Āsrava": ["Asrava", "influx of karma"],
+    "Bandha": ["Bandh", "bondage of karma"],
+    "Saṃvara": ["Samvara", "stoppage"],
+    "Nirjarā": ["Nirjara", "shedding of karma"],
+    "Mokṣa": ["Moksha", "liberation", "salvation"],
+    "Punya": ["merit", "good karma"],
+    "Pāpa": ["Papa", "demerit", "sin"],
+    
+    # Religious Terms
+    "Tīrthaṅkara": ["Tirthankara", "Tīrthankara", "Jina", "Arhat", "Arihaṅta"],
+    "Mahāvīra": ["Mahavira", "Vardhamana"],
+    "Ṛṣabhadeva": ["Rishabhadeva", "Adinatha", "first Tirthankara"],
+    "Karma": ["Karmas", "karmic matter"],
+    "Saṅgha": ["Sangha", "fourfold community"],
+    "Sādhu": ["Sadhu", "monk"],
+    "Sādhvī": ["Sadhvi", "nun"],
+    "Śrāvaka": ["Shravak", "layman"],
+    "Śrāvikā": ["Shravika", "laywoman"],
+    
+    # Types of Knowledge
+    "Kēvalajñāna": ["Kevala Jnana", "Kevalajnana", "omniscience", "absolute knowledge"],
+    "Mati Jñāna": ["Mati Jnana", "sensory knowledge"],
+    "Śruta Jñāna": ["Shruta Jnana", "scriptural knowledge"],
+    "Avadhi Jñāna": ["Avadhi Jnana", "clairvoyance"],
+    "Manaḥparyaya": ["Manahparyaya", "telepathy"],
+    
+    # Seven Nayas
+    "Naigama Naya": ["Naigama", "common viewpoint"],
+    "Saṅgraha Naya": ["Sangraha Naya", "collective viewpoint"],
+    "Vyavahāra Naya": ["Vyavahara Naya", "practical viewpoint"],
+    "Ṛjusūtra Naya": ["Rijusutra Naya", "linear viewpoint"],
+    "Śabda Naya": ["Shabda Naya", "verbal viewpoint"],
+    "Samabhirūḍha Naya": ["Samabhirudha Naya", "etymological viewpoint"],
+    "Evambhūta Naya": ["Evambhuta Naya", "actuality viewpoint"],
+    
+    # Practices
+    "Ahiṃsā": ["Ahimsa", "non-violence"],
+    "Anuvratas": ["Anuvrata", "small vows", "five vows"],
+    "Namaskāra Mahāmantra": ["Namaskar Mantra", "Navkar Mantra"],
+    "Guṇasthānaka": ["Gunasthana", "stages of spiritual development"],
+}
+
+# Chapter structure from the book's table of contents
+CHAPTERS = [
+    {"number": 1, "title": "The Quest for Truth", "start_page": 1, "end_page": 13},
+    {"number": 2, "title": "Perspectives and Paradoxes", "start_page": 14, "end_page": 19},
+    {"number": 3, "title": "Beyond Judgement", "start_page": 20, "end_page": 26},
+    {"number": 4, "title": "Jainism: A First Look", "start_page": 27, "end_page": 39},
+    {"number": 5, "title": "Religion and Philosophy", "start_page": 40, "end_page": 48},
+    {"number": 6, "title": "Anekāntavāda", "start_page": 49, "end_page": 65},
+    {"number": 7, "title": "Syādvāda", "start_page": 66, "end_page": 75},
+    {"number": 8, "title": "Four Bases", "start_page": 76, "end_page": 84},
+    {"number": 9, "title": "Five Reasons", "start_page": 85, "end_page": 100},
+    {"number": 10, "title": "Various aspects of Knowledge", "start_page": 101, "end_page": 115},
+    {"number": 11, "title": "7 Naya", "start_page": 116, "end_page": 139},
+    {"number": 12, "title": "A point of view", "start_page": 140, "end_page": 147},
+    {"number": 13, "title": "Saptabhaṅgī", "start_page": 148, "end_page": 167},
+    {"number": 14, "title": "Barrister Chakravarti", "start_page": 168, "end_page": 181},
+    {"number": 15, "title": "Five Types of Knowledge", "start_page": 182, "end_page": 198},
+    {"number": 16, "title": "Karma", "start_page": 199, "end_page": 222},
+    {"number": 17, "title": "Development of the Soul", "start_page": 223, "end_page": 256},
+    {"number": 18, "title": "Life is a hassle", "start_page": 257, "end_page": 282},
+    {"number": 19, "title": "Confirmation and Refutation", "start_page": 283, "end_page": 292},
+    {"number": 20, "title": "Namaskāra Mahāmantra", "start_page": 293, "end_page": 309},
+]
+
+
+class ChunkMetadata(BaseModel):
+    """Pydantic model for chunk metadata"""
+    chunk_id: str = Field(description="Unique identifier for the chunk")
+    chapter_number: int = Field(description="Chapter number (1-20)")
+    chapter_title: str = Field(description="Title of the chapter")
+    page_number: str = Field(description="Page number or range")
+    chunk_index: int = Field(description="Index of chunk within chapter")
+    total_chunks_in_chapter: int = Field(default=0, description="Total chunks in this chapter")
+    word_count: int = Field(description="Number of words in chunk")
+    has_sanskrit_terms: bool = Field(default=False, description="Whether chunk contains Sanskrit/transliterated terms")
+    key_concepts: List[str] = Field(default_factory=list, description="Key Jain concepts mentioned")
+    
+
+@dataclass
+class ProcessedChunk:
+    """Represents a processed text chunk with metadata"""
+    text: str
+    metadata: ChunkMetadata
+    embedding: List[float] = field(default_factory=list)
+
+
+def clean_text(text: str) -> str:
+    """Clean text while preserving Unicode/transliterated characters"""
+    # Remove form feed and other control characters
+    text = text.replace('\x0c', '')
+    text = text.replace('\x00', '')
+    
+    # Normalize whitespace but preserve paragraph breaks
+    text = re.sub(r'[ \t]+', ' ', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    
+    return text.strip()
+
+
+def extract_page_number(chunk: str) -> Optional[str]:
+    """Extract page number from chunk"""
+    lines = chunk.strip().split('\n')
+    if not lines:
+        return None
+    
+    last_line = lines[-1].strip()
+    
+    # Check for numeric page number
+    if last_line.isdigit() and len(last_line) <= 3:
+        return last_line
+    
+    # Check for Roman numerals (for front matter)
+    if re.match(r'^[ivxlcIVXLC]+$', last_line) and len(last_line) <= 5:
+        return last_line.lower()
+    
+    return None
+
+
+def identify_chapter(page_num: str) -> Optional[Dict]:
+    """Identify which chapter a page belongs to"""
+    try:
+        page_int = int(page_num)
+        for chapter in CHAPTERS:
+            if chapter["start_page"] <= page_int <= chapter["end_page"]:
+                return chapter
+    except (ValueError, TypeError):
+        pass
+    return None
+
+
+def extract_key_concepts(text: str) -> List[str]:
+    """Extract key Jain concepts from text"""
+    found_concepts = []
+    text_lower = text.lower()
+    
+    for main_term, variants in JAIN_CONCEPTS.items():
+        # Check main term (case-insensitive for ASCII, exact for Unicode)
+        if main_term.lower() in text_lower or main_term in text:
+            found_concepts.append(main_term)
+            continue
+        
+        # Check variants
+        for variant in variants:
+            if variant.lower() in text_lower:
+                found_concepts.append(main_term)
+                break
+    
+    return list(set(found_concepts))
+
+
+def has_transliterated_terms(text: str) -> bool:
+    """Check if text contains Sanskrit transliteration characters"""
+    transliteration_chars = set("āīūṛṅñṭḍṇśṣḥṁĀĪŪṚṄÑṬḌṆŚṢḤṀ")
+    return any(c in transliteration_chars for c in text)
+
+
+def semantic_chunk(text: str, max_chunk_size: int = 1500, overlap: int = 200) -> List[str]:
+    """
+    Semantic chunking that respects paragraph and sentence boundaries.
+    Uses a sliding window approach with overlap for context preservation.
+    """
+    # Split into paragraphs first
+    paragraphs = re.split(r'\n\n+', text)
+    
+    chunks = []
+    current_chunk = ""
+    
+    for para in paragraphs:
+        para = para.strip()
+        if not para:
+            continue
+        
+        # If adding this paragraph exceeds max size, save current chunk
+        if len(current_chunk) + len(para) + 2 > max_chunk_size and current_chunk:
+            chunks.append(current_chunk.strip())
+            
+            # Start new chunk with overlap from end of previous
+            words = current_chunk.split()
+            overlap_words = words[-overlap//10:] if len(words) > overlap//10 else words
+            current_chunk = " ".join(overlap_words) + "\n\n" + para
+        else:
+            if current_chunk:
+                current_chunk += "\n\n" + para
+            else:
+                current_chunk = para
+    
+    # Don't forget the last chunk
+    if current_chunk.strip():
+        chunks.append(current_chunk.strip())
+    
+    return chunks
+
+
+def parse_book(file_path: str) -> List[ProcessedChunk]:
+    """Parse the book into hierarchical chunks with rich metadata"""
+    print(f"Reading file: {file_path}")
+    
+    with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+        content = f.read()
+    
+    # Verify transliteration characters are present
+    test_chars = ["ā", "ī", "ū", "ṛ", "ṅ", "ś", "ṣ", "ḥ"]
+    found_chars = [c for c in test_chars if c in content]
+    print(f"✓ Found transliterated characters: {found_chars}")
+    
+    # Split by form feed (page breaks)
+    raw_pages = content.split('\x0c')
+    print(f"Found {len(raw_pages)} raw pages")
+    
+    # Group content by chapter
+    chapter_content: Dict[int, List[Tuple[str, str]]] = {c["number"]: [] for c in CHAPTERS}
+    front_matter = []
+    
+    for page in raw_pages:
+        page = clean_text(page)
+        if not page:
+            continue
+        
+        page_num = extract_page_number(page)
+        chapter = identify_chapter(page_num) if page_num else None
+        
+        if chapter:
+            # Remove page number from end for cleaner text
+            lines = page.split('\n')
+            if lines and lines[-1].strip() == page_num:
+                page = '\n'.join(lines[:-1])
+            
+            chapter_content[chapter["number"]].append((page_num, page))
+        else:
+            front_matter.append((page_num or "fm", page))
+    
+    # Process chapters into chunks
+    all_chunks: List[ProcessedChunk] = []
+    
+    for chapter in CHAPTERS:
+        chapter_pages = chapter_content[chapter["number"]]
+        if not chapter_pages:
+            continue
+        
+        # Combine all text from chapter
+        chapter_text = "\n\n".join([p[1] for p in chapter_pages])
+        page_range = f"{chapter_pages[0][0]}-{chapter_pages[-1][0]}" if len(chapter_pages) > 1 else chapter_pages[0][0]
+        
+        # Semantic chunking
+        text_chunks = semantic_chunk(chapter_text, max_chunk_size=1500, overlap=200)
+        
+        for idx, chunk_text in enumerate(text_chunks):
+            key_concepts = extract_key_concepts(chunk_text)
+            
+            metadata = ChunkMetadata(
+                chunk_id=f"ch{chapter['number']:02d}_chunk{idx:03d}",
+                chapter_number=chapter["number"],
+                chapter_title=chapter["title"],
+                page_number=page_range,
+                chunk_index=idx,
+                total_chunks_in_chapter=len(text_chunks),
+                word_count=len(chunk_text.split()),
+                has_sanskrit_terms=has_transliterated_terms(chunk_text),
+                key_concepts=key_concepts
+            )
+            
+            all_chunks.append(ProcessedChunk(text=chunk_text, metadata=metadata))
+    
+    # Update total chunks per chapter
+    for chunk in all_chunks:
+        chunk.metadata.total_chunks_in_chapter = len([
+            c for c in all_chunks 
+            if c.metadata.chapter_number == chunk.metadata.chapter_number
+        ])
+    
+    print(f"Created {len(all_chunks)} semantic chunks across {len(CHAPTERS)} chapters")
+    return all_chunks
+
+
+def create_graph_schema(session):
+    """Create Neo4j indexes and constraints"""
+    queries = [
+        # Constraints
+        "CREATE CONSTRAINT book_title IF NOT EXISTS FOR (b:Book) REQUIRE b.title IS UNIQUE",
+        "CREATE CONSTRAINT chapter_id IF NOT EXISTS FOR (c:Chapter) REQUIRE c.chapter_id IS UNIQUE", 
+        "CREATE CONSTRAINT chunk_id IF NOT EXISTS FOR (ch:Chunk) REQUIRE ch.chunk_id IS UNIQUE",
+        "CREATE CONSTRAINT concept_name IF NOT EXISTS FOR (con:Concept) REQUIRE con.name IS UNIQUE",
+        
+        # Vector index for semantic search
+        """CREATE VECTOR INDEX chunk_embeddings IF NOT EXISTS
+        FOR (n:Chunk)
+        ON (n.embedding)
+        OPTIONS {indexConfig: {
+          `vector.dimensions`: 768,
+          `vector.similarity_function`: 'cosine'
+        }}""",
+        
+        # Full-text index for keyword search
+        "CREATE FULLTEXT INDEX chunk_text_index IF NOT EXISTS FOR (n:Chunk) ON EACH [n.text, n.chapter_title]",
+        
+        # Index for concept lookup
+        "CREATE INDEX concept_name_index IF NOT EXISTS FOR (c:Concept) ON (c.name)",
+    ]
+    
+    for query in queries:
+        try:
+            session.run(query)
+        except Exception as e:
+            if "already exists" not in str(e).lower():
+                print(f"Warning: {e}")
+
+
+def ingest_to_neo4j(chunks: List[ProcessedChunk], embedder: SentenceTransformer):
+    """Ingest chunks into Neo4j with graph relationships"""
+    print(f"Connecting to Neo4j at {NEO4J_URI}...")
+    
+    driver = GraphDatabase.driver(NEO4J_URI, auth=NEO4J_AUTH)
+    driver.verify_connectivity()
+    print("✓ Connected to Neo4j")
+    
+    with driver.session() as session:
+        # Clear existing data
+        print("Clearing existing book data...")
+        session.run("MATCH (n) WHERE n:Book OR n:Chapter OR n:Chunk OR n:Concept DETACH DELETE n")
+        
+        # Create schema
+        print("Creating graph schema...")
+        create_graph_schema(session)
+        
+        # Create Book node
+        session.run("""
+            CREATE (b:Book {
+                title: 'Anekāntavāda: The Heart of Jainism',
+                author: 'Late Mr. Chandulal S. Shah',
+                translator: 'Ms. Nimisha Vora',
+                language: 'English',
+                genre: 'Philosophy',
+                total_chapters: $total_chapters
+            })
+        """, total_chapters=len(CHAPTERS))
+        
+        # Create Chapter nodes
+        for chapter in CHAPTERS:
+            session.run("""
+                MATCH (b:Book {title: 'Anekāntavāda: The Heart of Jainism'})
+                CREATE (c:Chapter {
+                    chapter_id: $chapter_id,
+                    number: $number,
+                    title: $title,
+                    start_page: $start_page,
+                    end_page: $end_page
+                })
+                CREATE (b)-[:HAS_CHAPTER]->(c)
+            """, 
+                chapter_id=f"chapter_{chapter['number']}",
+                number=chapter["number"],
+                title=chapter["title"],
+                start_page=chapter["start_page"],
+                end_page=chapter["end_page"]
+            )
+        
+        # Create sequential chapter relationships
+        session.run("""
+            MATCH (c1:Chapter), (c2:Chapter)
+            WHERE c2.number = c1.number + 1
+            CREATE (c1)-[:NEXT_CHAPTER]->(c2)
+        """)
+        
+        # Create Concept nodes
+        print("Creating concept nodes...")
+        for concept_name, variants in JAIN_CONCEPTS.items():
+            session.run("""
+                CREATE (con:Concept {
+                    name: $name,
+                    variants: $variants,
+                    category: $category
+                })
+            """, 
+                name=concept_name, 
+                variants=variants,
+                category=categorize_concept(concept_name)
+            )
+        
+        # Ingest chunks with embeddings
+        print("Ingesting chunks with embeddings...")
+        prev_chunk_id = None
+        
+        for i, chunk in enumerate(chunks):
+            # Generate embedding
+            embedding = embedder.encode(chunk.text).tolist()
+            chunk.embedding = embedding
+            
+            # Create Chunk node
+            session.run("""
+                MATCH (ch:Chapter {number: $chapter_number})
+                CREATE (c:Chunk {
+                    chunk_id: $chunk_id,
+                    text: $text,
+                    chapter_number: $chapter_number,
+                    chapter_title: $chapter_title,
+                    page_number: $page_number,
+                    chunk_index: $chunk_index,
+                    word_count: $word_count,
+                    has_sanskrit_terms: $has_sanskrit_terms,
+                    key_concepts: $key_concepts,
+                    embedding: $embedding
+                })
+                CREATE (ch)-[:CONTAINS]->(c)
+            """,
+                chunk_id=chunk.metadata.chunk_id,
+                text=chunk.text,
+                chapter_number=chunk.metadata.chapter_number,
+                chapter_title=chunk.metadata.chapter_title,
+                page_number=chunk.metadata.page_number,
+                chunk_index=chunk.metadata.chunk_index,
+                word_count=chunk.metadata.word_count,
+                has_sanskrit_terms=chunk.metadata.has_sanskrit_terms,
+                key_concepts=chunk.metadata.key_concepts,
+                embedding=embedding
+            )
+            
+            # Create NEXT relationship for sequential reading
+            if prev_chunk_id:
+                session.run("""
+                    MATCH (c1:Chunk {chunk_id: $prev_id}), (c2:Chunk {chunk_id: $curr_id})
+                    CREATE (c1)-[:NEXT]->(c2)
+                """, prev_id=prev_chunk_id, curr_id=chunk.metadata.chunk_id)
+            
+            prev_chunk_id = chunk.metadata.chunk_id
+            
+            # Link to concepts
+            for concept_name in chunk.metadata.key_concepts:
+                session.run("""
+                    MATCH (c:Chunk {chunk_id: $chunk_id}), (con:Concept {name: $concept_name})
+                    CREATE (c)-[:MENTIONS]->(con)
+                """, chunk_id=chunk.metadata.chunk_id, concept_name=concept_name)
+            
+            if (i + 1) % 20 == 0:
+                print(f"  Ingested {i + 1}/{len(chunks)} chunks...", end='\r')
+        
+        # Create concept co-occurrence relationships
+        print("\nCreating concept co-occurrence relationships...")
+        session.run("""
+            MATCH (c1:Concept)<-[:MENTIONS]-(chunk:Chunk)-[:MENTIONS]->(c2:Concept)
+            WHERE id(c1) < id(c2)
+            WITH c1, c2, count(chunk) as co_occurrences
+            WHERE co_occurrences > 1
+            MERGE (c1)-[r:CO_OCCURS_WITH]->(c2)
+            SET r.count = co_occurrences
+        """)
+    
+    driver.close()
+    print(f"\n✓ Ingestion complete! {len(chunks)} chunks stored in Neo4j.")
+
+
+def categorize_concept(concept_name: str) -> str:
+    """Categorize a concept for better organization"""
+    categories = {
+        "Core Doctrine": ["Anekāntavāda", "Syādvāda", "Saptabhaṅgī", "Naya"],
+        "Six Substances": ["Jīvāstikāya", "Pudgalāstīkāya", "Dharmāstikāya", "Adharmāstikāya", "Ākāśāstikāya", "Kāla"],
+        "Nine Tattvas": ["Tattvas", "Āsrava", "Bandha", "Saṃvara", "Nirjarā", "Mokṣa", "Punya", "Pāpa"],
+        "Religious Terms": ["Tīrthaṅkara", "Mahāvīra", "Ṛṣabhadeva", "Karma", "Saṅgha", "Sādhu", "Sādhvī", "Śrāvaka", "Śrāvikā"],
+        "Types of Knowledge": ["Kēvalajñāna", "Mati Jñāna", "Śruta Jñāna", "Avadhi Jñāna", "Manaḥparyaya"],
+        "Seven Nayas": ["Naigama Naya", "Saṅgraha Naya", "Vyavahāra Naya", "Ṛjusūtra Naya", "Śabda Naya", "Samabhirūḍha Naya", "Evambhūta Naya"],
+        "Practices": ["Ahiṃsā", "Anuvratas", "Namaskāra Mahāmantra", "Guṇasthānaka"],
+    }
+    
+    for category, concepts in categories.items():
+        if concept_name in concepts:
+            return category
+    return "Other"
+
+
+def main():
+    print("=" * 60)
+    print("Hybrid RAG Ingestion for Anekant Syadvad")
+    print("=" * 60)
+    
+    # Load embedding model
+    print("\nLoading embedding model (all-mpnet-base-v2)...")
+    embedder = SentenceTransformer('all-mpnet-base-v2')
+    print("✓ Model loaded")
+    
+    # Parse book
+    print("\nParsing book...")
+    chunks = parse_book(FILE_PATH)
+    
+    # Ingest to Neo4j
+    print("\nIngesting to Neo4j...")
+    ingest_to_neo4j(chunks, embedder)
+    
+    print("\n" + "=" * 60)
+    print("Ingestion Complete!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+python-dotenv
+neo4j
+sentence-transformers
+groq
+pydantic

sample_output.txt

@@ -0,0 +1,122 @@
+
+### Question
+explain 5 rationales described by the Jain philosophers
+
+### Answer
+The 5 rationales described by Jain philosophers are essential for understanding the functioning of the world and the occurrence of events. These rationales are:
+
+1. **Kāla** (Time): This rationale defines the maturity and immaturity periods of a thing or work, serving as a cause for events to take place. Kāla refers to the concept of time, which is considered a fundamental aspect of the universe. In Jain philosophy, time is seen as a continuous process that governs the evolution and devolution of all things.
+
+2. **Svabhāva** (Intrinsic Nature): This rationale refers to the inherent nature or characteristics of an entity, which can be recognized by its natural merit or features. Svabhāva is the unique essence or identity of a thing, which distinguishes it from others. It is the intrinsic property that defines the nature of an entity and determines its behavior.
+
+3. **Bhavitavyatā** (Destiny or Niyati): Also known as Niyati, this rationale is considered one of the eternal, infinite, and independent fundamentals. Bhavitavyatā refers to the concept of destiny or the natural order of things, which governs the course of events in the universe. It is the inherent tendency or predisposition of an entity to behave in a certain way.
+
+4. **Prārabdha** (Karma): This rationale refers to the actions of an individual and the community, which shape their destiny. Prārabdha is the accumulated karma or the consequences of past actions, which influence the present and future. In Jain philosophy, karma is seen as a fundamental principle that governs the universe, and it is believed that every action has consequences that affect an individual's spiritual journey.
+
+5. **Puruṣārtha** (Human Effort or Udyama): This rationale refers to the efforts made by a living being to achieve their goals. Puruṣārtha is the human endeavor or striving that enables individuals to overcome challenges and attain their objectives. It is the conscious effort or exertion that individuals make to shape their own destiny and achieve spiritual growth.
+
+These 5 rationales are interconnected and interdependent, and they work together to shape the world and the events that occur within it. By understanding these rationales, individuals can gain insight into the workings of the universe and the principles that govern human existence.
+
+---
+
+### Question
+explain 7 Naya
+
+### Answer
+The 7 Naya, also known as the seven modes of knowing or perspectives, are a fundamental concept in Jain philosophy. Naya (नाय) is a Sanskrit term that means "approach," "method," or "way of knowing." It refers to the different ways of understanding or perceiving an object, concept, or reality. The 7 Naya provide a framework for analyzing and categorizing the various aspects of an object, allowing for a more nuanced and comprehensive understanding.
+
+The 7 Naya are:
+
+1. **Naigama Naya** (नैगम नाय): This perspective involves understanding both the general and specific aspects of an object separately. Naigama is derived from the word Nigam (निगम), which means "resolution" or "decision." It refers to the process of distinguishing between the general and specific characteristics of an object.
+
+2. **Saṅgraha Naya** (संग्रह नाय): This perspective involves understanding the object as a whole, considering its various aspects and attributes. Saṅgraha means "collection" or "gathering," and this Naya involves collecting and synthesizing information about the object.
+
+3. **Vyavahāra Naya** (व्यवहार नाय): This perspective involves understanding the object in terms of its practical or functional aspects. Vyavahāra means "practical" or "worldly," and this Naya involves considering how the object is used or applied in everyday life.
+
+4. **Ṛjusūtra Naya** (ऋजुसूत्र नाय): This perspective involves understanding the object in terms of its essential or intrinsic nature. Ṛjusūtra means "straight" or "direct," and this Naya involves considering the object's inherent characteristics or properties.
+
+5. **Śabda Naya** (शब्द नाय): This perspective involves understanding the object through language or verbal description. Śabda means "word" or "sound," and this Naya involves considering the object's name, definition, or linguistic representation.
+
+6. **Samabhirūḍha Naya** (समभीरूढ नाय): This perspective involves understanding the object in terms of its relationships or interactions with other objects. Samabhirūḍha means "equally" or "simultaneously," and this Naya involves considering the object's connections or correlations with other entities.
+
+7. **Evambhūta Naya** (एवमभूत नाय): This perspective involves understanding the object in terms of its unique or distinctive characteristics. Evambhūta means "thus" or "in this way," and this Naya involves considering the object's individual or peculiar aspects.
+
+The 7 Naya are not mutually exclusive, and they can be used in combination to gain a more comprehensive understanding of an object or concept. By applying these different perspectives, one can develop a more nuanced and multifaceted understanding of reality, which is a key goal of Jain philosophy. The 7 Naya are often used in conjunction with other Jain concepts, such as Anekāntavāda (the doctrine of multiple perspectives) and Syādvāda (the doctrine of conditional assertion), to provide a more complete and balanced understanding of the world.
+
+---
+
+### Question
+Why does the author compare Anekāntavāda to Einstein’s Theory of Relativity?
+
+### Answer
+The author compares Anekāntavāda to Einstein's Theory of Relativity because both concepts deal with the idea of relativity. In Jain philosophy, Anekāntavāda (Sanskrit: अनेकान्तवाद, meaning "non-absolutism" or "many-sidedness") refers to the doctrine that truth and reality are complex and multifaceted, and can be viewed from different perspectives. This concept is central to Jain epistemology and ontology.
+
+Similarly, Einstein's Theory of Relativity challenged the traditional notion of absolute space and time, introducing the concept of relative motion and the equivalence of all inertial frames of reference. The author suggests that the idea of relativity in Jain philosophy, as expressed in Anekāntavāda, predates Einstein's theory by thousands of years.
+
+By drawing this comparison, the author highlights the parallels between the two concepts and implies that Jain philosophy has long recognized the importance of considering multiple perspectives and the relative nature of reality. The author is emphasizing that Jainism's Anekāntavāda is a fundamental and unchallengeable principle that acknowledges the complexity and multifaceted nature of reality, much like Einstein's Theory of Relativity revolutionized our understanding of space and time.
+
+In essence, the comparison serves to illustrate the depth and profundity of Jain philosophical thought, demonstrating that ancient Jain philosophers had already grasped the concept of relativity, which was later developed in modern physics. The term Anekāntavāda itself is derived from the Sanskrit words "anekānta," meaning "many-sided" or "non-absolutist," and "vāda," meaning "doctrine" or "theory."
+
+The concept of Anekāntavāda is closely related to other key Jain terms, such as Syādvāda (Sanskrit: स्याद्वाद, meaning "maybe-ism" or "conditionalism"), which refers to the practice of qualifying statements with conditions or possibilities, acknowledging the complexity and contextuality of truth. By invoking these concepts, the author aims to showcase the richness and sophistication of Jain philosophical thought, which has been developed over centuries.
+
+---
+
+### Question
+Name the six substances (Dravyas) described in Jain philosophy.
+
+### Answer
+The six substances (Dravyas) described in Jain philosophy are:
+
+1. **Jīvāstikāya** (Living substance): Refers to the substance that comprises all living beings, including humans, animals, and microorganisms. The term 'Jīva' (जीव) means a living being or a soul, and 'Astikāya' (अस्तिकाय) refers to a substance that has a physical presence.
+
+2. **Dharmāstikāya** (Substance of motion): Helps things to move from one place to another. The word 'Dharma' (धर्म) in this context means motion or movement.
+
+3. **Adharmāstikāya** (Substance of rest): Helps things to stay still or stationary. The term 'Adharma' (अधर्म) in this context means rest or stillness.
+
+4. **Ākāśāstikāya** (Substance of space): Provides space for all other substances to exist. The term 'Ākāśa' (आकाश) means space or ether.
+
+5. **Pudgalāstīkāya** (Substance of matter): Comprises all non-living things, including matter and energy. The term 'Pudgala' (पुद्गल) means matter or material substance.
+
+6. **Kāla** (Time): Is the sixth substance, which exists independently and is considered an inanimate object. The term 'Kāla' (काल) means time.
+
+These six substances are the fundamental components of the universe according to Jain philosophy, and they interact with each other to create the complex world we experience.
+
+---
+
+### Question
+What is the highest form of knowledge according to Jainism?
+
+### Answer
+The highest form of knowledge according to Jainism is **Kevala Jñāna** (केवल ज्ञान), which refers to omniscience or absolute knowledge. Kevala Jñāna is the state of complete knowledge where nothing remains unknown to the soul. A soul that has attained Kevala Jñāna is known as a Kevalī (केवली) or Sarvajña (सर्वज्ञ), and has the ability to comprehend and visualize everything in the universe, past, present, and future.
+
+In this state, the soul has direct and self-evident knowledge without the need for any external medium or assistance. Kevala Jñāna is considered the ultimate goal of spiritual development in Jainism, where the soul has attained complete self-realization and liberation from the cycle of birth and death.
+
+It is worth noting that Kevala Jñāna is different from other forms of knowledge, such as Mati (माति) and Śruta (श्रुत), which are indirect forms of knowledge that rely on the senses and the mind as intermediaries. In contrast, Kevala Jñāna is a direct and intuitive form of knowledge that arises from the soul itself, without the need for external sources or mediums.
+
+---
+
+### Question
+What are the nine fundamental principles (Tattvas) in Jainism?
+
+### Answer
+The nine fundamental principles (Tattvas) in Jainism are the essential concepts that describe the nature of the universe, the soul, and the path to liberation. These principles are as follows:
+
+1. **Jiva** (living beings): Jiva refers to the sentient beings that possess consciousness. In Jainism, Jiva is considered to be eternal and indestructible, and it is the essence of life.
+
+2. **Ajiva** (non-living things): Ajiva refers to non-sentient matter, which includes all inanimate objects, such as rocks, water, and air.
+
+3. **Punya** (virtue): Punya refers to the accumulation of positive karma, which results from good deeds and actions. It is considered to be a factor that contributes to the spiritual growth and development of the soul.
+
+4. **Pāpa** (sin): Pāpa refers to the accumulation of negative karma, which results from bad deeds and actions. It is considered to be a factor that hinders the spiritual growth and development of the soul.
+
+5. **Āsrava** (influx of karmic matter): Āsrava refers to the process by which karma accumulates and attaches to the soul. This influx of karmic matter is considered to be the cause of the soul's bondage to the cycle of birth and death.
+
+6. **Samvara** (stoppage of karmic matter): Samvara refers to the process of stopping the influx of karmic matter, which is essential for the soul's liberation. This can be achieved through the practice of austerities, self-control, and detachment.
+
+7. **Bandha** (bondage): Bandha refers to the state of being bound to the cycle of birth and death, which is caused by the accumulation of karma. This bondage is considered to be the root cause of suffering and unhappiness.
+
+8. **Nirjarā** (shedding of karmic matter): Nirjarā refers to the process of shedding or destroying the accumulated karma, which is essential for the soul's liberation. This can be achieved through the practice of austerities, self-control, and detachment.
+
+9. **Mokṣa** (liberation): Mokṣa refers to the state of ultimate liberation, where the soul is freed from the cycle of birth and death and achieves eternal bliss and happiness. This is considered to be the ultimate goal of Jainism, and it can be achieved through the practice of the above principles and the cultivation of spiritual knowledge and self-awareness.
+
+These nine fundamental principles provide a framework for understanding the nature of the universe, the soul, and the path to liberation in Jainism. They offer a comprehensive and holistic approach to spiritual growth and development, and they are considered to be essential for achieving the ultimate goal of Mokṣa.

test_chatbot.html

@@ -0,0 +1,351 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Jain Sage AI | Interactive Interface</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --primary: #FF9F1C;
+            /* Saffron/Gold */
+            --secondary: #2EC4B6;
+            /* Teal/Turquoise */
+            --dark: #0F172A;
+            --darker: #020617;
+            --light: #F8FAFC;
+            --glass: rgba(255, 255, 255, 0.05);
+            --glass-border: rgba(255, 255, 255, 0.1);
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: 'Outfit', sans-serif;
+            background-color: var(--darker);
+            color: var(--light);
+            min-height: 100vh;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background: radial-gradient(circle at top right, #1e293b, var(--darker));
+            overflow-x: hidden;
+        }
+
+        .container {
+            width: 100%;
+            max-width: 900px;
+            padding: 2rem;
+            position: relative;
+            z-index: 10;
+        }
+
+        /* Ambient Background blobs */
+        .blob {
+            position: absolute;
+            width: 400px;
+            height: 400px;
+            background: var(--primary);
+            filter: blur(150px);
+            opacity: 0.2;
+            border-radius: 50%;
+            z-index: -1;
+            animation: float 10s infinite alternate;
+        }
+
+        .blob-2 {
+            background: var(--secondary);
+            top: 10%;
+            right: 10%;
+            animation-delay: -5s;
+        }
+
+        @keyframes float {
+            0% {
+                transform: translate(0, 0);
+            }
+
+            100% {
+                transform: translate(20px, 40px);
+            }
+        }
+
+        header {
+            text-align: center;
+            margin-bottom: 3rem;
+        }
+
+        h1 {
+            font-size: 3.5rem;
+            font-weight: 700;
+            background: linear-gradient(135deg, #fff 0%, var(--primary) 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 0.5rem;
+            letter-spacing: -1px;
+        }
+
+        .subtitle {
+            color: #94A3B8;
+            font-size: 1.1rem;
+        }
+
+        .chat-card {
+            background: var(--glass);
+            backdrop-filter: blur(16px);
+            border: 1px solid var(--glass-border);
+            border-radius: 24px;
+            padding: 2rem;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+        }
+
+        .api-config {
+            margin-bottom: 1.5rem;
+            display: flex;
+            gap: 1rem;
+            align-items: center;
+            background: rgba(0, 0, 0, 0.2);
+            padding: 1rem;
+            border-radius: 12px;
+        }
+
+        .input-group {
+            flex: 1;
+        }
+
+        label {
+            display: block;
+            margin-bottom: 0.5rem;
+            font-size: 0.85rem;
+            color: var(--secondary);
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        input[type="text"],
+        textarea {
+            width: 100%;
+            background: rgba(15, 23, 42, 0.6);
+            border: 1px solid var(--glass-border);
+            color: white;
+            padding: 1rem;
+            border-radius: 12px;
+            font-family: inherit;
+            font-size: 1rem;
+            transition: all 0.3s ease;
+        }
+
+        input[type="text"]:focus,
+        textarea:focus {
+            outline: none;
+            border-color: var(--primary);
+            box-shadow: 0 0 0 2px rgba(255, 159, 28, 0.2);
+        }
+
+        .chat-box {
+            min-height: 200px;
+            max-height: 500px;
+            overflow-y: auto;
+            margin-bottom: 1.5rem;
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .message {
+            padding: 1rem 1.5rem;
+            border-radius: 16px;
+            max-width: 80%;
+            line-height: 1.6;
+            animation: slideIn 0.3s ease-out;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .message.user {
+            align-self: flex-end;
+            background: rgba(46, 196, 182, 0.15);
+            border: 1px solid rgba(46, 196, 182, 0.3);
+            color: #d1fae5;
+            border-bottom-right-radius: 4px;
+        }
+
+        .message.bot {
+            align-self: flex-start;
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid var(--glass-border);
+            color: #e2e8f0;
+            border-bottom-left-radius: 4px;
+        }
+
+        .controls {
+            display: flex;
+            gap: 1rem;
+        }
+
+        button {
+            background: var(--primary);
+            color: var(--darker);
+            border: none;
+            padding: 1rem 2rem;
+            border-radius: 12px;
+            font-weight: 700;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 20px -5px rgba(255, 159, 28, 0.4);
+        }
+
+        button:disabled {
+            background: #64748b;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .spinner {
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(0, 0, 0, 0.3);
+            border-radius: 50%;
+            border-top-color: var(--darker);
+            animation: spin 1s linear infinite;
+            display: none;
+        }
+
+        @keyframes spin {
+            to {
+                transform: rotate(360deg);
+            }
+        }
+
+        /* Formatting for bot responses */
+        .message.bot strong {
+            color: var(--primary);
+        }
+    </style>
+</head>
+
+<body>
+    <div class="blob"></div>
+    <div class="blob blob-2"></div>
+
+    <div class="container">
+        <header>
+            <h1>Jain Sage AI</h1>
+            <p class="subtitle">Deep Wisdom from Anekant Syadvad & The Tirthankaras</p>
+        </header>
+
+        <div class="chat-card">
+
+            <div class="api-config">
+                <div class="input-group">
+                    <label for="apiUrl">API Endpoint URL</label>
+                    <input type="text" id="apiUrl" value="https://deploymentcode.onrender.com/chat"
+                        placeholder="http://localhost:10000/chat">
+                </div>
+                <div style="font-size: 0.8rem; color: #64748b; max-width: 300px;">
+                    Replace with your Render URL after deployment.
+                </div>
+            </div>
+
+            <div class="chat-box" id="chatBox">
+                <div class="message bot">
+                    Namaste. I am an AI scholar of Jain Philosophy. Ask me about Anekantavada, Karma, or the path to
+                    Moksha.
+                </div>
+            </div>
+
+            <div class="controls">
+                <input type="text" id="queryInput" placeholder="Ask a question..."
+                    onkeydown="if(event.key==='Enter') sendMessage()">
+                <button onclick="sendMessage()" id="sendBtn">
+                    <span>Ask</span>
+                    <div class="spinner" id="spinner"></div>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        async function sendMessage() {
+            const input = document.getElementById('queryInput');
+            const chatBox = document.getElementById('chatBox');
+            const btn = document.getElementById('sendBtn');
+            const spinner = document.getElementById('spinner');
+            const apiUrl = document.getElementById('apiUrl').value;
+
+            const query = input.value.trim();
+            if (!query) return;
+
+            // Add User Message
+            addMessage(query, 'user');
+            input.value = '';
+
+            // Loading State
+            btn.disabled = true;
+            spinner.style.display = 'block';
+
+            try {
+                const response = await fetch(apiUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ query: query })
+                });
+
+                if (!response.ok) {
+                    throw new Error(`API Error: ${response.statusText}`);
+                }
+
+                const data = await response.json();
+                addMessage(formatResponse(data.answer), 'bot');
+
+            } catch (error) {
+                addMessage(`⚠️ Error: ${error.message}. Please check if the API URL is correct and the server is running.`, 'bot');
+            } finally {
+                btn.disabled = false;
+                spinner.style.display = 'none';
+                chatBox.scrollTop = chatBox.scrollHeight;
+            }
+        }
+
+        function addMessage(text, type) {
+            const chatBox = document.getElementById('chatBox');
+            const div = document.createElement('div');
+            div.className = `message ${type}`;
+            div.innerHTML = text.replace(/\n/g, '<br>');
+            chatBox.appendChild(div);
+            chatBox.scrollTop = chatBox.scrollHeight;
+        }
+
+        function formatResponse(text) {
+            // Simple markdown-like formatting for bold text
+            return text.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+        }
+    </script>
+</body>
+
+</html>