Prepare Hugging Face Space deployment

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bookworm",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "Home.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run Home.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts": [
+    8501
+  ]
+}

.github/workflows/main_plexi.yml

@@ -0,0 +1,76 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+# More info on Python, GitHub Actions, and Azure App Service: https://aka.ms/python-webapps-actions
+
+name: Build and deploy Python app to Azure Web App - plexi
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read #This is required for actions/checkout
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python version
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      # 🛠️ Local Build Section (Optional)
+      # The following section in your workflow is designed to catch build issues early on the client side, before deployment. This can be helpful for debugging and validation. However, if this step significantly increases deployment time and early detection is not critical for your workflow, you may remove this section to streamline the deployment process.
+      - name: Create and Start virtual environment and Install dependencies
+        run: |
+          python -m venv antenv
+          source antenv/bin/activate
+          pip install -r requirements.txt
+                
+      # By default, when you enable GitHub CI/CD integration through the Azure portal, the platform automatically sets the SCM_DO_BUILD_DURING_DEPLOYMENT application setting to true. This triggers the use of Oryx, a build engine that handles application compilation and dependency installation (e.g., pip install) directly on the platform during deployment. Hence, we exclude the antenv virtual environment directory from the deployment artifact to reduce the payload size. 
+      - name: Upload artifact for deployment jobs
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-app
+          path: |
+            .
+            !antenv/
+
+      # 🚫 Opting Out of Oryx Build
+      # If you prefer to disable the Oryx build process during deployment, follow these steps:
+      # 1. Remove the SCM_DO_BUILD_DURING_DEPLOYMENT app setting from your Azure App Service Environment variables.
+      # 2. Refer to sample workflows for alternative deployment strategies: https://github.com/Azure/actions-workflow-samples/tree/master/AppService
+      
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    permissions:
+      id-token: write #This is required for requesting the JWT
+      contents: read #This is required for actions/checkout
+
+    steps:
+      - name: Download artifact from build job
+        uses: actions/download-artifact@v4
+        with:
+          name: python-app
+      
+      - name: Login to Azure
+        uses: azure/login@v2
+        with:
+          client-id: ${{ secrets.AZUREAPPSERVICE_CLIENTID_57930D6EA9E0445795ADC1381E0BF637 }}
+          tenant-id: ${{ secrets.AZUREAPPSERVICE_TENANTID_4402E3B59B64422D9FCB755F7BE45091 }}
+          subscription-id: ${{ secrets.AZUREAPPSERVICE_SUBSCRIPTIONID_407A4A4497714262919D51936A8FEC81 }}
+
+      - name: 'Deploy to Azure Web App'
+        uses: azure/webapps-deploy@v3
+        id: deploy-to-webapp
+        with:
+          app-name: 'plexi'
+          slot-name: 'Production'
+          

.github/workflows/wake-up-streamlit.yml

@@ -0,0 +1,61 @@
+name: Keep Streamlit Warm
+
+on:
+  schedule:
+    - cron: "0 */5 * * *"
+  workflow_dispatch:
+
+jobs:
+  warm_app:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install Playwright
+        run: |
+          npm init -y
+          npm install playwright
+          npx playwright install --with-deps chromium
+
+      - name: Wake Streamlit Community Cloud app
+        env:
+          APP_URL: https://plexi-study.streamlit.app/
+        run: |
+          cat <<'EOF' > wake-streamlit.mjs
+          import { chromium } from "playwright";
+
+          const appUrl = process.env.APP_URL;
+          const browser = await chromium.launch({ headless: true });
+          const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
+
+          try {
+            await page.goto(appUrl, { waitUntil: "domcontentloaded", timeout: 90000 });
+
+            const wakeButton = page
+              .getByRole("button", { name: /yes, get this app back up|wake up/i })
+              .first();
+
+            if (await wakeButton.isVisible({ timeout: 10000 }).catch(() => false)) {
+              await wakeButton.click();
+              await page.waitForTimeout(8000);
+              console.log("App was asleep. Wake-up button clicked.");
+            } else {
+              console.log("Wake-up prompt not shown.");
+            }
+
+            await page.waitForSelector(
+              "[data-testid='stAppViewContainer'], section.main, div[data-testid='stApp']",
+              { timeout: 90000 }
+            );
+
+            console.log("App is reachable.");
+          } finally {
+            await browser.close();
+          }
+          EOF
+          node wake-streamlit.mjs

.gitignore

