.

.env

@@ -1,4 +1,3 @@
-<<<<<<< HEAD
 # API Configuration
 OPENAI_API_KEY="d1c9ed1ca70b9721dee1087d93f9662a"
 GEMINI_API_KEY="AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
@@ -6,13 +5,4 @@ GEMINI_API_KEY="AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
 # GCP_API_KEY="AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
 
 GEMINI_API_KEY_1= "AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
-=======
-# API Configuration
-OPENAI_API_KEY="d1c9ed1ca70b9721dee1087d93f9662a"
-GEMINI_API_KEY="AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
-# GCP_PROJECT_ID="1008673779731"
-# GCP_API_KEY="AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
-
-GEMINI_API_KEY_1= "AIzaSyDDWHYpQKQ5glnQn5Q-kMTjliwpNfYBpeY"
->>>>>>> 51466f9c2c65701d4b45dd8e842e1a151f75959b
 GEMINI_API_KEY_2= "AIzaSyDzQSzM9vA6Le36V65I2meN5URclq4JSx0"

app.py

@@ -1,5 +1,4 @@
-# Optimized RAG System with E5-Mistral Embeddings and Gemini Flash Generation
-
+# Combined Llama 3 and Gemini Flash Chatbot
 import json
 import logging
 import re
@@ -18,30 +17,27 @@ from langchain_core.documents import Document
 from collections import defaultdict
 import hashlib
 from tqdm import tqdm
-
 from dotenv import load_dotenv
+
 load_dotenv()
 
 # --- Configuration ---
 FAISS_INDEX_PATH = "faiss_index"
 BM25_INDEX_PATH = "bm25_index.pkl"
-
 CACHE_VERSION = "v1"
 embedding_model = "e5-mistral-7b-instruct"
-generation_model = "gemini-1.5-flash"
 data_file_name = "AskNatureNet_data_enhanced.json"
+CHUNK_SIZE = 800
+OVERLAP = 200
+EMBEDDING_BATCH_SIZE = 32
 
 # Initialize clients
 OPENAI_API_CONFIG = {
     "api_key": os.getenv("OPENAI_API_KEY"),
     "base_url": "https://chat-ai.academiccloud.de/v1"
-
 }
 client = OpenAI(**OPENAI_API_CONFIG)
-
-# Configure Gemini
 genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
-gemini_model = genai.GenerativeModel(generation_model)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -175,10 +171,16 @@ class EnhancedRetriever:
     @lru_cache(maxsize=500)
     def _hyde_expansion(self, query: str) -> str:
         try:
-            response = gemini_model.generate_content(
-                f"Generate a technical draft about biomimicry for: {query}\nInclude domain-specific terms."
+            response = client.chat.completions.create(
+                model="meta-llama-3-70b-instruct",
+                messages=[{
+                    "role": "user",
+                    "content": f"Generate a technical draft about biomimicry for: {query}\nInclude domain-specific terms."
+                }],
+                temperature=0.5,
+                max_tokens=200
             )
-            return response.text
+            return response.choices[0].message.content
         except Exception as e:
             logger.error(f"HyDE Error: {str(e)}")
             return query
@@ -211,19 +213,32 @@ class EnhancedRetriever:
 # --- Generation System ---
 SYSTEM_PROMPT = """**Biomimicry Expert Guidelines**
 1. Base answers strictly on context
-2. **Bold** technical terms
-3. Must Include reference links at the end of the response
+2. Cite sources as [Source]
+3. **Bold** technical terms
+4. Include reference links
 
 Context: {context}"""
 
 @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=20))
-def get_ai_response(query: str, context: str) -> str:
+def get_ai_response(query: str, context: str, model: str) -> str:
     try:
-        response = gemini_model.generate_content(
-            f"{SYSTEM_PROMPT.format(context=context)}\nQuestion: {query}\nProvide a detailed technical answer:"
-        )
-        logger.info(f"Raw Response: {response.text}")
-        return _postprocess_response(response.text)
+        if model == "gemini-2.0-flash":
+            gemini_model = genai.GenerativeModel(model)
+            response = gemini_model.generate_content(
+                f"{SYSTEM_PROMPT.format(context=context)}\nQuestion: {query}\nProvide a detailed technical answer:"
+            )
+            return _postprocess_response(response.text)
+        elif model == "meta-llama-3-70b-instruct":
+            response = client.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT.format(context=context)},
+                    {"role": "user", "content": f"Question: {query}\nProvide a detailed technical answer:"}
+                ],
+                temperature=0.4,
+                max_tokens=2000
+            )
+            return _postprocess_response(response.choices[0].message.content)
     except Exception as e:
         logger.error(f"Generation Error: {str(e)}")
         return "I'm unable to generate a response right now. Please try again later."
