Upload 2 files

app.py

@@ -3,7 +3,7 @@ import pymongo
 import certifi
 from llama_index.core import VectorStoreIndex
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-from llama_index.llms.groq import Groq
+from llama_index.llms.gemini import Gemini
 from llama_index.vector_stores.mongodb import MongoDBAtlasVectorSearch
 from llama_index.core.prompts import PromptTemplate
 from dotenv import load_dotenv
@@ -18,7 +18,7 @@ load_dotenv()
 # --- Embedding Model ---
 embed_model = HuggingFaceEmbedding(model_name="intfloat/multilingual-e5-base")
 
-# --- Prompt Template ---
+# --- Prompt Templates ---
 ramayana_qa_template = PromptTemplate(
     """You are an expert on the Valmiki Ramayana and a guide who always inspires people with the great Itihasa like the Ramayana.
 
@@ -33,7 +33,7 @@ ramayana_qa_template = PromptTemplate(
 
     Answer:
      - Intro or general description to ```Query```
-     - Related shloka/shlokas followed by its explanation
+     - Related sanskrit shloka(s) followed by its explanation
      - Overview of ```Query```"""
 )
 
@@ -51,18 +51,15 @@ gita_qa_template = PromptTemplate(
 
     Answer:
      - Intro or context about the topic
-     - Relevant verse(s) with explanation
+     - Relevant sanskrit verse(s) with explanation
      - Conclusion or reflection"""
 )
 
-# --- Connect to MongoDB once at startup ---
+# --- MongoDB Vector Index Loader ---
 def get_vector_index(db_name, collection_name, vector_index_name):
     mongo_client = pymongo.MongoClient(
         os.getenv("ATLAS_CONNECTION_STRING"),
         tlsCAFile=certifi.where(),
-        tlsAllowInvalidCertificates=False,
-        connectTimeoutMS=30000,
-        serverSelectionTimeoutMS=30000,
     )
     mongo_client.server_info()
     print(f"✅ Connected to MongoDB Atlas for collection: {collection_name}")
@@ -75,29 +72,38 @@ def get_vector_index(db_name, collection_name, vector_index_name):
     )
     return VectorStoreIndex.from_vector_store(vector_store, embed_model=embed_model)
 
-# --- Respond Function (uses API key from state) ---
-def chat_with_groq(index, template):
-    def fn(message, history, groq_key):
-        if not groq_key or not groq_key.startswith("gsk_"):
-            return "❌ Invalid Groq API Key. Please enter a valid key."
-        llm = Groq(model="llama-3.1-8b-instant", api_key=groq_key)
-        query_engine = index.as_query_engine(
-            llm=llm,
-            text_qa_template=template,
-            similarity_top_k=5,
-            verbose=True,
-        )
-        response = query_engine.query(message)
-        print(f"\n{datetime.now()}:: {message} --> {str(response)}\n")
-        return str(response)
-    return fn
-
-# Load vector indices once
+# --- Load Indices Once ---
 ramayana_index = get_vector_index("RAG", "ramayana", "ramayana_vector_index")
 gita_index = get_vector_index("RAG", "bhagavad_gita", "gita_vector_index")
 
-# Encode logos
+# --- Gradio Chat Wrapper with Streaming ---
+def chat(index, template):
+    llm = Gemini(
+        model="models/gemini-1.5-flash",
+        api_key=os.getenv("GOOGLE_API_KEY"),
+        streaming=True
+    )
+    query_engine = index.as_query_engine(
+        llm=llm,
+        text_qa_template=template,
+        similarity_top_k=5,
+        streaming=True,
+        verbose=True,
+    )
+
+    def fn(message, history):
+        streaming_response = query_engine.query(message)
 
+        full_response = ""
+        for text in streaming_response.response_gen:
+            full_response += text
+            yield full_response
+        response = query_engine.query(message)
+        yield str(response)
+        print(f"\n{datetime.now()}:: {message} --> {str(full_response)}\n")
+    return fn
+
+# --- Encode Logos ---
 def encode_image(image_path):
     with open(image_path, "rb") as image_file:
         return base64.b64encode(image_file.read()).decode("utf-8")
@@ -107,54 +113,26 @@ linkedin_logo_encoded = encode_image("Images/linkedin-logo.png")
 website_logo_encoded = encode_image("Images/ai-logo.png")
 
 # --- Gradio UI ---
-with gr.Blocks(theme=gr.themes.Soft(font=[gr.themes.GoogleFont("Roboto Mono")]), css='footer {visibility: hidden}') as demo:
+with gr.Blocks(theme=gr.themes.Soft(font=[gr.themes.GoogleFont("Roboto Mono")]), css="footer {visibility: hidden}") as demo:
     with gr.Tabs():
         with gr.TabItem("Intro"):
             gr.Markdown(md.description)
 
-        def create_tab(tab_title, chatbot_title, vector_index, template, intro):
+        def create_tab(tab_title, vector_index, template, intro_md):
             with gr.TabItem(tab_title):
-                with gr.Column(visible=True) as accordion_container:
-                    with gr.Accordion("How to get Groq API KEY", open=False):
-                        gr.Markdown(md.groq_api_key)
-
-                groq_key_box = gr.Textbox(
-                    label="Enter Groq API Key",
-                    type="password",
-                    placeholder="Paste your Groq API key here..."
-                )
-
-                start_btn = gr.Button("Start Chat")
-                groq_state = gr.State(value="")
-
-                with gr.Column(visible=False) as chatbot_container:
-                    with gr.Accordion("Overview & Summary", open=False):
-                        gr.Markdown(intro)
-                    chatbot = gr.ChatInterface(
-                        fn=chat_with_groq(vector_index, template),
-                        additional_inputs=[groq_state],
-                        chatbot=gr.Chatbot(height=500),
-                        title=chatbot_title,
-                        show_progress="full",
-                        fill_height=True,
-                    )
-
-                def save_key_and_show_chat(key):
-                    if key and key.startswith("gsk_"):
-                        return key, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
-                    else:
-                        return "", gr.update(visible=True), gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
-
-                start_btn.click(
-                    fn=save_key_and_show_chat,
-                    inputs=[groq_key_box],
-                    outputs=[groq_state, groq_key_box, start_btn, accordion_container, chatbot_container]
+                with gr.Accordion("==========> Overview & Summary <==========", open=False):
+                    gr.Markdown(intro_md)
+                gr.ChatInterface(
+                    fn=chat(vector_index, template),
+                    chatbot=gr.Chatbot(height=500),
+                    show_progress="full",
+                    fill_height=True,
                 )
 
-        create_tab("RamayanaGPT", "🕉️ RamayanaGPT", ramayana_index, ramayana_qa_template, md.RamayanaGPT)
-        create_tab("GitaGPT", "🕉️ GitaGPT", gita_index, gita_qa_template, md.GitaGPT)
+        create_tab("RamayanaGPT🏹", ramayana_index, ramayana_qa_template, md.RamayanaGPT)
+        create_tab("GitaGPT🛞", gita_index, gita_qa_template, md.GitaGPT)
 
         gr.HTML(md.footer.format(github_logo_encoded, linkedin_logo_encoded, website_logo_encoded))
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

markdown.py

@@ -1,19 +1,19 @@
 description = """
-## 🕉️ **Project Title: RamayanaGPT & GitaGPT – RAG-based Chatbots for Ancient Indian Epics**
+## 🕉️ **Project Title: Epic-Minds 🏹🛞**
 
 ---
 
 ### 🔍 **Project Overview**
 
-**RamayanaGPT** and **GitaGPT** are knowledge-based conversational AI tools designed to answer questions from the *Valmiki Ramayana* and the *Bhagavad Gita*, respectively. These chatbots use **Retrieval-Augmented Generation (RAG)** architecture to generate accurate, scripture-based responses. They combine powerful **vector search capabilities** with **large language models (LLMs)** to deliver spiritually insightful, context-rich conversations.
+**RamayanaGPT** and **GitaGPT** are intelligent chatbots designed to answer spiritual and literary questions from the *Valmiki Ramayana* and the *Bhagavad Gita* respectively. They follow a **Retrieval-Augmented Generation (RAG)** pipeline to ensure that the responses are contextually grounded in the scriptures.
 
-These tools leverage:
+These tools integrate:
 
-* **MongoDB Atlas Vector Search** for embedding-based document retrieval
-* **Hugging Face** embeddings (`intfloat/multilingual-e5-base`)
-* **Groq LLaMA 3.1 8B** via API
-* **LlamaIndex** for orchestration
-* **Gradio** for user interface
+- **MongoDB Atlas Vector Search** for semantic document retrieval
+- **Hugging Face embeddings** (`intfloat/multilingual-e5-base`)
+- **Gemini Flash 1.5 API** as the large language model
+- **LlamaIndex** for orchestration and query handling
+- **Gradio** for a clean and simple user interface
 
 ---
 
@@ -21,67 +21,66 @@ These tools leverage:
 
 #### 1. **Vector Store: MongoDB Atlas**
 
-* Two collections are created in the `RAG` database:
+- Two collections are created in the `RAG` database:
+  - `ramayana` for **Valmiki Ramayana**
+  - `bhagavad_gita` for **Bhagavad Gita**
+- Each collection has an associated vector index:
+  - `ramayana_vector_index`
+  - `gita_vector_index`
 
-  * `ramayana` for **Valmiki Ramayana**
-  * `bhagavad_gita` for **Bhagavad Gita**
-* Each collection contains vector indexes:
-
-  * `ramayana_vector_index`
-  * `gita_vector_index`
-* Each document includes:
-
-  * For Ramayana: `kanda`, `sarga`, `shloka`, `shloka_text`, and `explanation`
-  * For Gita: `Title`, `Chapter`, `Verse`, and `explanation`
+Each document includes:
+- **Ramayana**: `kanda`, `sarga`, `shloka`, `shloka_text`, `explanation`
+- **Gita**: `Title`, `Chapter`, `Verse`, `explanation`
 
 #### 2. **Vector Embedding: Hugging Face**
 
-* Model: `intfloat/multilingual-e5-base`
-* Used to convert `shloka_text + explanation` or `verse + explanation` into vector representations
-* These embeddings are indexed into MongoDB for semantic similarity search
+- Model used: `intfloat/multilingual-e5-base`
+- Text format for embedding: `shloka_text + explanation` or `verse + explanation`
+- Indexed into MongoDB for fast semantic retrieval
 
-#### 3. **Language Model: Groq API**
+#### 3. **Language Model: Gemini Flash**
 
-* LLM used: `llama-3.1-8b-instant` via **Groq API**
-* Users input their Groq API key securely
-* LLM is instantiated per query using `llama_index.llms.groq.Groq`
+- Model: `gemini-1.5-flash`
+- Integrated via `llama_index.llms.gemini.Gemini`
+- API key loaded from environment variables
+- No user input required for keys—simplifies interface and experience
 
 #### 4. **Prompt Engineering**
 
-* Custom **PromptTemplates** guide the response structure for each chatbot
-* **RamayanaGPT Prompt**:
+Custom **PromptTemplates** for each chatbot to guide structured, scripture-faithful responses.
 
-  * Introduction to the query
-  * Related shlokas with explanations
-  * Summary/overview
-* **GitaGPT Prompt**:
+- **RamayanaGPT Prompt**:
+  - Intro or overview of the query
+  - Related Sanskrit shloka(s) with explanation
+  - Summary of the topic
 
-  * Context or spiritual background
-  * Relevant verse(s) with meaning
-  * Reflective conclusion
+- **GitaGPT Prompt**:
+  - Spiritual or contextual introduction
+  - Relevant verse(s) and meaning
+  - Reflective conclusion
 
 #### 5. **Index Initialization**
 
-* Vector indexes are loaded **once** at application startup:
+- Vector indices are initialized **once** at app startup:
 
-  ```python
-  ramayana_index = get_vector_index("RAG", "ramayana", "ramayana_vector_index")
-  gita_index = get_vector_index("RAG", "bhagavad_gita", "gita_vector_index")
-  ```
-* Shared across all user queries for speed and efficiency
+```python
+ramayana_index = get_vector_index("RAG", "ramayana", "ramayana_vector_index")
+gita_index = get_vector_index("RAG", "bhagavad_gita", "gita_vector_index")
+````
+
+* Shared across sessions for efficiency
 
 #### 6. **User Interface: Gradio**
 
-* Built with `gr.Blocks` using the `Soft` theme and `Roboto Mono` font
-* Two tabs:
+* Built using `gr.Blocks` with the `Soft` theme and `Roboto Mono` font
+* Clean tabbed interface:
 
   * 🕉️ **RamayanaGPT**
   * 🕉️ **GitaGPT**
-* Users enter their Groq API key once; it's stored in `gr.State`
-* Upon authentication:
+* Each tab features:
 
-  * API key input and help accordion are hidden
-  * Full chat interface is revealed (`gr.ChatInterface`)
+  * Overview accordion
+  * Chat window powered by `gr.ChatInterface`
 
 ---
 
@@ -89,7 +88,7 @@ These tools leverage:
 
 | Component       | Technology                            |
 | --------------- | ------------------------------------- |
-| Backend LLM     | Groq (LLaMA 3.1 8B via API)           |
+| Backend LLM     | Gemini Flash 1.5 (via API)            |
 | Embedding Model | Hugging Face (`multilingual-e5-base`) |
 | Vector Store    | MongoDB Atlas Vector Search           |
 | Vector Engine   | LlamaIndex VectorStoreIndex           |
@@ -103,16 +102,14 @@ These tools leverage:
 ### ✅ **Features Implemented**
 
 * [x] Vector search using MongoDB Atlas
+* [x] Hugging Face embedding integration
+* [x] Gemini Flash 1.5 LLM integration
+* [x] Structured prompts per scripture
+* [x] Tabbed Gradio UI for easy switching
+* [x] Collapsible summaries for each section
+* [x] Query logging with timestamp
 
-  * `ramayana_vector_index` for Valmiki Ramayana
-  * `gita_vector_index` for Bhagavad Gita
-* [x] Hugging Face embedding (`e5-base`) integration
-* [x] API key input and session handling with `gr.State`
-* [x] LLM integration via Groq API
-* [x] Prompt templates customized for each scripture
-* [x] Tabbed interface for seamless switching between RamayanaGPT and GitaGPT
-* [x] Clean UX with collapsible Groq API key instructions
-* [x] Logging of each query with timestamp (for debugging/monitoring)
+---
 
 """