@@ -0,0 +1,27 @@
+
+__pycache__
+.github
+!.github/
+!.github/workflows/
+!.github/workflows/*.yml
+
+
+# Environment variables
+.env
+
+# Credentials and tokens
+credentials.json
+token.json
+service_account.json
+
+
+# Python virtual environments
+venv/
+env/
+ENV/
+.venv/
+.pyenv/
+
+.streamlit/*
+!.streamlit/config.toml
+.zencoder

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+base = "light"
+primaryColor = "#1D7A63"
+backgroundColor = "#FBF7EF"
+secondaryBackgroundColor = "#F1E7D7"
+textColor = "#16312C"

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["streamlit", "run", "Home.py", "--server.port=8501", "--server.address=0.0.0.0"]

Home.py

@@ -0,0 +1,130 @@
+import streamlit as st
+from utils import (
+    inject_theme,
+    render_page_header,
+    render_sidebar,
+)
+
+st.set_page_config(page_title="Plexi | Home", layout="wide")
+inject_theme()
+
+render_page_header(
+    "AI study companion",
+    "Study with real materials, not generic answers",
+    (
+        "Plexi keeps revision simple: browse the right files, preview them quickly, "
+        "and ask focused questions without losing the subject context."
+    ),
+    badges=[
+        "Inline file previews",
+        "Subject-scoped retrieval",
+        "Bring your own model",
+    ],
+)
+
+intro_col, action_col = st.columns(2, gap="large")
+
+with intro_col:
+    st.markdown(
+        """
+        <section class="plexi-panel" style="min-height: 122px;">
+            <div class="plexi-sidecard-title">Built for focused revision</div>
+            <div class="plexi-muted">
+                Move from finding the right material to understanding it in one clean flow.
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+with action_col:
+    st.markdown(
+        """
+        <section class="plexi-callout" style="min-height: 122px;">
+            <div class="plexi-sidecard-title">Choose your starting point</div>
+            <div class="plexi-muted">
+                Open the hub to explore files, or jump straight into the assistant if you already
+                know what you want to study.
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+st.markdown(
+    """
+    <div class="plexi-cta-grid">
+        <a class="plexi-cta-button" href="/Study_Material_Hub" target="_self">Open Material Hub</a>
+        <a class="plexi-cta-button" href="/Plexi-Assistant" target="_self">Open Assistant</a>
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.markdown(
+    '<div class="plexi-section-label">How It Works</div>',
+    unsafe_allow_html=True,
+)
+step_cols = st.columns(3, gap="medium")
+step_cards = [
+    (
+        "01",
+        "Choose your subject",
+        "Pick a semester and subject so the experience stays focused on one course.",
+    ),
+    (
+        "02",
+        "Browse the material",
+        "Open notes and PDFs in the hub and preview them without leaving the app.",
+    ),
+    (
+        "03",
+        "Study with Plexi",
+        "Ask for summaries, revision help, or simple explanations from the loaded subject.",
+    ),
+]
+for column, (step, title, body) in zip(step_cols, step_cards):
+    with column:
+        st.markdown(
+            f"""
+            <section class="plexi-stat">
+                <div class="plexi-stat-label">{step}</div>
+                <div class="plexi-sidecard-title">{title}</div>
+                <div class="plexi-muted">{body}</div>
+            </section>
+            """,
+            unsafe_allow_html=True,
+        )
+
+st.markdown(
+    '<div class="plexi-section-label">Contribute</div>',
+    unsafe_allow_html=True,
+)
+contribute_cols = st.columns([1.25, 0.75], gap="large")
+
+with contribute_cols[0]:
+    st.markdown(
+        """
+        <section class="plexi-callout">
+            <div class="plexi-sidecard-title">Share something useful</div>
+            <div class="plexi-muted">
+                Have clean notes, slides, or question papers that can help others?
+                Submit them through the upload form and they can be reviewed and added
+                to the study library for everyone.
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+with contribute_cols[1]:
+    st.markdown(
+        """
+        <div class="plexi-cta-grid" style="margin-top:0; grid-template-columns:1fr;">
+            <a class="plexi-cta-button" href="https://github.com/KunalGupta25/plexi-materials/issues/new?template=upload-material.yml" target="_blank" rel="noopener noreferrer">Submit Materials</a>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+render_sidebar()

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kunal Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,79 @@
+---
+title: Plexi
+emoji: 📚
+colorFrom: green
+colorTo: teal
+sdk: docker
+app_port: 8501
+pinned: false
+---
+
+# Plexi
+
+<p align="center">
+  <strong>Your AI-powered study companion for Parul University CS students.</strong>
+</p>
+
+<p align="center">
+  <a href="https://ko-fi.com/lazy_human">
+    <img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="Support on Ko-fi" />
+  </a>
+</p>
+
+---
+
+## What is Plexi?
+
+Plexi is a free web app that gives Collage students easy access to study materials and an AI assistant — all in one place. No setup, no accounts, just open and start studying.
+
+---
+
+## What can you do?
+
+### Study Material Hub
+
+Browse and download notes, slides, and other materials organized by **semester → subject → type**. PDFs open right in the browser — no extra apps needed.
+
+- Filter by semester, subject, and file type
+- In-Build PDF Viewer
+- Download any file with one click
+
+### Plexi Assistant
+
+Chat with an AI that **only answers using actual study materials from Database** — no hallucinations, no random internet answers. It works like Google's NotebookLM but specifically for your course content.
+
+- Pick any OpenAI Compatible LLM provider — **Gemini, ChatGPT, Mistral, Groq, OpenRouter**, or even a local model(Ollama or LM Studio)
+- Every answer includes **source citations** so you know exactly where the information came from
+- Bring your own API key (free tiers available from most providers)
+
+### Contribute Materials
+
+Have notes that could help others? Submit them through a simple form — they'll be reviewed and added for everyone automatically.
+
+---
+
+## How it works
+
+1. **Pick your scope** — Select a semester and subject
+2. **Browse or chat** — View files in the Hub, or ask the AI assistant questions grounded in your materials
+3. **Get cited answers** — Every response references the exact source file so you can verify and study further
+
+---
+
+## Built by
+
+**Kunal Gupta** (LazyHuman)
+
+- [lazyhideout.tech](https://lazyhideout.tech)
+- [github.com/KunalGupta25](https://github.com/KunalGupta25)
+- [ko-fi.com/lazy_human](https://ko-fi.com/lazy_human)
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+
+---
+
+> Made with ❤️ by Kunal aka LazyHuman

example.env

@@ -0,0 +1,5 @@
+# Example environment variables for Plexi
+
+# GitHub repo hosting study materials (owner/repo format)
+# Defaults to KunalGupta25/plexi-materials if not set
+# MATERIALS_REPO=KunalGupta25/plexi-materials

pages/Plexi-Assistant.py

@@ -0,0 +1,601 @@
+"""
+Plexi-Assistant.py - Plexi RAG Assistant (GitHub Index)
+======================================================
+The Streamlit frontend. Retrieval uses the pre-built LlamaIndex
+committed to the plexi-materials repo by GitHub Actions.
+
+Flow per user message:
+  1. On app start -> fetch pre-built index from GitHub (cached)
+  2. On each message -> embed query locally, retrieve top-k chunks
+  3. Build focused prompt with retrieved chunks -> call user's LLM
+"""
+
+import requests
+import streamlit as st
+from utils import (
+    fetch_rag_index,
+    get_manifest,
+    inject_theme,
+    load_subject_context,
+    render_page_header,
+    render_panel,
+    render_sidebar,
+    render_stat_cards,
+    summarize_subject_catalog,
+)
+
+st.set_page_config(page_title="Plexi Assistant", layout="wide")
+inject_theme()
+
+TOP_K = 5
+PROMPT_SUGGESTIONS = [
+    (
+        "Summarize this subject",
+        "Give me a clean revision summary of this subject using only the loaded materials.",
+    ),
+    (
+        "Important exam topics",
+        "List the most important exam topics covered in these materials.",
+    ),
+    (
+        "Explain like a beginner",
+        "Explain the most important concepts in simple terms using only the loaded materials.",
+    ),
+    (
+        "Make viva questions",
+        "Create 10 viva-style questions and short answers from the loaded materials.",
+    ),
+]
+
+PROVIDERS = {
+    "Gemini (Google)": {
+        "base_url": "https://generativelanguage.googleapis.com/v1beta/openai",
+        "models": [
+            "gemini-2.0-flash",
+            "gemini-2.0-flash-lite",
+            "gemini-1.5-flash",
+            "gemini-1.5-pro",
+        ],
+        "key_help": "Get a key at [Google AI Studio](https://aistudio.google.com/app/apikey)",
+    },
+    "OpenAI": {
+        "base_url": "https://api.openai.com/v1",
+        "models": ["gpt-4o-mini", "gpt-4o", "gpt-4.1-mini", "gpt-4.1-nano"],
+        "key_help": "Get a key at [OpenAI Platform](https://platform.openai.com/api-keys)",
+    },
+    "Mistral": {
+        "base_url": "https://api.mistral.ai/v1",
+        "models": [
+            "mistral-small-latest",
+            "mistral-medium-latest",
+            "mistral-large-latest",
+            "open-mistral-nemo",
+        ],
+        "key_help": "Get a key at [Mistral Console](https://console.mistral.ai/api-keys)",
+    },
+    "Groq": {
+        "base_url": "https://api.groq.com/openai/v1",
+        "models": [
+            "llama-3.3-70b-versatile",
+            "llama-3.1-8b-instant",
+            "gemma2-9b-it",
+            "mixtral-8x7b-32768",
+        ],
+        "key_help": "Get a key at [Groq Console](https://console.groq.com/keys)",
+    },
+    "OpenRouter": {
+        "base_url": "https://openrouter.ai/api/v1",
+        "models": [
+            "google/gemini-2.0-flash-exp:free",
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "mistralai/mistral-small-3.1-24b-instruct:free",
+            "qwen/qwen3-8b:free",
+        ],
+        "key_help": "Get a key at [OpenRouter](https://openrouter.ai/keys)",
+    },
+    "Custom (self-hosted)": {
+        "base_url": "",
+        "models": [],
+        "key_help": "For Ollama, LM Studio, or any OpenAI-compatible server",
+    },
+}
+PROVIDER_NAMES = list(PROVIDERS.keys())
+
+
+def _matches_scope(node, semester: str, subject: str) -> bool:
+    """Return True when a retrieved node belongs to the active semester + subject."""
+    metadata = getattr(node.node, "metadata", {}) or {}
+    return metadata.get("semester") == semester and metadata.get("subject") == subject
+
+
+def queue_prompt(prompt: str):
+    """Store a prompt and rerun so the chat input flow can process it."""
+    st.session_state["_pending_prompt"] = prompt
+    st.rerun()
+
+
+def local_retrieve(index, query: str, semester: str, subject: str, top_k: int = TOP_K):
+    """Retrieve top-k relevant chunks scoped to the active semester + subject."""
+    if index is None:
+        return []
+    try:
+        retriever = index.as_retriever(similarity_top_k=max(top_k * 5, 10))
+        nodes = retriever.retrieve(query)
+        scoped_nodes = [
+            node for node in nodes if _matches_scope(node, semester, subject)
+        ]
+        return [
+            {
+                "text": node.node.get_content(),
+                "score": round(float(node.score), 4)
+                if node.score is not None
+                else None,
+                "filename": (getattr(node.node, "metadata", {}) or {}).get("filename"),
+                "subject": (getattr(node.node, "metadata", {}) or {}).get("subject"),
+            }
+            for node in scoped_nodes[:top_k]
+        ]
+    except Exception as err:
+        st.warning(f"Retrieval error: {err}")
+        return []
+
+
+def format_context(chunks):
+    """Format retrieved chunks for the system prompt."""
+    if not chunks:
+        return "(No relevant context retrieved.)"
+    parts = []
+    for index, chunk in enumerate(chunks, start=1):
+        score = f"  [relevance: {chunk['score']}]" if chunk.get("score") else ""
+        parts.append(f"--- Chunk {index}{score} ---\n{chunk['text']}\n")
+    return "\n".join(parts)
+
+
+def _send_message(endpoint_url, api_key, model, system_prompt, history, user_prompt):
+    messages = [{"role": "system", "content": system_prompt}]
+    for message in history:
+        messages.append({"role": message["role"], "content": message["content"]})
+    messages.append({"role": "user", "content": user_prompt})
+
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    response = requests.post(
+        f"{endpoint_url}/chat/completions",
+        headers=headers,
+        json={"model": model, "messages": messages, "temperature": 0.3},
+        timeout=120,
+    )
+    if response.status_code == 429:
+        detail = response.json().get("error", {}).get("message", "Rate limit exceeded.")
+        raise Exception(f"RATE_LIMITED: {detail}")
+    if response.status_code == 401:
+        raise Exception(
+            "AUTH_ERROR: Invalid API key. Please check your key and try again."
+        )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"]
+
+
+def _is_configured():
+    return (
+        "cfg_provider" in st.session_state
+        and st.session_state.get("cfg_model")
+        and (
+            st.session_state.get("cfg_provider") == "Custom (self-hosted)"
+            or st.session_state.get("api_key")
+        )
+    )
+
+
+def render_onboarding():
+    """Render the setup flow before chat becomes available."""
+    render_page_header(
+        "Plexi assistant",
+        "Ask course questions with grounded context",
+        (
+            "Choose a provider, bring your own API key, and Plexi will answer only "
+            "from the materials loaded for the subject you pick."
+        ),
+        badges=["Cited answers", "Scoped retrieval", "OpenAI-compatible"],
+    )
+
+    left_col, right_col = st.columns([1.1, 0.9], gap="large")
+
+    with left_col:
+        st.markdown(
+            """
+            <section class="plexi-panel">
+                <div class="plexi-sidecard-title">Set up your model endpoint</div>
+                <div class="plexi-muted">
+                    Pick a hosted provider or connect a local OpenAI-compatible server.
+                </div>
+            </section>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        provider_name = st.selectbox("Provider", PROVIDER_NAMES, key="ob_provider")
+        provider = PROVIDERS[provider_name]
+
+        if provider_name == "Custom (self-hosted)":
+            base_url = st.text_input("Base URL", value="http://localhost:11434/v1")
+            model_name = st.text_input(
+                "Model", placeholder="e.g. llama3, mistral, phi3"
+            )
+        else:
+            base_url = provider["base_url"]
+            model_options = provider["models"] + ["Custom"]
+            model_choice = st.selectbox("Model", model_options)
+            model_name = (
+                st.text_input("Custom model ID", placeholder="Enter model identifier")
+                if model_choice == "Custom"
+                else model_choice
+            )
+
+        needs_key = provider_name != "Custom (self-hosted)"
+        api_key = ""
+        if needs_key:
+            st.info(provider["key_help"])
+            api_key = st.text_input(
+                "API Key",
+                type="password",
+                placeholder="Paste your API key here",
+            )
+
+        can_start = bool(model_name and (not needs_key or api_key))
+        if st.button(
+            "Start Chatting",
+            type="primary",
+            disabled=not can_start,
+            use_container_width=True,
+        ):
+            st.session_state.cfg_provider = provider_name
+            st.session_state.cfg_base_url = base_url
+            st.session_state.cfg_model = model_name
+            if api_key:
+                st.session_state.api_key = api_key
+            st.session_state.pop("messages", None)
+            st.rerun()
+
+    with right_col:
+        render_panel(
+            "What Plexi does",
+            "Keeps answers grounded in the currently loaded course materials instead of drifting into generic knowledge.",
+        )
+        render_panel(
+            "Provider model",
+            "Bring your own endpoint. Use hosted providers or connect a local OpenAI-compatible server.",
+        )
+        render_panel(
+            "Best use case",
+            "Use Plexi for revision summaries, topic breakdowns, viva practice, and quick concept explanations.",
+            tone="callout",
+        )
+        st.markdown(
+            """
+            <section class="plexi-callout">
+                <div class="plexi-sidecard-title">Good prompts to start with</div>
+                <ul class="plexi-list">
+                    <li>Summarize this subject for revision.</li>
+                    <li>List important topics and cite the source files.</li>
+                    <li>Explain a concept in simple terms using only the notes.</li>
+                </ul>
+            </section>
+            """,
+            unsafe_allow_html=True,
+        )
+
+
+render_sidebar()
+
+if not _is_configured():
+    render_onboarding()
+    st.stop()
+
+provider_name = st.session_state.cfg_provider
+base_url = st.session_state.cfg_base_url
+model_name = st.session_state.cfg_model
+api_key = st.session_state.get("api_key", "")
+
+rag_index, rag_error = fetch_rag_index()
+rag_active = rag_index is not None
+mode_label = "RAG retrieval" if rag_active else "Full-context fallback"
+
+try:
+    manifest = get_manifest()
+except Exception as err:
+    st.error(f"Failed to load materials catalog: {err}")
+    st.stop()
+
+if not manifest:
+    st.info("No study materials are available yet.")
+    st.stop()
+
+with st.sidebar:
+    st.markdown(
+        '<div class="plexi-section-label">Study Scope</div>',
+        unsafe_allow_html=True,
+    )
+    semester_names = sorted(manifest.keys())
+    selected_semester = st.selectbox("Semester", semester_names, key="asst_semester")
+    subjects = sorted(manifest[selected_semester].keys())
+    selected_subject = st.selectbox("Subject", subjects, key="asst_subject")
+
+scope_key = f"{selected_semester}|{selected_subject}"
+if st.session_state.get("_scope_key") != scope_key:
+    st.session_state._scope_key = scope_key
+    st.session_state.pop("messages", None)
+
+
+@st.cache_data(show_spinner="Loading study materials...", ttl=300)
+def _get_subject_context(semester, subject):
+    return load_subject_context(manifest, semester, subject)
+
+
+subject_text, source_list = _get_subject_context(selected_semester, selected_subject)
+if not subject_text.strip():
+    st.warning("No readable text was found for this subject. Try another selection.")
+    st.stop()
+
+subject_summary = summarize_subject_catalog(
+    manifest[selected_semester][selected_subject]
+)
+
+with st.sidebar:
+    st.markdown(
+        f"""
+        <section class="plexi-panel">
+            <div class="plexi-sidecard-title">{selected_subject}</div>
+            <div class="plexi-muted">{selected_semester}</div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+    if rag_active:
+        st.success("RAG is active. Answers use subject-scoped retrieved chunks.")
+    elif rag_error:
+        st.warning(f"RAG is unavailable: {rag_error}")
+    else:
+        st.warning("RAG index is unavailable. Using full-context fallback mode.")
+
+    with st.expander(f"Loaded sources ({len(source_list)})", expanded=False):
+        for source in source_list:
+            st.caption(f"[{source['id']}] {source['name']} ({source['type']})")
+
+    with st.expander("Change LLM settings", expanded=False):
+        new_provider = st.selectbox(
+            "Provider",
+            PROVIDER_NAMES,
+            index=PROVIDER_NAMES.index(provider_name),
+            key="sb_provider",
+        )
+        selected_provider = PROVIDERS[new_provider]
+
+        if new_provider == "Custom (self-hosted)":
+            new_base_url = st.text_input("Base URL", value=base_url, key="sb_base_url")
+            new_model = st.text_input(
+                "Model",
+                value=model_name if provider_name == "Custom (self-hosted)" else "",
+                key="sb_model_custom",
+                placeholder="e.g. llama3, mistral, phi3",
+            )
+        else:
+            new_base_url = selected_provider["base_url"]
+            model_options = selected_provider["models"] + ["Custom"]
+            default_index = (
+                model_options.index(model_name) if model_name in model_options else 0
+            )
+            selected_model = st.selectbox(
+                "Model",
+                model_options,
+                index=default_index,
+                key="sb_model_select",
+            )
+            new_model = (
+                st.text_input("Custom model ID", key="sb_model_id")
+                if selected_model == "Custom"
+                else selected_model
+            )
+
+        new_needs_key = new_provider != "Custom (self-hosted)"
+        new_key = api_key
+        if new_needs_key:
+            new_key = st.text_input(
+                "API Key",
+                type="password",
+                value=api_key,
+                key="sb_api_key",
+            )
+
+        changed = (
+            new_provider != provider_name
+            or new_base_url != base_url
+            or new_model != model_name
+            or new_key != api_key
+        )
+        if changed and new_model:
+            if st.button("Apply Changes", use_container_width=True, type="primary"):
+                st.session_state.cfg_provider = new_provider
+                st.session_state.cfg_base_url = new_base_url
+                st.session_state.cfg_model = new_model
+                if new_key:
+                    st.session_state.api_key = new_key
+                elif "api_key" in st.session_state:
+                    del st.session_state.api_key
+                st.session_state.pop("messages", None)
+                st.rerun()
+
+    if st.button("New Chat", use_container_width=True):
+        st.session_state.pop("messages", None)
+        st.rerun()
+
+render_page_header(
+    "Plexi assistant",
+    f"Ask anything from {selected_subject}",
+    (
+        "The assistant is currently grounded to the selected subject. It will stay inside "
+        "that scope and answer only from the loaded materials."
+    ),
+    badges=[selected_semester, selected_subject, provider_name, mode_label],
+)
+
+render_stat_cards(
+    [
+        {
+            "label": "Loaded sources",
+            "value": len(source_list),
+            "note": "Readable files currently available to cite in this chat.",
+        },
+        {
+            "label": "Subject files",
+            "value": subject_summary["file_count"],
+            "note": "Assets available for the selected subject in the catalog.",
+        },
+        {
+            "label": "Provider",
+            "value": provider_name,
+            "note": model_name,
+        },
+        {
+            "label": "Answer mode",
+            "value": "RAG" if rag_active else "Fallback",
+            "note": rag_error or "Top matching chunks are injected into the prompt.",
+        },
+    ]
+)
+
+st.markdown(
+    '<div class="plexi-section-label">Prompt Starters</div>',
+    unsafe_allow_html=True,
+)
+prompt_cols = st.columns(len(PROMPT_SUGGESTIONS), gap="medium")
+for column, (label, prompt_text) in zip(prompt_cols, PROMPT_SUGGESTIONS):
+    with column:
+        if st.button(label, use_container_width=True, key=f"prompt_{label}"):
+            queue_prompt(prompt_text)
+
+st.markdown(
+    """
+    <section class="plexi-panel">
+        <div class="plexi-sidecard-title">Study scope loaded</div>
+        <div class="plexi-muted">
+            Ask for summaries, examples, key differences, exam revision prompts, or viva-style
+            questions. Plexi will stay inside the loaded subject context.
+        </div>
+    </section>
+    """,
+    unsafe_allow_html=True,
+)
+
+source_index = "\n".join(
+    f"  [{src['id']}] {src['name']} ({src['type']})" for src in source_list
+)
+
+
+def build_system_prompt(retrieved_chunks):
+    if rag_active and retrieved_chunks:
+        context_section = (
+            "## RETRIEVED CONTEXT (most relevant chunks for this query)\n"
+            f"{format_context(retrieved_chunks)}\n"
+            "## END OF RETRIEVED CONTEXT"
+        )
+    else:
+        context_section = f"## SOURCE MATERIALS\n{subject_text}\n## END OF MATERIALS"
+
+    return (
+        "Your name is Plexi. You are an academic assistant for Parul University CS students.\n\n"
+        "## STRICT GROUNDING RULES\n"
+        "1. Answer ONLY using information found in the provided context below.\n"
+        "2. Do NOT include inline citation markers like [Source 1] in the response.\n"
+        "3. If the answer is NOT in the context, say: 'This information is not covered in the loaded materials.'\n"
+        "   Do NOT guess or use general knowledge.\n"
+        "4. Use clear structure: headings, bullet points, bold key terms.\n\n"
+        "## INTERACTION STYLE\n"
+        "- Greet users and list covered topics when greeted.\n"
+        "- If asked about your creator, say: Kunal Gupta (LazyHuman).\n"
+        "- Write natural, clean answers without a sources footer unless the user explicitly asks for sources.\n\n"
+        f"## SOURCE INDEX\n{source_index}\n\n"
+        f"{context_section}"
+    )
+
+
+if "messages" not in st.session_state:
+    st.session_state.messages = [
+        {
+            "role": "assistant",
+            "content": (
+                f"Hi! I am loaded with **{selected_subject}** from **{selected_semester}**. "
+                f"Mode: *{mode_label}*. Ask me for summaries, explanations, or revision help."
+            ),
+        }
+    ]
+
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+pending_prompt = st.session_state.pop("_pending_prompt", None)
+prompt = pending_prompt or st.chat_input("Ask about your loaded study materials")
+
+if prompt:
+    if not pending_prompt:
+        st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            retrieved = (
+                local_retrieve(rag_index, prompt, selected_semester, selected_subject)
+                if rag_active
+                else []
+            )
+            system_prompt = build_system_prompt(retrieved)
+
+            history = [
+                message
+                for message in st.session_state.messages[1:-1]
+                if message["role"] in ("user", "assistant")
+            ]
+
+            try:
+                answer = _send_message(
+                    base_url, api_key, model_name, system_prompt, history, prompt
+                )
+            except Exception as err:
+                err_text = str(err)
+                if "RATE_LIMITED" in err_text:
+                    st.session_state["_pending_prompt"] = prompt
+                    st.error("API rate limit reached. Wait a minute and press Retry.")
+                    if st.button("Retry", type="primary"):
+                        st.rerun()
+                    st.stop()
+                if "AUTH_ERROR" in err_text:
+                    st.error(err_text.split(": ", 1)[1])
+                    if "api_key" in st.session_state:
+                        del st.session_state.api_key
+                    st.session_state.messages.pop()
+                    st.stop()
+                raise
+
+            st.markdown(answer)
+
+            if retrieved:
+                with st.expander("Retrieved context chunks", expanded=False):
+                    for index, chunk in enumerate(retrieved, start=1):
+                        label = (
+                            chunk.get("filename")
+                            or chunk.get("subject")
+                            or "Unknown source"
+                        )
+                        st.caption(
+                            f"Chunk {index} - {label} - relevance: {chunk.get('score')}"
+                        )
+                        preview = chunk["text"][:400] + (
+                            "..." if len(chunk["text"]) > 400 else ""
+                        )
+                        st.text(preview)
+
+    st.session_state.messages.append({"role": "assistant", "content": answer})

pages/Study_Material_Hub.py

@@ -0,0 +1,263 @@
+from html import escape
+
+import streamlit as st
+from streamlit_pdf_viewer import pdf_viewer
+from utils import (
+    download_github_file,
+    get_manifest,
+    get_mime_type,
+    inject_theme,
+    render_page_header,
+    render_sidebar,
+    render_stat_cards,
+    summarize_manifest,
+    summarize_subject_catalog,
+)
+
+st.set_page_config(page_title="Study Materials Hub", layout="wide")
+inject_theme()
+
+
+def display_pdf(file_content):
+    """Display PDF using streamlit-pdf-viewer."""
+    pdf_viewer(file_content, width="100%", height=700)
+
+
+def display_ppt(file_content, filename):
+    """Show PPT download button when inline preview is unavailable."""
+    st.info("PowerPoint files cannot be previewed inline yet. Use the download button.")
+    st.download_button(
+        label="Download PPT",
+        data=file_content,
+        file_name=filename,
+        mime="application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        use_container_width=True,
+        type="primary",
+    )
+
+
+try:
+    manifest = get_manifest()
+except Exception as err:
+    st.error(f"Failed to load materials catalog: {err}")
+    st.stop()
+
+semester_names = sorted(manifest.keys()) if manifest else []
+catalog_summary = summarize_manifest(manifest) if manifest else None
+
+if not semester_names:
+    st.info("No study materials are available yet. Check back later.")
+    st.stop()
+
+selected_semester = None
+selected_subject = None
+selected_type = None
+selected_file_name = None
+
+with st.container():
+    render_page_header(
+        "Material hub",
+        "Browse the catalog without losing context",
+        (
+            "Move from semester to file in a single flow, preview PDFs in place, and "
+            "download the exact asset you want from the shared materials repository."
+        ),
+        badges=[
+            f"{catalog_summary['semester_count']} semesters"
+            if catalog_summary
+            else None,
+            f"{catalog_summary['file_count']} files" if catalog_summary else None,
+            "Inline PDF preview",
+        ],
+    )
+
+st.markdown(
+    '<div class="plexi-section-label">Refine Your Selection</div>',
+    unsafe_allow_html=True,
+)
+st.markdown(
+    """
+    <section class="plexi-panel">
+        <div class="plexi-sidecard-title">Catalog filters</div>
+        <div class="plexi-muted">
+            Narrow the collection by semester, then drill into one subject and file.
+        </div>
+    </section>
+    """,
+    unsafe_allow_html=True,
+)
+
+filter_cols = st.columns(4, gap="medium")
+with filter_cols[0]:
+    selected_semester = st.selectbox("Semester", semester_names, key="hub_semester")
+
+subjects = sorted(manifest[selected_semester].keys())
+with filter_cols[1]:
+    selected_subject = st.selectbox("Subject", subjects, key="hub_subject")
+
+subject_data = manifest[selected_semester][selected_subject]
+subject_summary = summarize_subject_catalog(subject_data)
+types = subject_summary["types"]
+with filter_cols[2]:
+    selected_type = st.selectbox("Material Type", types, key="hub_type")
+
+files_list = subject_data[selected_type]
+file_names = [file_entry["name"] for file_entry in files_list]
+with filter_cols[3]:
+    selected_file_name = (
+        st.selectbox("File", file_names, key="hub_file") if file_names else None
+    )
+
+selected_file_obj = (
+    next((item for item in files_list if item["name"] == selected_file_name), None)
+    if selected_file_name
+    else None
+)
+
+render_stat_cards(
+    [
+        {
+            "label": "Current Subject",
+            "value": selected_subject,
+            "note": f"{selected_semester} collection currently in focus.",
+        },
+        {
+            "label": "Available Files",
+            "value": subject_summary["file_count"],
+            "note": "All assets available for this subject across material types.",
+        },
+        {
+            "label": "Material Types",
+            "value": subject_summary["type_count"],
+            "note": ", ".join(subject_summary["types"]),
+        },
+        {
+            "label": "Current Bucket",
+            "value": len(files_list),
+            "note": f"Files available inside {selected_type}.",
+        },
+    ]
+)
+
+render_sidebar()
+
+if not selected_file_obj:
+    st.info("No files were found for this combination yet.")
+    st.stop()
+
+try:
+    file_content = download_github_file(selected_file_obj["download_url"])
+    file_mime = get_mime_type(selected_file_obj["name"])
+except Exception as err:
+    st.error(f"Error loading file: {err}")
+    st.stop()
+
+if not file_content:
+    st.error("The selected file could not be downloaded.")
+    st.stop()
+
+st.markdown(
+    '<div class="plexi-section-label">Preview And Download</div>',
+    unsafe_allow_html=True,
+)
+
+preview_col, info_col = st.columns([1.7, 0.95], gap="large")
+
+with preview_col:
+    st.markdown(
+        f"""
+        <section class="plexi-panel">
+            <div class="plexi-kicker">{selected_semester}</div>
+            <div class="plexi-sidecard-title">{selected_file_obj["name"]}</div>
+            <div class="plexi-muted">
+                {selected_subject} / {selected_type}
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    if file_mime == "application/pdf":
+        display_pdf(file_content)
+    elif file_mime in [
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ]:
+        display_ppt(file_content, selected_file_obj["name"])
+    else:
+        st.info(
+            "Preview is not available for this file type. Download it to inspect the content."
+        )
+
+with info_col:
+    st.markdown(
+        """
+        <section class="plexi-callout">
+            <div class="plexi-sidecard-title">Selected file</div>
+            <div class="plexi-muted">
+                Download the current file or switch to another asset in the same bucket.
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.download_button(
+        label="Download File",
+        data=file_content,
+        file_name=selected_file_obj["name"],
+        mime=file_mime,
+        use_container_width=True,
+        type="primary",
+    )
+
+    st.markdown(
+        """
+        <section class="plexi-panel">
+            <div class="plexi-sidecard-title">File details</div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown(
+        f"""
+        <section class="plexi-meta">
+            <div class="plexi-meta-row">
+                <div class="plexi-meta-key">Semester</div>
+                <div class="plexi-meta-value">{escape(selected_semester)}</div>
+            </div>
+            <div class="plexi-meta-row">
+                <div class="plexi-meta-key">Subject</div>
+                <div class="plexi-meta-value">{escape(selected_subject)}</div>
+            </div>
+            <div class="plexi-meta-row">
+                <div class="plexi-meta-key">Material Type</div>
+                <div class="plexi-meta-value">{escape(selected_type)}</div>
+            </div>
+            <div class="plexi-meta-row">
+                <div class="plexi-meta-key">Format</div>
+                <div class="plexi-meta-value">{escape(file_mime)}</div>
+            </div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.markdown(
+        """
+        <section class="plexi-panel">
+            <div class="plexi-sidecard-title">More in this bucket</div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+    bucket_items = []
+    for file_name in file_names:
+        item_class = "current" if file_name == selected_file_obj["name"] else ""
+        label = "Current" if file_name == selected_file_obj["name"] else "Available"
+        bucket_items.append(
+            f'<li class="{item_class}">{escape(label)}: {escape(file_name)}</li>'
+        )
+    st.markdown(
+        f'<section class="plexi-meta"><ul class="plexi-filelist">{"".join(bucket_items)}</ul></section>',
+        unsafe_allow_html=True,
+    )

requirements.txt

@@ -0,0 +1,8 @@
+streamlit
+python-dotenv
+requests
+PyPDF2
+streamlit-pdf-viewer
+llama-index-core
+llama-index-embeddings-huggingface
+sentence-transformers

startup.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+python -m streamlit run Home.py --server.port 8000 --server.address 0.0.0.0

utils.py

@@ -0,0 +1,950 @@
+import io
+import mimetypes
+import os
+import tempfile
+from html import escape
+from string import Template
+
+import PyPDF2
+import requests
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# LlamaIndex imports for RAG retrieval
+try:
+    from llama_index.core import Settings, StorageContext, load_index_from_storage
+    from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+
+    LLAMA_INDEX_AVAILABLE = True
+except ImportError:
+    LLAMA_INDEX_AVAILABLE = False
+
+# GitHub repo that hosts study materials via Releases + manifest.json
+# Format: "owner/repo"
+MATERIALS_REPO = os.getenv("MATERIALS_REPO", "KunalGupta25/plexi-materials")
+MANIFEST_BRANCH = "main"
+THEME_MODE_STATE_KEY = "plexi_theme_mode"
+THEME_MODE_WIDGET_KEY = "_plexi_theme_mode_widget"
+
+LIGHT_PALETTE = {
+    "ink": "#16312c",
+    "muted": "#5b6c66",
+    "bg": "#f5f0e8",
+    "panel": "rgba(255, 252, 247, 0.88)",
+    "panel_strong": "#fffaf1",
+    "line": "rgba(22, 49, 44, 0.11)",
+    "accent": "#1d7a63",
+    "accent_soft": "#d7efe4",
+    "highlight": "#f4b860",
+    "shadow": "0 18px 60px rgba(30, 48, 43, 0.08)",
+    "app_background": """
+        radial-gradient(circle at top left, rgba(244, 184, 96, 0.18), transparent 28%),
+        radial-gradient(circle at top right, rgba(29, 122, 99, 0.14), transparent 30%),
+        linear-gradient(180deg, #fbf7ef 0%, #f4ecde 100%)
+    """,
+    "hero_background": """
+        linear-gradient(135deg, rgba(29, 122, 99, 0.08), rgba(255, 250, 241, 0.92)),
+        rgba(255, 252, 247, 0.88)
+    """,
+    "chip_background": "rgba(29, 122, 99, 0.08)",
+    "chip_border": "rgba(29, 122, 99, 0.12)",
+    "button_border": "rgba(29, 122, 99, 0.14)",
+    "button_surface": "#f8fbfa",
+    "button_hover": "#eef7f2",
+    "primary_button": "linear-gradient(135deg, #1d7a63, #245e74)",
+    "sidebar_background": """
+        linear-gradient(180deg, rgba(255, 251, 245, 0.98), rgba(246, 238, 224, 0.96))
+    """,
+    "expander_background": "rgba(255, 251, 245, 0.72)",
+    "meta_background": "rgba(255, 251, 245, 0.72)",
+    "divider": "linear-gradient(90deg, rgba(29, 122, 99, 0.25), transparent)",
+    "meta_row_border": "rgba(22, 49, 44, 0.08)",
+    "bottom_background": "#fbf7ef",
+}
+
+DARK_PALETTE = {
+    "ink": "#eef4ef",
+    "muted": "#b8c6c0",
+    "bg": "#0d1715",
+    "panel": "rgba(20, 31, 29, 0.9)",
+    "panel_strong": "#15211f",
+    "line": "rgba(196, 223, 211, 0.14)",
+    "accent": "#54c6a2",
+    "accent_soft": "#17392f",
+    "highlight": "#f0b564",
+    "shadow": "0 22px 70px rgba(0, 0, 0, 0.32)",
+    "app_background": """
+        radial-gradient(circle at top left, rgba(240, 181, 100, 0.12), transparent 28%),
+        radial-gradient(circle at top right, rgba(84, 198, 162, 0.12), transparent 32%),
+        linear-gradient(180deg, #0f1b19 0%, #09110f 100%)
+    """,
+    "hero_background": """
+        linear-gradient(135deg, rgba(84, 198, 162, 0.12), rgba(16, 28, 25, 0.92)),
+        rgba(20, 31, 29, 0.9)
+    """,
+    "chip_background": "rgba(84, 198, 162, 0.12)",
+    "chip_border": "rgba(84, 198, 162, 0.18)",
+    "button_border": "rgba(84, 198, 162, 0.18)",
+    "button_surface": "rgba(84, 198, 162, 0.14)",
+    "button_hover": "rgba(84, 198, 162, 0.22)",
+    "primary_button": "linear-gradient(135deg, #2ea483, #245e74)",
+    "sidebar_background": """
+        linear-gradient(180deg, rgba(17, 28, 26, 0.98), rgba(12, 20, 18, 0.97))
+    """,
+    "expander_background": "rgba(17, 28, 26, 0.84)",
+    "meta_background": "rgba(19, 31, 28, 0.84)",
+    "divider": "linear-gradient(90deg, rgba(84, 198, 162, 0.32), transparent)",
+    "meta_row_border": "rgba(196, 223, 211, 0.1)",
+    "bottom_background": "#09110f",
+}
+
+
+def get_theme_mode():
+    """Return the selected appearance mode."""
+    if THEME_MODE_STATE_KEY not in st.session_state:
+        st.session_state[THEME_MODE_STATE_KEY] = "system"
+    return st.session_state[THEME_MODE_STATE_KEY]
+
+
+def sync_theme_mode():
+    """Persist the appearance selector value across page switches."""
+    st.session_state[THEME_MODE_STATE_KEY] = st.session_state.get(
+        THEME_MODE_WIDGET_KEY, "System"
+    ).lower()
+
+
+def _css_vars_block(palette):
+    """Return CSS custom property definitions for a palette."""
+    return "\n".join(
+        [
+            f"            --plexi-ink: {palette['ink']};",
+            f"            --plexi-muted: {palette['muted']};",
+            f"            --plexi-bg: {palette['bg']};",
+            f"            --plexi-panel: {palette['panel']};",
+            f"            --plexi-panel-strong: {palette['panel_strong']};",
+            f"            --plexi-line: {palette['line']};",
+            f"            --plexi-accent: {palette['accent']};",
+            f"            --plexi-accent-soft: {palette['accent_soft']};",
+            f"            --plexi-highlight: {palette['highlight']};",
+            f"            --plexi-shadow: {palette['shadow']};",
+            f"            --plexi-app-background: {palette['app_background']};",
+            f"            --plexi-hero-background: {palette['hero_background']};",
+            f"            --plexi-chip-background: {palette['chip_background']};",
+            f"            --plexi-chip-border: {palette['chip_border']};",
+            f"            --plexi-button-border: {palette['button_border']};",
+            f"            --plexi-button-surface: {palette['button_surface']};",
+            f"            --plexi-button-hover: {palette['button_hover']};",
+            f"            --plexi-primary-button: {palette['primary_button']};",
+            f"            --plexi-sidebar-background: {palette['sidebar_background']};",
+            f"            --plexi-expander-background: {palette['expander_background']};",
+            f"            --plexi-meta-background: {palette['meta_background']};",
+            f"            --plexi-divider: {palette['divider']};",
+            f"            --plexi-meta-row-border: {palette['meta_row_border']};",
+            f"            --plexi-bottom-background: {palette['bottom_background']};",
+        ]
+    )
+
+
+def inject_theme():
+    """Inject the shared visual language for the Streamlit app."""
+    theme_mode = get_theme_mode()
+    palette = DARK_PALETTE if theme_mode == "dark" else LIGHT_PALETTE
+    system_css = ""
+    color_scheme = "dark" if theme_mode == "dark" else "light"
+    if theme_mode == "system":
+        system_css = f"""
+        @media (prefers-color-scheme: dark) {{
+            :root {{
+{_css_vars_block(DARK_PALETTE)}
+            }}
+
+            html {{
+                color-scheme: dark;
+            }}
+        }}
+        """
+    css = Template(
+        """
+        <style>
+        @import url('https://fonts.googleapis.com/css2?family=DM+Serif+Display:ital@0;1&family=Space+Grotesk:wght@400;500;700&display=swap');
+
+        :root {
+$palette_vars
+        }
+
+        html, body, [class*="css"] {
+            font-family: "Space Grotesk", "Segoe UI", sans-serif;
+        }
+
+        html {
+            color-scheme: $color_scheme;
+        }
+
+        .stApp {
+            background: var(--plexi-app-background);
+            color: var(--plexi-ink);
+        }
+
+        header[data-testid="stHeader"] {
+            background: transparent !important;
+        }
+
+        div[data-testid="stToolbar"] {
+            background: transparent !important;
+        }
+
+        div[data-testid="stAppViewContainer"] {
+            background: transparent;
+        }
+
+        .block-container {
+            padding-top: 2.2rem;
+            padding-bottom: 3rem;
+        }
+
+        h1, h2, h3 {
+            color: var(--plexi-ink);
+        }
+
+        h1, .plexi-title {
+            font-family: "DM Serif Display", Georgia, serif;
+            letter-spacing: -0.03em;
+        }
+
+        p, li, .stMarkdown, .stCaption, .stChatMessage {
+            color: var(--plexi-ink);
+        }
+
+        .plexi-hero,
+        .plexi-panel,
+        .plexi-stat,
+        .plexi-sidecard,
+        .plexi-callout {
+            background: var(--plexi-panel);
+            border: 1px solid var(--plexi-line);
+            border-radius: 24px;
+            box-shadow: var(--plexi-shadow);
+        }
+
+        .plexi-hero {
+            padding: 1.8rem 1.9rem;
+            margin-bottom: 1.1rem;
+            background: var(--plexi-hero-background);
+        }
+
+        .plexi-kicker {
+            text-transform: uppercase;
+            letter-spacing: 0.16em;
+            font-size: 0.72rem;
+            font-weight: 700;
+            color: var(--plexi-accent);
+            margin-bottom: 0.65rem;
+        }
+
+        .plexi-title {
+            font-size: clamp(2.2rem, 5vw, 4.2rem);
+            margin: 0;
+            line-height: 0.95;
+        }
+
+        .plexi-subtitle {
+            max-width: 48rem;
+            margin: 0.8rem 0 0;
+            color: var(--plexi-muted);
+            font-size: 1rem;
+            line-height: 1.65;
+        }
+
+        .plexi-chip-row {
+            display: flex;
+            gap: 0.55rem;
+            flex-wrap: wrap;
+            margin-top: 1rem;
+        }
+
+        .plexi-chip {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.35rem;
+            padding: 0.45rem 0.8rem;
+            border-radius: 999px;
+            background: var(--plexi-chip-background);
+            border: 1px solid var(--plexi-chip-border);
+            font-size: 0.82rem;
+            color: var(--plexi-ink);
+        }
+
+        .plexi-panel,
+        .plexi-callout,
+        .plexi-sidecard {
+            padding: 1.15rem 1.2rem;
+            margin-bottom: 1rem;
+        }
+
+        .plexi-stat {
+            padding: 1rem 1.15rem;
+            min-height: 8.5rem;
+            overflow: hidden;
+        }
+
+        .plexi-stat-label {
+            color: var(--plexi-muted);
+            font-size: 0.82rem;
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+        }
+
+        .plexi-stat-value {
+            font-family: "DM Serif Display", Georgia, serif;
+            font-size: clamp(1.5rem, 2.1vw, 2.1rem);
+            line-height: 1.08;
+            margin: 0.35rem 0 0.4rem;
+            overflow-wrap: anywhere;
+        }
+
+        .plexi-stat-note,
+        .plexi-muted {
+            color: var(--plexi-muted);
+            font-size: 0.92rem;
+            line-height: 1.55;
+        }
+
+        .plexi-section-label {
+            margin: 1.6rem 0 0.8rem;
+            text-transform: uppercase;
+            letter-spacing: 0.12em;
+            color: var(--plexi-accent);
+            font-size: 0.74rem;
+            font-weight: 700;
+        }
+
+        .plexi-list {
+            margin: 0;
+            padding-left: 1rem;
+            color: var(--plexi-muted);
+            line-height: 1.7;
+        }
+
+        .plexi-cta-grid {
+            display: grid;
+            grid-template-columns: repeat(2, minmax(0, 1fr));
+            gap: 1rem;
+            margin: 1rem 0 1.4rem;
+            align-items: stretch;
+        }
+
+        .plexi-cta-button {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            width: 100%;
+            min-height: 3.6rem;
+            padding: 0.9rem 1.2rem;
+            border-radius: 999px;
+            text-decoration: none !important;
+            font-weight: 700;
+            font-size: 1.02rem;
+            color: #ffffff !important;
+            background: linear-gradient(135deg, #3bb192, #2b728a);
+            box-shadow: 0 16px 40px rgba(38, 109, 107, 0.22);
+            border: none;
+            transition: transform 120ms ease, box-shadow 120ms ease, opacity 120ms ease;
+        }
+
+        .plexi-cta-button:hover {
+            color: #ffffff !important;
+            transform: translateY(-1px);
+            box-shadow: 0 18px 44px rgba(38, 109, 107, 0.28);
+        }
+
+        .plexi-prompt button,
+        .stButton > button,
+        .stDownloadButton > button,
+        .stLinkButton > a {
+            border-radius: 999px !important;
+        }
+
+        .stButton > button,
+        .stDownloadButton > button,
+        .stLinkButton > a {
+            border: 1px solid var(--plexi-button-border);
+            min-height: 2.85rem;
+            background: var(--plexi-button-surface);
+            color: var(--plexi-ink) !important;
+            box-shadow: none !important;
+        }
+
+        .stButton > button[kind="primary"],
+        .stDownloadButton > button[kind="primary"] {
+            background: var(--plexi-primary-button);
+            color: white;
+            border: none;
+        }
+
+        .stLinkButton > a {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            text-decoration: none !important;
+        }
+
+        .stLinkButton > a:hover,
+        .stButton > button:hover,
+        .stDownloadButton > button:hover {
+            border-color: var(--plexi-accent);
+            background: var(--plexi-button-hover);
+            color: var(--plexi-ink) !important;
+        }
+
+        .stButton > button:disabled,
+        .stDownloadButton > button:disabled,
+        .stLinkButton > a[disabled] {
+            opacity: 0.55;
+            color: var(--plexi-muted) !important;
+        }
+
+        .stTextInput input,
+        .stSelectbox [data-baseweb="select"] > div,
+        .stTextArea textarea,
+        .stChatInput textarea {
+            background: var(--plexi-panel-strong) !important;
+            color: var(--plexi-ink) !important;
+            border-color: var(--plexi-line) !important;
+        }
+
+        .stSelectbox [data-baseweb="select"] *,
+        .stTextInput input::placeholder,
+        .stTextArea textarea::placeholder,
+        .stChatInput textarea::placeholder {
+            color: var(--plexi-muted) !important;
+        }
+
+        div[data-baseweb="select"] svg,
+        div[data-baseweb="select"] path {
+            color: var(--plexi-accent) !important;
+            fill: var(--plexi-accent) !important;
+        }
+
+        .stChatInputContainer,
+        div[data-testid="stChatMessage"] {
+            border-radius: 22px;
+        }
+
+        div[data-testid="stBottomBlockContainer"],
+        div[data-testid="stBottomBlockContainer"] > div,
+        div[data-testid="stBottomBlockContainer"] > div > div,
+        div[data-testid="stChatInput"],
+        div[data-testid="stChatInput"] > div,
+        div[data-testid="stChatInput"] form,
+        div[data-testid="stChatInput"] form > div,
+        .stChatInputContainer {
+            background: var(--plexi-bottom-background) !important;
+        }
+
+        div[data-testid="stChatInput"] {
+            border-top: none !important;
+            padding-top: 0.5rem;
+        }
+
+        div[data-testid="stChatInput"] textarea,
+        div[data-testid="stChatInput"] section,
+        div[data-testid="stChatInput"] [data-baseweb="textarea"] {
+            background: var(--plexi-panel-strong) !important;
+            color: var(--plexi-ink) !important;
+            border-color: var(--plexi-line) !important;
+        }
+
+        div[data-testid="stChatInput"] button {
+            background: var(--plexi-panel-strong) !important;
+            color: var(--plexi-accent) !important;
+            border: 1px solid var(--plexi-button-border) !important;
+        }
+
+        div[data-testid="stChatInput"] button svg,
+        div[data-testid="stChatInput"] button path {
+            fill: currentColor !important;
+        }
+
+        div[data-testid="stSidebar"],
+        div[data-testid="stSidebar"] > div,
+        section[data-testid="stSidebar"] {
+            background: var(--plexi-sidebar-background);
+            border-right: 1px solid var(--plexi-line);
+        }
+
+        div[data-testid="stSidebar"] .block-container {
+            padding-top: 1.2rem;
+        }
+
+        div[data-testid="stSidebarNav"],
+        div[data-testid="stSidebarNav"] ul,
+        div[data-testid="stSidebarNav"] li,
+        div[data-testid="stSidebarUserContent"] {
+            background: transparent !important;
+        }
+
+        div[data-testid="stSidebarNav"] a,
+        div[data-testid="stSidebarNav"] span,
+        div[data-testid="stSidebarNav"] button {
+            color: var(--plexi-ink) !important;
+        }
+
+        div[data-testid="stSidebarNav"] a:hover {
+            background: rgba(255, 255, 255, 0.04);
+        }
+
+        div[data-testid="stExpander"] {
+            border-radius: 18px;
+            border-color: var(--plexi-line);
+            background: var(--plexi-expander-background);
+        }
+
+        div[data-baseweb="popover"],
+        div[data-baseweb="popover"] > div,
+        div[data-baseweb="popover"] > div > div,
+        div[data-baseweb="popover"] > div > div > div,
+        div[data-baseweb="menu"],
+        div[data-baseweb="menu"] > div,
+        div[role="listbox"],
+        ul[role="listbox"] {
+            background: var(--plexi-panel-strong) !important;
+            color: var(--plexi-ink) !important;
+            border: 1px solid var(--plexi-line) !important;
+            box-shadow: var(--plexi-shadow) !important;
+        }
+
+        div[data-baseweb="popover"] *,
+        div[data-baseweb="menu"] *,
+        div[role="listbox"] *,
+        ul[role="listbox"] * {
+            color: var(--plexi-ink) !important;
+        }
+
+        div[data-baseweb="popover"] ul,
+        div[data-baseweb="popover"] li,
+        div[data-baseweb="popover"] li > div,
+        div[data-baseweb="menu"] ul,
+        div[data-baseweb="menu"] li,
+        div[data-baseweb="menu"] li > div {
+            background: var(--plexi-panel-strong) !important;
+        }
+
+        li[role="option"],
+        li[role="option"] > div,
+        li[role="option"] * {
+            background: transparent !important;
+            color: var(--plexi-ink) !important;
+        }
+
+        li[role="option"]:hover,
+        li[role="option"]:hover > div,
+        li[role="option"]:hover *,
+        li[role="option"][aria-selected="true"] {
+            background: var(--plexi-accent-soft) !important;
+            color: var(--plexi-ink) !important;
+        }
+
+        li[role="option"][aria-selected="true"] > div,
+        li[role="option"][aria-selected="true"] * {
+            background: var(--plexi-accent-soft) !important;
+            color: var(--plexi-ink) !important;
+        }
+
+        .plexi-sidecard-title {
+            font-family: "DM Serif Display", Georgia, serif;
+            font-size: 1.25rem;
+            margin-bottom: 0.35rem;
+        }
+
+        .plexi-meta {
+            background: var(--plexi-meta-background);
+            border: 1px solid var(--plexi-line);
+            border-radius: 18px;
+            padding: 0.85rem 1rem;
+            margin-bottom: 1rem;
+        }
+
+        .plexi-meta-row {
+            display: flex;
+            justify-content: space-between;
+            gap: 1rem;
+            align-items: flex-start;
+            padding: 0.65rem 0;
+            border-bottom: 1px solid var(--plexi-meta-row-border);
+        }
+
+        .plexi-meta-row:last-child {
+            border-bottom: none;
+            padding-bottom: 0;
+        }
+
+        .plexi-meta-row:first-child {
+            padding-top: 0;
+        }
+
+        .plexi-meta-key {
+            color: var(--plexi-muted);
+            font-size: 0.78rem;
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+            flex: 0 0 38%;
+        }
+
+        .plexi-meta-value {
+            text-align: right;
+            color: var(--plexi-ink);
+            font-size: 0.96rem;
+            line-height: 1.5;
+            overflow-wrap: anywhere;
+        }
+
+        .plexi-filelist {
+            margin: 0;
+            padding-left: 1.1rem;
+            color: var(--plexi-muted);
+            line-height: 1.7;
+        }
+
+        .plexi-filelist li.current {
+            color: var(--plexi-ink);
+            font-weight: 600;
+        }
+
+        .plexi-divider {
+            height: 1px;
+            background: var(--plexi-divider);
+            margin: 1rem 0 1.1rem;
+        }
+
+$system_css
+        @media (max-width: 900px) {
+            .block-container {
+                padding-top: 1.2rem;
+            }
+
+            .plexi-hero {
+                padding: 1.35rem 1.2rem;
+                border-radius: 20px;
+            }
+
+            .plexi-stat {
+                min-height: 0;
+            }
+
+            .plexi-meta-row {
+                display: block;
+            }
+
+            .plexi-meta-value {
+                text-align: left;
+                margin-top: 0.2rem;
+            }
+
+            .plexi-cta-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+        </style>
+        """
+    ).substitute(
+        {
+            "palette_vars": _css_vars_block(palette),
+            "color_scheme": color_scheme,
+            "system_css": system_css,
+        }
+    )
+    st.markdown(css, unsafe_allow_html=True)
+
+
+def summarize_manifest(manifest):
+    """Return top-level counts for the materials catalog."""
+    subject_total = sum(len(subjects) for subjects in manifest.values())
+    file_total = sum(
+        len(files)
+        for subjects in manifest.values()
+        for types in subjects.values()
+        for files in types.values()
+    )
+    material_types = sorted(
+        {
+            material_type
+            for subjects in manifest.values()
+            for types in subjects.values()
+            for material_type in types.keys()
+        }
+    )
+    return {
+        "semester_count": len(manifest),
+        "subject_count": subject_total,
+        "file_count": file_total,
+        "material_types": material_types,
+    }
+
+
+def summarize_subject_catalog(subject_data):
+    """Return counts for one selected subject catalog."""
+    return {
+        "type_count": len(subject_data),
+        "file_count": sum(len(files) for files in subject_data.values()),
+        "types": sorted(subject_data.keys()),
+    }
+
+
+def render_page_header(kicker, title, subtitle, badges=None):
+    """Render a shared hero block for each page."""
+    badge_html = ""
+    if badges:
+        badge_html = "".join(
+            f'<span class="plexi-chip">{escape(str(badge))}</span>'
+            for badge in badges
+            if badge
+        )
+        badge_html = f'<div class="plexi-chip-row">{badge_html}</div>'
+
+    st.markdown(
+        f"""
+        <section class="plexi-hero">
+            <div class="plexi-kicker">{escape(kicker)}</div>
+            <h1 class="plexi-title">{escape(title)}</h1>
+            <p class="plexi-subtitle">{escape(subtitle)}</p>
+            {badge_html}
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def render_stat_cards(cards):
+    """Render compact metrics in a responsive grid."""
+    if not cards:
+        return
+
+    cols = st.columns(len(cards))
+    for col, card in zip(cols, cards):
+        label = escape(str(card.get("label", "")))
+        value = escape(str(card.get("value", "")))
+        note = escape(str(card.get("note", "")))
+        with col:
+            st.markdown(
+                f"""
+                <div class="plexi-stat">
+                    <div class="plexi-stat-label">{label}</div>
+                    <div class="plexi-stat-value">{value}</div>
+                    <div class="plexi-stat-note">{note}</div>
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+
+def render_panel(title, body, tone="default"):
+    """Render a simple informational panel."""
+    panel_class = "plexi-callout" if tone == "callout" else "plexi-panel"
+    st.markdown(
+        f"""
+        <section class="{panel_class}">
+            <div class="plexi-sidecard-title">{escape(title)}</div>
+            <div class="plexi-muted">{escape(body)}</div>
+        </section>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _manifest_url():
+    """Raw GitHub URL for manifest.json."""
+    return f"https://raw.githubusercontent.com/{MATERIALS_REPO}/{MANIFEST_BRANCH}/manifest.json"
+
+
+@st.cache_data(ttl=300, show_spinner=False)
+def get_manifest():
+    """Fetch the materials manifest from GitHub. Cached for 5 minutes."""
+    url = _manifest_url()
+    resp = requests.get(url, timeout=15)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def download_github_file(download_url, max_retries=3):
+    """Download a file from a GitHub Release asset URL with retry logic."""
+    for attempt in range(max_retries):
+        try:
+            resp = requests.get(download_url, timeout=60)
+            resp.raise_for_status()
+            return resp.content
+        except requests.RequestException as err:
+            print(f"Download error (attempt {attempt + 1}): {err}")
+            if attempt == max_retries - 1:
+                raise
+    return None
+
+
+def get_mime_type(filename):
+    """Guess MIME type from filename extension."""
+    mime, _ = mimetypes.guess_type(filename)
+    return mime or "application/octet-stream"
+
+
+def render_sidebar():
+    """Render the shared sidebar with branding and outbound links."""
+    with st.sidebar:
+        current_mode = get_theme_mode()
+        widget_value = current_mode.capitalize()
+        if st.session_state.get(THEME_MODE_WIDGET_KEY) != widget_value:
+            st.session_state[THEME_MODE_WIDGET_KEY] = widget_value
+        st.markdown(
+            """
+            <section class="plexi-sidecard">
+                <div class="plexi-kicker">Plexi</div>
+                <div class="plexi-sidecard-title">Grounded study assistant</div>
+                <div class="plexi-muted">
+                    Browse materials, preview files, and ask questions backed by the
+                    currently loaded course content.
+                </div>
+            </section>
+            """,
+            unsafe_allow_html=True,
+        )
+        st.markdown(
+            '<div class="plexi-section-label">Appearance</div>',
+            unsafe_allow_html=True,
+        )
+        st.selectbox(
+            "Theme",
+            ["System", "Light", "Dark"],
+            key=THEME_MODE_WIDGET_KEY,
+            on_change=sync_theme_mode,
+            help="System follows your device preference unless you override it here.",
+        )
+        st.caption("Built by **Kunal Gupta** (LazyHuman)")
+        cols = st.columns(3)
+        with cols[0]:
+            st.link_button("Web", "https://lazyhideout.tech", use_container_width=True)
+        with cols[1]:
+            st.link_button(
+                "GitHub", "https://github.com/kunalgupta25", use_container_width=True
+            )
+        with cols[2]:
+            st.link_button(
+                "Ko-fi", "https://ko-fi.com/lazy_human", use_container_width=True
+            )
+        st.markdown('<div class="plexi-divider"></div>', unsafe_allow_html=True)
+
+
+def read_pdf_text(pdf_bytes):
+    """Extract text from PDF bytes with error handling."""
+    text = []
+    try:
+        reader = PyPDF2.PdfReader(io.BytesIO(pdf_bytes))
+        for page in reader.pages:
+            try:
+                page_text = page.extract_text()
+                if page_text:
+                    filtered = page_text.encode("utf-16", "surrogatepass").decode(
+                        "utf-16", "ignore"
+                    )
+                    text.append(filtered)
+            except Exception:
+                pass
+        return "\n".join(text)
+    except Exception:
+        return pdf_bytes.decode("utf-8", errors="ignore") if pdf_bytes else ""
+
+
+def load_subject_context(manifest, semester, subject):
+    """Download and extract text from all files for a given semester + subject.
+
+    Returns (context_string, source_list) where:
+    - context_string: numbered source blocks for the system prompt
+    - source_list: list of dicts with 'id', 'name', 'type' for citation display
+    """
+    subject_data = manifest.get(semester, {}).get(subject, {})
+    parts = []
+    sources = []
+    source_id = 0
+
+    for file_type, file_list in subject_data.items():
+        for file_entry in file_list:
+            name = file_entry["name"]
+            mime = get_mime_type(name)
+
+            if not (mime.startswith("text/") or mime == "application/pdf"):
+                continue
+
+            try:
+                content = download_github_file(file_entry["download_url"])
+                if not content:
+                    continue
+
+                if mime == "application/pdf":
+                    text = read_pdf_text(content)
+                else:
+                    text = content.decode("utf-8", errors="ignore")
+
+                if text.strip():
+                    source_id += 1
+                    sources.append({"id": source_id, "name": name, "type": file_type})
+                    parts.append(
+                        f"[Source {source_id}: {name} ({file_type})]\n{text}\n[End Source {source_id}]"
+                    )
+            except Exception as err:
+                print(f"Error loading {name}: {err}")
+
+    return "\n\n".join(parts), sources
+
+
+# RAG index loading from GitHub
+# The index is pre-built by GitHub Actions (build_index.py) and
+# committed to the materials repo. We just download and load it.
+
+EMBED_MODEL_ID = "sentence-transformers/all-MiniLM-L6-v2"  # must match build_index.py
+INDEX_FILES = [
+    "default__vector_store.json",
+    "docstore.json",
+    "graph_store.json",
+    "image__vector_store.json",
+    "index_store.json",
+]
+
+
+@st.cache_resource(show_spinner="Loading RAG index...")
+def fetch_rag_index():
+    """
+    Download the pre-built LlamaIndex from the materials repo and return
+    a ready-to-use VectorStoreIndex. Cached once per Streamlit session.
+
+    Returns (index, error_msg) - index is None if loading failed.
+    """
+    if not LLAMA_INDEX_AVAILABLE:
+        return (
+            None,
+            "LlamaIndex not installed - install llama-index-core and dependencies.",
+        )
+
+    index_base_url = (
+        f"https://raw.githubusercontent.com/{MATERIALS_REPO}/{MANIFEST_BRANCH}/index"
+    )
+
+    index_dir = tempfile.mkdtemp(prefix="plexi_index_")
+    try:
+        for filename in INDEX_FILES:
+            url = f"{index_base_url}/{filename}"
+            resp = requests.get(url, timeout=30)
+            resp.raise_for_status()
+            with open(os.path.join(index_dir, filename), "wb") as file_handle:
+                file_handle.write(resp.content)
+    except Exception as err:
+        return None, f"Failed to download index files: {err}"
+
+    try:
+        embed_model = HuggingFaceEmbedding(model_name=EMBED_MODEL_ID)
+        Settings.embed_model = embed_model
+        Settings.llm = None
+
+        storage_context = StorageContext.from_defaults(persist_dir=index_dir)
+        index = load_index_from_storage(storage_context)
+        return index, None
+    except Exception as err:
+        return None, f"Failed to load index: {err}"