@@ -237,17 +252,17 @@ def _postprocess_response(response: str) -> str:
 documents = load_and_chunk_data(data_file_name)
 retriever = EnhancedRetriever(documents)
 
-def generate_response(question: str) -> str:
+def generate_response(question: str, model: str) -> str:
     try:
         context = retriever.retrieve(question)
-        return get_ai_response(question, context) if context else "No relevant information found."
+        return get_ai_response(question, context, model) if context else "No relevant information found."
     except Exception as e:
         logger.error(f"Pipeline Error: {str(e)}")
         return "An error occurred processing your request."
 
 # --- Gradio Interface ---
-def chat_interface(question: str, history: List[Tuple[str, str]]):
-    response = generate_response(question)
+def chat_interface(question: str, history: List[Tuple[str, str]], model: str):
+    response = generate_response(question, model)
     return "", history + [(question, response)]
 
 with gr.Blocks(title="AskNature BioRAG Expert", theme=gr.themes.Soft()) as demo:
@@ -257,12 +272,15 @@ with gr.Blocks(title="AskNature BioRAG Expert", theme=gr.themes.Soft()) as demo:
     with gr.Row():
         question = gr.Textbox(placeholder="Ask about biomimicry (e.g. 'How does Werewool use coral proteins to make fibers?')",
                             label="Inquiry", scale=4)
+        model_selector = gr.Dropdown(choices=["gemini-2.0-flash", "meta-llama-3-70b-instruct"], label="Generation Model", value="gemini-2.0-flash")
         clear_btn = gr.Button("Clear History", variant="secondary")
     
-    gr.Markdown("""<div style="text-align: center; color: #4a7c59;">
-        <small>Powered by AskNature's Database | 
-        Explore nature's blueprints at <a href="https://asknature.org">asknature.org</a></small></div>""")
-    question.submit(chat_interface, [question, chatbot], [question, chatbot])
+    gr.Markdown("""
+        <div style="text-align: center; color: #4a7c59;">
+            <small>Powered by AskNature's Database | 
+            Explore nature's blueprints at <a href="https://asknature.org">asknature.org</a></small>
+        </div>""")
+    question.submit(chat_interface, [question, chatbot, model_selector], [question, chatbot])
     clear_btn.click(lambda: [], None, chatbot)
 
 if __name__ == "__main__":

main.ipynb

@@ -606,8 +606,8 @@
     "import pickle\n",
     "from typing import List, Tuple, Optional\n",
     "import gradio as gr\n",
-    "from openai import OpenAI  \n",
-    "from google import genai  \n",
+    "from openai import OpenAI\n",
+    "import google.generativeai as genai\n",
     "from functools import lru_cache\n",
     "from tenacity import retry, stop_after_attempt, wait_exponential\n",
     "from langchain_community.retrievers import BM25Retriever\n",
@@ -616,24 +616,18 @@
     "from langchain_core.documents import Document\n",
     "from collections import defaultdict\n",
     "import hashlib\n",
-    "from tqdm import tqdm  \n",
+    "from tqdm import tqdm\n",
     "\n",
     "from dotenv import load_dotenv\n",
     "load_dotenv()\n",
+    "\n",
     "# --- Configuration ---\n",
     "FAISS_INDEX_PATH = \"faiss_index\"\n",
     "BM25_INDEX_PATH = \"bm25_index.pkl\"\n",
-    "CACHE_VERSION = \"v1\"  # Increment when data format changes\n",
-    "embedding_model = \"e5-mistral-7b-instruct\"  # OpenAI embedding model\n",
-    "generation_model = \"gemini-2.0-flash\"  # Gemini generation model\n",
+    "CACHE_VERSION = \"v1\"\n",
+    "embedding_model = \"e5-mistral-7b-instruct\"\n",
+    "generation_model = \"gemini-2.0-flash\"\n",
     "data_file_name = \"AskNatureNet_data_enhanced.json\"\n",
-    "API_CONFIG = {\n",
-    "    \"gemini_api_key\": os.getenv(\"GEMINI_API_KEY\")  # Gemini API key for generation\n",
-    "}\n",
-    "\n",
-    "CHUNK_SIZE = 800\n",
-    "OVERLAP = 200\n",
-    "EMBEDDING_BATCH_SIZE = 32  # Batch size for embedding API calls\n",
     "\n",
     "# Initialize clients\n",
     "OPENAI_API_CONFIG = {\n",
@@ -641,7 +635,11 @@
     "    \"base_url\": \"https://chat-ai.academiccloud.de/v1\"\n",
     "}\n",
     "client = OpenAI(**OPENAI_API_CONFIG)\n",
-    "gemini_client = genai.Client(api_key=API_CONFIG[\"gemini_api_key\"])  # Gemini client for generation\n",
+    "\n",
+    "# Configure Gemini\n",
+    "genai.configure(api_key=os.getenv(\"GEMINI_API_KEY\"))\n",
+    "gemini_model = genai.GenerativeModel(generation_model)\n",
+    "\n",
     "logging.basicConfig(level=logging.INFO)\n",
     "logger = logging.getLogger(__name__)\n",
     "\n",
@@ -651,13 +649,12 @@
     "    with open(file_path, \"rb\") as f:\n",
     "        return hashlib.md5(f.read()).hexdigest()\n",
     "\n",
-    "# --- Custom Embedding Handler with Progress Tracking ---\n",
+    "# --- Custom Embedding Handler ---\n",
     "class MistralEmbeddings(Embeddings):\n",
-    "    \"\"\"E5-Mistral-7B embedding adapter with error handling and progress tracking\"\"\"\n",
+    "    \"\"\"E5-Mistral-7B embedding adapter\"\"\"\n",
     "    def embed_documents(self, texts: List[str]) -> List[List[float]]:\n",
     "        embeddings = []\n",
     "        try:\n",
-    "            # Process in batches with progress tracking\n",
     "            for i in tqdm(range(0, len(texts), EMBEDDING_BATCH_SIZE), desc=\"Embedding Progress\"):\n",
     "                batch = texts[i:i + EMBEDDING_BATCH_SIZE]\n",
     "                response = client.embeddings.create(\n",
@@ -674,7 +671,7 @@
     "    def embed_query(self, text: str) -> List[float]:\n",
     "        return self.embed_documents([text])[0]\n",
     "\n",
-    "# --- Data Processing with Cache Validation ---\n",
+    "# --- Data Processing ---\n",
     "def load_and_chunk_data(file_path: str) -> List[Document]:\n",
     "    \"\"\"Enhanced chunking with metadata preservation\"\"\"\n",
     "    current_hash = get_data_hash(file_path)\n",
@@ -775,9 +772,8 @@
     "    @lru_cache(maxsize=500)\n",
     "    def _hyde_expansion(self, query: str) -> str:\n",
     "        try:\n",
-    "            response = gemini_client.models.generate_content(  # Use Gemini client for HyDE\n",
-    "                model=generation_model,\n",
-    "                contents=f\"Generate a technical draft about biomimicry for: {query}\\nInclude domain-specific terms.\"\n",
+    "            response = gemini_model.generate_content(\n",
+    "                f\"Generate a technical draft about biomimicry for: {query}\\nInclude domain-specific terms.\"\n",
     "            )\n",
     "            return response.text\n",
     "        except Exception as e:\n",
@@ -811,20 +807,19 @@
     "\n",
     "# --- Generation System ---\n",
     "SYSTEM_PROMPT = \"\"\"**Biomimicry Expert Guidelines**\n",
-    "1. Base answers strictly on context\n",
+    "1. Firstly Base answers strictly on context and if there is not context answer by your own.\n",
     "2. **Bold** technical terms\n",
-    "3. Include reference links at the end of the response\n",
+    "3. Must Include reference links at the end of the response\n",
     "\n",
     "Context: {context}\"\"\"\n",
     "\n",
     "@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=20))\n",
     "def get_ai_response(query: str, context: str) -> str:\n",
     "    try:\n",
-    "        response = gemini_client.models.generate_content(  # Use Gemini client for generation\n",
-    "            model=generation_model,\n",
-    "            contents=f\"{SYSTEM_PROMPT.format(context=context)}\\nQuestion: {query}\\nProvide a detailed technical answer:\"\n",
+    "        response = gemini_model.generate_content(\n",
+    "            f\"{SYSTEM_PROMPT.format(context=context)}\\nQuestion: {query}\\nProvide a detailed technical answer:\"\n",
     "        )\n",
-    "        logger.info(f\"Raw Response: {response.text}\")  # Log raw response\n",
+    "        logger.info(f\"Raw Response: {response.text}\")\n",
     "        return _postprocess_response(response.text)\n",
     "    except Exception as e:\n",
     "        logger.error(f\"Generation Error: {str(e)}\")\n",
@@ -835,7 +830,7 @@
     "    response = re.sub(r\"\\*\\*([\\w-]+)\\*\\*\", r\"**\\1**\", response)\n",
     "    return response\n",
     "\n",
-    "# --- Optimized Pipeline ---\n",
+    "# --- Pipeline ---\n",
     "documents = load_and_chunk_data(data_file_name)\n",
     "retriever = EnhancedRetriever(documents)\n",
     "\n",
@@ -861,11 +856,9 @@
     "                            label=\"Inquiry\", scale=4)\n",
     "        clear_btn = gr.Button(\"Clear History\", variant=\"secondary\")\n",
     "    \n",
-    "    gr.Markdown(\"\"\"\n",
-    "        <div style=\"text-align: center; color: #4a7c59;\">\n",
-    "            <small>Powered by AskNature's Database | \n",
-    "            Explore nature's blueprints at <a href=\"https://asknature.org\">asknature.org</a></small>\n",
-    "        </div>\"\"\")\n",
+    "    gr.Markdown(\"\"\"<div style=\"text-align: center; color: #4a7c59;\">\n",
+    "        <small>Powered by AskNature's Database | \n",
+    "        Explore nature's blueprints at <a href=\"https://asknature.org\">asknature.org</a></small></div>\"\"\")\n",
     "    question.submit(chat_interface, [question, chatbot], [question, chatbot])\n",
     "    clear_btn.click(lambda: [], None, chatbot)\n",
     "\n",
@@ -884,16 +877,69 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:Loading cached documents\n",
+      "INFO:__main__:Loading cached BM25 index\n",
+      "INFO:__main__:Loading cached FAISS index\n",
+      "INFO:faiss.loader:Loading faiss with AVX2 support.\n",
+      "INFO:faiss.loader:Successfully loaded faiss with AVX2 support.\n",
+      "c:\\Users\\Mohamed Elsafty\\.conda\\envs\\rag\\Lib\\site-packages\\gradio\\components\\chatbot.py:273: UserWarning: You have not specified a value for the `type` parameter. Defaulting to the 'tuples' format for chatbot messages, but this is deprecated and will be removed in a future version of Gradio. Please set type='messages' instead, which uses openai-style dictionaries with 'role' and 'content' keys.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7860\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:httpx:HTTP Request: GET https://api.gradio.app/pkg-version \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: HEAD http://127.0.0.1:7860/ \"HTTP/1.1 200 OK\"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:httpx:HTTP Request: POST https://chat-ai.academiccloud.de/v1/chat/completions \"HTTP/1.1 200 OK\"\n",
+      "Embedding Progress:   0%|          | 0/1 [00:00<?, ?it/s]INFO:httpx:HTTP Request: POST https://chat-ai.academiccloud.de/v1/embeddings \"HTTP/1.1 200 OK\"\n",
+      "Embedding Progress: 100%|██████████| 1/1 [00:00<00:00,  4.64it/s]\n",
+      "INFO:httpx:HTTP Request: POST https://chat-ai.academiccloud.de/v1/chat/completions \"HTTP/1.1 200 OK\"\n"
+     ]
+    }
+   ],
    "source": [
-    "# Optimized RAG System with E5-Mistral Embeddings and Gemini Flash Generation with Rate Control\n",
+    "# Combined Llama 3 and Gemini Flash Chatbot\n",
     "import json\n",
     "import logging\n",
     "import re\n",
@@ -901,8 +947,8 @@
     "import pickle\n",
     "from typing import List, Tuple, Optional\n",
     "import gradio as gr\n",
-    "from openai import OpenAI  # For embeddings\n",
-    "from google import genai  # For generation\n",
+    "from openai import OpenAI\n",
+    "import google.generativeai as genai\n",
     "from functools import lru_cache\n",
     "from tenacity import retry, stop_after_attempt, wait_exponential\n",
     "from langchain_community.retrievers import BM25Retriever\n",
@@ -911,41 +957,20 @@
     "from langchain_core.documents import Document\n",
     "from collections import defaultdict\n",
     "import hashlib\n",
-    "from tqdm import tqdm  # For progress tracking\n",
-    "import time  # For rate limit testing\n",
-    "from threading import Thread  # For concurrent requests\n",
-    "\n",
+    "from tqdm import tqdm\n",
     "from dotenv import load_dotenv\n",
+    "\n",
     "load_dotenv()\n",
     "\n",
     "# --- Configuration ---\n",
     "FAISS_INDEX_PATH = \"faiss_index\"\n",
     "BM25_INDEX_PATH = \"bm25_index.pkl\"\n",
-    "CACHE_VERSION = \"v1\"  # Increment when data format changes\n",
-    "embedding_model = \"e5-mistral-7b-instruct\"  # OpenAI embedding model\n",
-    "generation_model = \"gemini-2.0-flash\"  # Gemini generation model\n",
+    "CACHE_VERSION = \"v1\"\n",
+    "embedding_model = \"e5-mistral-7b-instruct\"\n",
     "data_file_name = \"AskNatureNet_data_enhanced.json\"\n",
-    "EMBEDDING_BATCH_SIZE = 32  # Batch size for embedding API calls\n",
-    "\n",
-    "# List of Gemini API keys\n",
-    "GEMINI_API_KEYS = [\n",
-    "    os.getenv(\"GEMINI_API_KEY_1\"),\n",
-    "    os.getenv(\"GEMINI_API_KEY_2\")\n",
-    "]\n",
-    "\n",
-    "current_key_index = 0\n",
-    "\n",
-    "def get_gemini_client():\n",
-    "    global current_key_index\n",
-    "    api_key = GEMINI_API_KEYS[current_key_index]\n",
-    "    print(f\"Using Gemini API Key: {api_key}\")\n",
-    "    return genai.Client(api_key=api_key)\n",
-    "\n",
-    "def switch_gemini_key():\n",
-    "    global current_key_index\n",
-    "    current_key_index = (current_key_index + 1) % len(GEMINI_API_KEYS)\n",
-    "    print(f\"Switched to Gemini API Key: {GEMINI_API_KEYS[current_key_index]}\")\n",
-    "    return get_gemini_client()\n",
+    "CHUNK_SIZE = 800\n",
+    "OVERLAP = 200\n",
+    "EMBEDDING_BATCH_SIZE = 32\n",
     "\n",
     "# Initialize clients\n",
     "OPENAI_API_CONFIG = {\n",
@@ -953,7 +978,8 @@
     "    \"base_url\": \"https://chat-ai.academiccloud.de/v1\"\n",
     "}\n",
     "client = OpenAI(**OPENAI_API_CONFIG)\n",
-    "gemini_client = get_gemini_client()  # Initialize with the first key\n",
+    "genai.configure(api_key=os.getenv(\"GEMINI_API_KEY\"))\n",
+    "\n",
     "logging.basicConfig(level=logging.INFO)\n",
     "logger = logging.getLogger(__name__)\n",
     "\n",
@@ -963,13 +989,12 @@
     "    with open(file_path, \"rb\") as f:\n",
     "        return hashlib.md5(f.read()).hexdigest()\n",
     "\n",
-    "# --- Custom Embedding Handler with Progress Tracking ---\n",
+    "# --- Custom Embedding Handler ---\n",
     "class MistralEmbeddings(Embeddings):\n",
-    "    \"\"\"E5-Mistral-7B embedding adapter with error handling and progress tracking\"\"\"\n",
+    "    \"\"\"E5-Mistral-7B embedding adapter\"\"\"\n",
     "    def embed_documents(self, texts: List[str]) -> List[List[float]]:\n",
     "        embeddings = []\n",
     "        try:\n",
-    "            # Process in batches with progress tracking\n",
     "            for i in tqdm(range(0, len(texts), EMBEDDING_BATCH_SIZE), desc=\"Embedding Progress\"):\n",
     "                batch = texts[i:i + EMBEDDING_BATCH_SIZE]\n",
     "                response = client.embeddings.create(\n",
@@ -986,7 +1011,7 @@
     "    def embed_query(self, text: str) -> List[float]:\n",
     "        return self.embed_documents([text])[0]\n",
     "\n",
-    "# --- Data Processing with Cache Validation ---\n",
+    "# --- Data Processing ---\n",
     "def load_and_chunk_data(file_path: str) -> List[Document]:\n",
     "    \"\"\"Enhanced chunking with metadata preservation\"\"\"\n",
     "    current_hash = get_data_hash(file_path)\n",
@@ -1087,11 +1112,16 @@
     "    @lru_cache(maxsize=500)\n",
     "    def _hyde_expansion(self, query: str) -> str:\n",
     "        try:\n",
-    "            response = gemini_client.models.generate_content(  # Use Gemini client for HyDE\n",
-    "                model=generation_model,\n",
-    "                contents=f\"Generate a technical draft about biomimicry for: {query}\\nInclude domain-specific terms.\"\n",
+    "            response = client.chat.completions.create(\n",
+    "                model=\"meta-llama-3-70b-instruct\",\n",
+    "                messages=[{\n",
+    "                    \"role\": \"user\",\n",
+    "                    \"content\": f\"Generate a technical draft about biomimicry for: {query}\\nInclude domain-specific terms.\"\n",
+    "                }],\n",
+    "                temperature=0.5,\n",
+    "                max_tokens=200\n",
     "            )\n",
-    "            return response.text\n",
+    "            return response.choices[0].message.content\n",
     "        except Exception as e:\n",
     "            logger.error(f\"HyDE Error: {str(e)}\")\n",
     "            return query\n",
@@ -1124,28 +1154,34 @@
     "# --- Generation System ---\n",
     "SYSTEM_PROMPT = \"\"\"**Biomimicry Expert Guidelines**\n",
     "1. Base answers strictly on context\n",
-    "2. **Bold** technical terms\n",
-    "3. Include reference links at the end of the response\n",
+    "2. Cite sources as [Source]\n",
+    "3. **Bold** technical terms\n",
+    "4. Include reference links\n",
     "\n",
     "Context: {context}\"\"\"\n",
     "\n",
     "@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=20))\n",
-    "def get_ai_response(query: str, context: str) -> str:\n",
-    "    global gemini_client\n",
+    "def get_ai_response(query: str, context: str, model: str) -> str:\n",
     "    try:\n",
-    "        # Simulate a rate limit error for testing\n",
-    "        if \"test\" in query.lower():\n",
-    "            raise Exception(\"Simulated rate limit error\")\n",
-    "        \n",
-    "        response = gemini_client.models.generate_content(  # Use Gemini client for generation\n",
-    "            model=generation_model,\n",
-    "            contents=f\"{SYSTEM_PROMPT.format(context=context)}\\nQuestion: {query}\\nProvide a detailed technical answer:\"\n",
-    "        )\n",
-    "        logger.info(f\"Raw Response: {response.text}\")  # Log raw response\n",
-    "        return _postprocess_response(response.text)\n",
+    "        if model == \"gemini-2.0-flash\":\n",
+    "            gemini_model = genai.GenerativeModel(model)\n",
+    "            response = gemini_model.generate_content(\n",
+    "                f\"{SYSTEM_PROMPT.format(context=context)}\\nQuestion: {query}\\nProvide a detailed technical answer:\"\n",
+    "            )\n",
+    "            return _postprocess_response(response.text)\n",
+    "        elif model == \"meta-llama-3-70b-instruct\":\n",
+    "            response = client.chat.completions.create(\n",
+    "                model=model,\n",
+    "                messages=[\n",
+    "                    {\"role\": \"system\", \"content\": SYSTEM_PROMPT.format(context=context)},\n",
+    "                    {\"role\": \"user\", \"content\": f\"Question: {query}\\nProvide a detailed technical answer:\"}\n",
+    "                ],\n",
+    "                temperature=0.4,\n",
+    "                max_tokens=2000\n",
+    "            )\n",
+    "            return _postprocess_response(response.choices[0].message.content)\n",
     "    except Exception as e:\n",
     "        logger.error(f\"Generation Error: {str(e)}\")\n",
-    "        gemini_client = switch_gemini_key()  # Switch to the next API key\n",
     "        return \"I'm unable to generate a response right now. Please try again later.\"\n",
     "\n",
     "def _postprocess_response(response: str) -> str:\n",
@@ -1153,21 +1189,21 @@
     "    response = re.sub(r\"\\*\\*([\\w-]+)\\*\\*\", r\"**\\1**\", response)\n",
     "    return response\n",
     "\n",
-    "# --- Optimized Pipeline ---\n",
+    "# --- Pipeline ---\n",
     "documents = load_and_chunk_data(data_file_name)\n",
     "retriever = EnhancedRetriever(documents)\n",
     "\n",
-    "def generate_response(question: str) -> str:\n",
+    "def generate_response(question: str, model: str) -> str:\n",
     "    try:\n",
     "        context = retriever.retrieve(question)\n",
-    "        return get_ai_response(question, context) if context else \"No relevant information found.\"\n",
+    "        return get_ai_response(question, context, model) if context else \"No relevant information found.\"\n",
     "    except Exception as e:\n",
     "        logger.error(f\"Pipeline Error: {str(e)}\")\n",
     "        return \"An error occurred processing your request.\"\n",
     "\n",
     "# --- Gradio Interface ---\n",
-    "def chat_interface(question: str, history: List[Tuple[str, str]]):\n",
-    "    response = generate_response(question)\n",
+    "def chat_interface(question: str, history: List[Tuple[str, str]], model: str):\n",
+    "    response = generate_response(question, model)\n",
     "    return \"\", history + [(question, response)]\n",
     "\n",
     "with gr.Blocks(title=\"AskNature BioRAG Expert\", theme=gr.themes.Soft()) as demo:\n",
@@ -1177,6 +1213,7 @@
     "    with gr.Row():\n",
     "        question = gr.Textbox(placeholder=\"Ask about biomimicry (e.g. 'How does Werewool use coral proteins to make fibers?')\",\n",
     "                            label=\"Inquiry\", scale=4)\n",
+    "        model_selector = gr.Dropdown(choices=[\"gemini-2.0-flash\", \"meta-llama-3-70b-instruct\"], label=\"Generation Model\", value=\"gemini-2.0-flash\")\n",
     "        clear_btn = gr.Button(\"Clear History\", variant=\"secondary\")\n",
     "    \n",
     "    gr.Markdown(\"\"\"\n",
@@ -1184,40 +1221,48 @@
     "            <small>Powered by AskNature's Database | \n",
     "            Explore nature's blueprints at <a href=\"https://asknature.org\">asknature.org</a></small>\n",
     "        </div>\"\"\")\n",
-    "    question.submit(chat_interface, [question, chatbot], [question, chatbot])\n",
+    "    question.submit(chat_interface, [question, chatbot, model_selector], [question, chatbot])\n",
     "    clear_btn.click(lambda: [], None, chatbot)\n",
     "\n",
-    "# --- Rate Limit Testing ---\n",
-    "def test_rate_limit():\n",
-    "    \"\"\"Simulate high-volume requests to test rate limit handling\"\"\"\n",
-    "    test_questions = [\n",
-    "        \"How do coral proteins help make eco-friendly fabrics without dyes?\",\n",
-    "        \"What environmental problems do coral-inspired textiles solve?\",\n",
-    "        \"What is industrial symbiosis and how does the Kalundborg example work?\",\n",
-    "        \"How do Metavision sensors work like human eyes to save energy?\",\n",
-    "        \"How does TISSIUM copy skin proteins for medical adhesives?\",\n",
-    "        \"How does DNA-level design create better fibers inspired by nature?\",\n",
-    "        \"Why is industrial symbiosis hard to implement despite benefits?\",\n",
-    "        \"How can biological systems inspire sustainable manufacturing?\",\n",
-    "        \"What other industries can use protein-based materials like Werewool?\",\n",
-    "        \"How could event-based cameras improve security systems?\",\n",
-    "        \"Design a factory network that works like coral reef partnerships - what features would it need?\"\n",
-    "    ]\n",
-    "\n",
-    "    for i, question in enumerate(test_questions):\n",
-    "        print(f\"\\nSending query {i+1}: {question}\")\n",
-    "        response = generate_response(question)\n",
-    "        print(f\"Response: {response}\")\n",
-    "        time.sleep(0.5)  # Add a small delay between requests\n",
-    "\n",
-    "# Run the rate limit test in a separate thread\n",
     "if __name__ == \"__main__\":\n",
-    "    gradio_thread = Thread(target=demo.launch, kwargs={\"show_error\": True})\n",
-    "    gradio_thread.start()\n",
-    "    time.sleep(5)\n",
-    "    test_rate_limit()"
+    "    demo.launch(show_error=True)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,