initial commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,103 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Environment variables
+.env
+.env.*
+
+# Virtual environments
+env/
+.venv/
+venv/
+ENV/
+
+# VS Code settings
+.vscode/
+
+# Data files
+*.xlsx
+*.csv
+*.tsv
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Python egg files
+*.egg
+*.egg-info/
+dist/
+build/
+
+# Logs
+*.log
+
+# Misc
+*.bak
+*.swp
+*.swo
+
+# Ignore model files and large downloads
+*.bin
+*.h5
+*.ckpt
+*.pt
+*.pth
+
+# Ignore outputs
+*.out
+*.tmp
+
+# Ignore Python and Jupyter temp files
+*.tmp
+*.temp
+*~
+*.bak
+*.swp
+*.swo
+*.pyc
+*.pyo
+*$py.class
+*.python
+# Jupyter Notebook temp files
+**/tempCodeRunnerFile.*
+
+# CONFIG.CFG
+*.cfg
+
+*assembly_ai.py
+*stt_routes.py
+*stt.py
+
+*test.ipynb
+*chat1.html
+*chat2.html
+*chat3.html
+*chat4.html
+*chat5.html
+*chat6.html
+*chat7.html
+*chat8.html
+*test.html
+*assembly_ai_transcriber_without_mic.py
+*assembly_ai_transcriber_old.py
+*ws_transcriber_old.py
+*transcribe_old.py
+*ws_speak.py
+*endpoint_tester.ipynb
+*stt_end.py
+*speak_old.py
+*chat_old.py
+*unilever_logo1.png
+
+*.png
+*config_old.py
+
+*ws_transcriber.py
+*speak.py
+*transcribe.py

Dockerfile

@@ -0,0 +1,47 @@
+FROM python:3.11-slim-bookworm
+
+# # Set up a new user named "user" with user ID 1000
+# RUN useradd -m -u 1000 user
+
+# # Switch to the "user" user
+# USER user
+
+LABEL maintainer="Maqbool Ahmed <[email protected]>"
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONWARNINGS="ignore:Unverified HTTPS request"
+
+
+# Install dependencies for PyAudio
+RUN apt-get update && apt-get install -y \
+    gcc \
+    libasound2-dev \
+    portaudio19-dev \
+    libportaudio2 \
+    libportaudiocpp0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip
+RUN python3 -m pip install --upgrade pip==24.3.1
+
+# Create workdir
+WORKDIR /app
+
+# Copy requirements first (for caching)
+COPY requirements.txt .
+
+# Install dependencies (uvicorn[standard] includes websockets)
+RUN pip install --no-cache-dir -r requirements.txt \
+    && pip install --no-cache-dir "uvicorn[standard]"
+
+# Copy app code and assets
+COPY app ./app
+# COPY *.png ./
+
+# Expose Hugging Face Spaces port (must be 7860)
+EXPOSE 7860
+
+# Start FastAPI with WebSocket support
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--ws", "websockets"]

app/api/chat.py

@@ -0,0 +1,140 @@
+from fastapi import APIRouter
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from app.models.chat import ChatRequest
+from app.services.chat_service import (
+    get_embedding_async,
+    query_pinecone_async,
+    query_groq_stream_async,
+    pinecone_query_maker,
+)
+import json
+import uuid
+
+router = APIRouter()
+
+# In-memory session store (for dev only)
+chat_sessions = {}
+
+
+@router.get("/")
+def serve_chat_html():
+    """Serve chat.html from static directory."""
+    return FileResponse("app/static/chat.html")
+
+
+@router.post("/stream/start")
+async def start_chat_session(payload: ChatRequest):
+    """Initialize a new chat session."""
+    session_id = str(uuid.uuid4())
+    chat_sessions[session_id] = {
+        "user_query": payload.user_query,
+        "chat_state": payload.chat_state,
+        "memory_state": payload.memory_state,
+    }
+    return {"session_id": session_id}
+
+
+@router.get("/stream")
+async def chat_stream(session_id: str):
+    """Stream AI response for a session using SSE."""
+    session = chat_sessions.pop(session_id, None)
+    if not session:
+        return JSONResponse({"error": "Invalid session_id"}, status_code=400)
+
+    user_query = session["user_query"]
+    chat_state = session["chat_state"]
+    memory_state = session["memory_state"]
+
+    async def event_stream():
+        partial_response = ""
+        # Build chat history from memory_state
+
+        history_str = "\n".join(memory_state)
+        if len(memory_state) > 0:
+            history = f"{memory_state[-1]}"
+        else:
+            history = f"{memory_state}"
+
+        pinecone_query = pinecone_query_maker(user_query, history)
+
+        # Async embedding
+        embedding = await get_embedding_async(pinecone_query)
+
+        # Async Pinecone query
+        relevant_chunks = await query_pinecone_async(embedding)
+
+        # Sort all chunks in descending order by score
+        sorted_chunks = sorted(relevant_chunks, key=lambda x: x["score"], reverse=True)
+
+        # Select the top 6 scoring chunks
+        top_chunks = sorted_chunks[:6]
+
+        # Build context from top chunks
+        context = "\n".join(
+            f"{chunk['score']}\n"
+            f"{chunk['metadata'].get('source', '')}\n"
+            f"{chunk['metadata'].get('link', '')}\n"
+            f"{chunk['metadata'].get('text', '')}"
+            for chunk in top_chunks
+        )
+
+        prompt = f"""
+        You are a professional assistant for helping user to understand ISO data.
+
+        🎯 Use *only* the information from the provided document context to respond.
+
+        🚫 DO NOT:
+        - Invent, assume, or infer beyond what's explicitly stated in the context.
+        - Generate or modify any links—only use links already present in the **context**.
+        - Reference external sources or extrapolate outside the provided material.
+
+        📌 Note:
+        If the user replies with "no", "nah", "not", "nope", or "nopes", respond only with:
+        **"Anything else I can help you with?"**
+
+        ---
+
+        📄 **Context**:
+        {context}
+
+        ---
+
+        🧠 **Response Guidelines**:
+        - ✅ Format all outputs in **Markdown** for readability.
+        - ✅ Convert any tables into well-structured paragraphs for smoother narrative flow.
+        - ✅ Conclude every response with the following clearly labeled sections:
+
+        ### Follow-Up Question Suggestions:
+        *Would you like to ask any of these follow-up questions based on the above?*
+
+        - ✅ If the context contains no relevant information, respond with:
+        *"No relevant information available in the provided documents."*
+
+        - ✅ Never fabricate sources, assumptions, or external references.
+        """
+
+        # Async LLM streaming with full context
+        async for chunk in query_groq_stream_async(pinecone_query, prompt):
+            # async for chunk in query_groq_stream_async(user_prompt, prompt):
+            partial_response += chunk
+            data = {
+                "partial_response": partial_response,
+                "chat_state": chat_state + [(user_query, partial_response)],
+                "memory_state": memory_state,
+            }
+            yield f"data: {json.dumps(data)}\n\n"
+
+        # Final state update
+        memory_state.append(f"User: {user_query}")
+        memory_state.append(f"{partial_response}")
+        chat_state.append((user_query, partial_response))
+
+        yield f"data: {json.dumps({'final': True, 'chat_state': chat_state, 'memory_state': memory_state})}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+@router.post("/clear")
+async def clear_chat():
+    """Clear session state (frontend reset)."""
+    return JSONResponse(content={"chat_state": [], "memory_state": [], "input_box": ""})

app/core/clients.py

@@ -0,0 +1,27 @@
+from pinecone import Pinecone
+from openai import OpenAI
+from groq import Groq
+from cartesia import Cartesia
+# from app.core.config import PINECONE_API, NVIDIA_API, GROQ_API_KEY, CARTESIA_API_KEY
+from app.core.config import PINECONE_API, NVIDIA_API, GROQ_API_KEY
+
+# from app.core.config import PINECONE_API, NVIDIA_API
+
+# Pinecone client
+pc = Pinecone(api_key=PINECONE_API)
+index = pc.Index("isocert")
+
+# NVIDIA embedding client
+embedding_client = OpenAI(
+    api_key=NVIDIA_API,
+    base_url="https://integrate.api.nvidia.com/v1",
+)
+
+# Groq client
+groq_client = Groq(api_key=GROQ_API_KEY)
+
+# # Cartesia client
+# cartesia_client = Cartesia(api_key=CARTESIA_API_KEY)
+
+# # tts_test
+# cartesia_client = Cartesia(api_key=)

app/core/config.py

@@ -0,0 +1,30 @@
+import os
+from dotenv import load_dotenv
+
+# Load variables from .env file (if present)
+load_dotenv()
+
+# Application mode
+APPLICATION_TYPE = os.getenv("APPLICATION_TYPE", "STANDALONE")
+print(f"APPLICATION_TYPE = {APPLICATION_TYPE}")
+
+# === PINECONE ===
+PINECONE_API = os.getenv("PINECONE_API")
+PINECONE_ENV = os.getenv("PINECONE_ENV")
+PINECONE_NAMESPACE = os.getenv("PINECONE_NAMESPACE", "").split(",") if os.getenv("PINECONE_NAMESPACE") else [
+    "iso_certificates",
+]
+
+# === GROQ ===
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")   # instead of TEST_API
+
+LLM_MODEL = os.getenv("LLM_MODEL")
+
+# === NVIDIA ===
+NVIDIA_API = os.getenv("NVIDEA_EMBEDDING_API")
+
+# # === ASSEMBLY ===
+# ASSEMBLY_API_KEY = os.getenv("ASSEMBLY_API_KEY")
+
+# # === CARTESIA ===
+# CARTESIA_API_KEY = os.getenv("CARTESIA_API_KEY")

app/main.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+# from app.api import chat, transcribe, speak
+from app.api import chat
+
+app = FastAPI(title="AI Assistant for ISO Documents")
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Change to specific frontend domain in prod
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Static files
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+
+# Routers
+app.include_router(chat.router, prefix="/chat", tags=["Chat"])
+
+# app.include_router(transcribe.router, prefix="/stt")
+
+# app.include_router(speak.router, prefix="/tts")
+
+print("✅ FastAPI backend for AI Assistant is ready.")
+
+# print("🌐 Visit http://127.0.0.1:8000 to open chat UI.")
+# print("📄 API docs available at http://127.0.0.1:8000/docs")
+
+print("🌐 Visit https://inveros-tech-iso-rag.hf.space/chat to open chat UI.")
+print("📄 API docs available at https://inveros-tech-iso-rag.hf.space/docs")

app/models/chat.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from typing import Literal, Optional
+from datetime import datetime
+
+
+class ChatRequest(BaseModel):
+    user_query: str
+    chat_state: list
+    memory_state: list
+
+
+# class STTResponse(BaseModel):
+#     type: Literal["partial", "final", "error", "closed"]
+#     text: Optional[str] = None
+#     timestamp: str = datetime.utcnow().isoformat()
+#     code: Optional[int] = None
+#     reason: Optional[str] = None
+
+
+class STTResponse(BaseModel):
+    type: Literal["partial", "final", "error", "closed"]
+    text: Optional[str] = None
+    timestamp: str = Field(default_factory=lambda: datetime.utcnow().isoformat())
+    code: Optional[int] = None
+    reason: Optional[str] = None

app/services/chat_service.py

@@ -0,0 +1,176 @@
+from fastapi.concurrency import run_in_threadpool
+
+# from app.core.clients import embedding_client, index, groq_client
+from openai import OpenAI
+from app.core.clients import index
+from groq import Groq
+from app.core.config import LLM_MODEL, PINECONE_NAMESPACE, NVIDIA_API, GROQ_API_KEY
+import logging
+
+
+# ------------------------
+# NVIDIA Embedding API
+# ------------------------
+def _get_embedding(text="None"):
+    """Blocking call to get NVIDIA embedding for a text string."""
+    # NVIDIA embedding client
+    embedding_client = OpenAI(
+        api_key=NVIDIA_API,
+        base_url="https://integrate.api.nvidia.com/v1",
+    )
+
+    response = embedding_client.embeddings.create(
+        input=text,
+        model="nvidia/nv-embed-v1",
+        encoding_format="float",
+        extra_body={"input_type": "query", "truncate": "NONE"},
+    )
+    return response.data[0].embedding
+
+
+async def get_embedding_async(text="None"):
+    """Async wrapper for embedding call."""
+    return await run_in_threadpool(_get_embedding, text)
+
+
+# ------------------------
+# Pinecone Query
+# ------------------------
+def _query_pinecone(embedding):
+    """Blocking Pinecone query."""
+    result = index.query_namespaces(
+        vector=embedding,
+        namespaces=PINECONE_NAMESPACE,
+        metric="cosine",
+        top_k=35,
+        include_metadata=True,
+    )
+    return result["matches"]
+
+
+async def query_pinecone_async(embedding):
+    """Async wrapper for Pinecone query."""
+    return await run_in_threadpool(_query_pinecone, embedding)
+
+
+# Instantiate client once and reuse across calls
+client = Groq(api_key=GROQ_API_KEY)
+
+
+def groq_chunk_cleaner(chunk: str) -> str:
+    """
+    Cleans a text chunk using Groq's model by stripping formatting,
+    sources, and boilerplate sections.
+    Preserves the exact user wording and phrasing of the main content.
+    """
+    try:
+        completion = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a Text Cleaning Assistant.\n"
+                        "Your ONLY job is to return the exact same text as provided by the user, "
+                        "but cleaned of unwanted elements.\n\n"
+                        "Strict rules:\n"
+                        "- DO NOT rephrase, paraphrase, or summarize the wording.\n"
+                        "- Preserve all original sentences, casing, punctuation, and wording of the main text.\n"
+                        "- Remove all formatting (Markdown, HTML, LaTeX, bullet points, headers, etc.).\n"
+                        "- Remove links, URLs, and citations.\n"
+                        "- Remove boilerplate sections such as:\n"
+                        "   * 'Sources:' and everything after it.\n"
+                        "   * 'Follow-up Question Suggestions:' and everything after it.\n"
+                        "- Output only the cleaned plain text content with no extra commentary."
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": chunk,
+                },
+            ],
+            temperature=0.1,  # strictly deterministic
+        )
+
+        return completion.choices[0].message.content.strip()
+
+    except Exception as e:
+        logging.error("Groq text cleaning failed: %s", e)
+        return "[Error] Unable to process the request at the moment."
+
+
+def pinecone_query_maker(user_query, history):
+    """
+    Generates an optimized prompt from Groq using prior history and current input.
+    If the input is unrelated, history is ignored. Follow-up logic is handled externally.
+    """
+    client = Groq(api_key=GROQ_API_KEY)
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a prompt optimization engine. Your task is to generate a clean, context-aware prompt "
+                        "for querying a vector database or a language model.\n\n"
+                        "You are given:\n"
+                        "- Prior conversation history (which may or may not be relevant)\n"
+                        "- A new user input (current query)\n\n"
+                        "Instructions:\n"
+                        "- If the user input is clearly related to the conversation history, merge the relevant context "
+                        "to enrich and clarify the prompt.\n"
+                        "- If the new input is unrelated or self-contained, do **not** incorporate history—just enhance the "
+                        "standalone query for precision and clarity.\n"
+                        "- If user input contains 'no', 'nah', 'not', 'nope', or 'nopes', respond only with: 'no'.\n"
+                        "- If user input contains 'yes', 'yup', 'yo', or 'y', analyze the prior question or topic in the Conversation History and generate a meaningful follow-up prompt based on it.\n\n"
+                        "Return only the final optimized user prompt as plain text—no extra commentary, headers, or formatting."
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": (
+                        f"Conversation History:\n{history.strip()}\n\n"
+                        f"User Input:\n{user_query.strip()}"
+                    ),
+                },
+            ],
+            model=LLM_MODEL,
+            temperature=0.4,
+            stream=False,
+        )
+
+        return chat_completion.choices[0].message.content.strip()
+
+    except Exception as e:
+        print("Groq streaming failed:", e)
+        return "[Error] Unable to process the request at the moment."
+
+
+def _query_groq_stream(user_input, relevant_context):
+    """Blocking Groq streaming call."""
+    groq_client = Groq(api_key=GROQ_API_KEY)
+    try:
+        chat_completion = groq_client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": f"{relevant_context}"},
+                {"role": "user", "content": f"{user_input}"},
+            ],
+            model=LLM_MODEL,
+            temperature=0.3,
+            stream=True,
+        )
+
+        for chunk in chat_completion:
+            content = chunk.choices[0].delta.content or ""
+            yield content
+
+    except Exception as e:
+        print("Groq streaming failed:", e)
+        yield "[Error] Unable to process the request at the moment."
+
+
+async def query_groq_stream_async(user_input, relevant_context):
+    """Async wrapper for Groq streaming."""
+    generator = _query_groq_stream(user_input, relevant_context)
+    for chunk in generator:
+        yield chunk

app/static/chat.html

@@ -0,0 +1,947 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ISO Certificate Query System</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/dompurify/dist/purify.min.js"></script>
+    <style>
+        :root {
+            --primary-color: #0068B5;
+            --secondary-color: #00A8E2;
+            --accent-color: #FFCB05;
+            --text-color: #333;
+            --bg-color: #f9f9f9;
+            --message-user-bg: #e3f2fd;
+            --message-assistant-bg: #fff;
+            --border-color: #e0e0e0;
+            --shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+            --success-color: #4CAF50;
+            --warning-color: #FF9800;
+            --error-color: #F44336;
+        }
+
+        .dark-mode {
+            --primary-color: #2C92D5;
+            --secondary-color: #4AB7E6;
+            --accent-color: #FFD54F;
+            --text-color: #f0f0f0;
+            --bg-color: #1a1a1a;
+            --message-user-bg: #2A3C4F;
+            --message-assistant-bg: #2D2D2D;
+            --border-color: #444;
+            --shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+            line-height: 1.6;
+            transition: background-color 0.3s, color 0.3s;
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
+            color: white;
+            padding: 1rem;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            box-shadow: var(--shadow);
+            z-index: 10;
+        }
+
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            font-weight: bold;
+            font-size: 1.2rem;
+        }
+
+        .logo i {
+            font-size: 1.5rem;
+        }
+
+        .controls {
+            display: flex;
+            gap: 0.5rem;
+        }
+
+        .btn {
+            background: rgba(255, 255, 255, 0.2);
+            border: none;
+            border-radius: 50%;
+            width: 2.5rem;
+            height: 2.5rem;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            color: white;
+            transition: background 0.2s;
+        }
+
+        .btn:hover {
+            background: rgba(255, 255, 255, 0.3);
+        }
+
+        .main {
+            display: flex;
+            flex: 1;
+            overflow: hidden;
+        }
+
+        .sidebar {
+            width: 300px;
+            background-color: var(--bg-color);
+            border-right: 1px solid var(--border-color);
+            padding: 1rem;
+            display: flex;
+            flex-direction: column;
+            transition: transform 0.3s;
+        }
+
+        .sidebar.hidden {
+            transform: translateX(-100%);
+        }
+
+        .connection-status {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            margin-bottom: 1rem;
+            padding: 0.5rem;
+            border-radius: 4px;
+            background-color: rgba(0, 0, 0, 0.05);
+        }
+
+        .connection-status i {
+            font-size: 0.7rem;
+        }
+
+        .chat-container {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .chat-box {
+            flex: 1;
+            padding: 1rem;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .message {
+            max-width: 80%;
+            padding: 0.75rem 1rem;
+            border-radius: 1rem;
+            position: relative;
+            animation: fadeIn 0.3s;
+            box-shadow: var(--shadow);
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .message.user {
+            align-self: flex-end;
+            background-color: var(--message-user-bg);
+            border-bottom-right-radius: 0.25rem;
+        }
+
+        .message.assistant {
+            align-self: flex-start;
+            background-color: var(--message-assistant-bg);
+            border-bottom-left-radius: 0.25rem;
+        }
+
+        .message-time {
+            font-size: 0.7rem;
+            opacity: 0.7;
+            margin-top: 0.5rem;
+        }
+
+        .message-actions {
+            position: absolute;
+            top: 0.5rem;
+            right: 0.5rem;
+            display: none;
+            gap: 0.25rem;
+        }
+
+        .message:hover .message-actions {
+            display: flex;
+        }
+
+        .message-action {
+            background: rgba(0, 0, 0, 0.1);
+            border: none;
+            border-radius: 50%;
+            width: 1.5rem;
+            height: 1.5rem;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            font-size: 0.7rem;
+            color: inherit;
+        }
+
+        .message-action:hover {
+            background: rgba(0, 0, 0, 0.2);
+        }
+
+        .typing-indicator {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.75rem 1rem;
+            background-color: var(--message-assistant-bg);
+            border-radius: 1rem;
+            align-self: flex-start;
+            margin-bottom: 1rem;
+            box-shadow: var(--shadow);
+        }
+
+        .typing-dot {
+            width: 8px;
+            height: 8px;
+            background-color: var(--text-color);
+            border-radius: 50%;
+            opacity: 0.6;
+            animation: typing-dot 1.4s infinite ease-in-out both;
+        }
+
+        .typing-dot:nth-child(1) {
+            animation-delay: -0.32s;
+        }
+
+        .typing-dot:nth-child(2) {
+            animation-delay: -0.16s;
+        }
+
+        @keyframes typing-dot {
+
+            0%,
+            80%,
+            100% {
+                transform: scale(0.8);
+            }
+
+            40% {
+                transform: scale(1);
+            }
+        }
+
+        .input-area {
+            padding: 1rem;
+            border-top: 1px solid var(--border-color);
+            display: flex;
+            gap: 0.5rem;
+            background-color: var(--bg-color);
+            z-index: 5;
+        }
+
+        .input-wrapper {
+            flex: 1;
+            position: relative;
+            display: flex;
+            align-items: flex-end;
+        }
+
+        #user-input {
+            flex: 1;
+            border: 1px solid var(--border-color);
+            border-radius: 1.5rem;
+            padding: 0.75rem 3.5rem 0.75rem 1rem;
+            resize: none;
+            min-height: 3rem;
+            max-height: 10rem;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+            font-family: inherit;
+            box-shadow: var(--shadow);
+        }
+
+        #user-input:focus {
+            outline: none;
+            border-color: var(--primary-color);
+        }
+
+        .input-buttons {
+            position: absolute;
+            right: 0.5rem;
+            bottom: 0.5rem;
+            display: flex;
+            gap: 0.25rem;
+        }
+
+        .input-btn {
+            background: none;
+            border: none;
+            width: 2rem;
+            height: 2rem;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            color: var(--text-color);
+        }
+
+        .input-btn:hover {
+            background: rgba(0, 0, 0, 0.05);
+        }
+
+        .input-btn.primary {
+            background-color: var(--primary-color);
+            color: white;
+        }
+
+        .input-btn.primary:hover {
+            opacity: 0.9;
+        }
+
+        .settings-panel {
+            position: fixed;
+            top: 0;
+            right: 0;
+            bottom: 0;
+            width: 300px;
+            background-color: var(--bg-color);
+            border-left: 1px solid var(--border-color);
+            padding: 1.5rem;
+            box-shadow: var(--shadow);
+            transform: translateX(100%);
+            transition: transform 0.3s;
+            z-index: 100;
+            overflow-y: auto;
+        }
+
+        .settings-panel.open {
+            transform: translateX(0);
+        }
+
+        .settings-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1.5rem;
+            padding-bottom: 0.5rem;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .settings-close {
+            background: none;
+            border: none;
+            cursor: pointer;
+            color: var(--text-color);
+            font-size: 1.2rem;
+        }
+
+        .settings-group {
+            margin-bottom: 1.5rem;
+        }
+
+        .settings-group h3 {
+            margin-bottom: 0.75rem;
+            font-size: 1rem;
+        }
+
+        .form-group {
+            margin-bottom: 1rem;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 0.25rem;
+            font-size: 0.9rem;
+        }
+
+        .form-group input[type="text"],
+        .form-group input[type="number"] {
+            width: 100%;
+            padding: 0.5rem;
+            border: 1px solid var(--border-color);
+            border-radius: 4px;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+        }
+
+        .settings-footer {
+            margin-top: 2rem;
+            display: flex;
+            justify-content: flex-end;
+        }
+
+        #save-settings {
+            background: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: 4px;
+            padding: 0.5rem 1rem;
+            cursor: pointer;
+        }
+
+        #save-settings:hover {
+            opacity: 0.9;
+        }
+
+        .toast {
+            position: fixed;
+            bottom: 1rem;
+            left: 50%;
+            transform: translateX(-50%);
+            padding: 0.75rem 1.5rem;
+            border-radius: 2rem;
+            background: var(--text-color);
+            color: var(--bg-color);
+            box-shadow: var(--shadow);
+            display: none;
+            z-index: 1000;
+            animation: toast-in 0.3s, toast-out 0.3s 2.7s forwards;
+        }
+
+        @keyframes toast-in {
+            from {
+                opacity: 0;
+                transform: translate(-50%, 100%);
+            }
+
+            to {
+                opacity: 1;
+                transform: translate(-50%, 0);
+            }
+        }
+
+        @keyframes toast-out {
+            from {
+                opacity: 1;
+                transform: translate(-50%, 0);
+            }
+
+            to {
+                opacity: 0;
+                transform: translate(-50%, 100%);
+            }
+        }
+
+        .toast.success {
+            background: var(--success-color);
+            color: white;
+        }
+
+        .toast.warning {
+            background: var(--warning-color);
+            color: white;
+        }
+
+        .toast.error {
+            background: var(--error-color);
+            color: white;
+        }
+
+        .quick-actions {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.5rem;
+            margin-bottom: 1rem;
+        }
+
+        .quick-action {
+            background: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: 1rem;
+            padding: 0.5rem 1rem;
+            font-size: 0.8rem;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        .quick-action:hover {
+            background: var(--secondary-color);
+        }
+
+        .certificate-info {
+            background-color: var(--message-assistant-bg);
+            border-radius: 0.5rem;
+            padding: 1rem;
+            margin-bottom: 1rem;
+            box-shadow: var(--shadow);
+        }
+
+        .certificate-info h3 {
+            margin-bottom: 0.5rem;
+            color: var(--primary-color);
+        }
+
+        .certificate-info ul {
+            padding-left: 1.5rem;
+        }
+
+        .certificate-info li {
+            margin-bottom: 0.25rem;
+        }
+
+        @media (max-width: 768px) {
+            .sidebar {
+                position: absolute;
+                left: 0;
+                top: 0;
+                bottom: 0;
+                z-index: 20;
+                box-shadow: var(--shadow);
+            }
+
+            .message {
+                max-width: 90%;
+            }
+
+            .settings-panel {
+                width: 100%;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="header">
+        <div class="logo">
+            <i class="fas fa-certificate"></i>
+            <span>ISO Certificate Query</span>
+        </div>
+        <div class="controls">
+            <button id="theme-toggle" class="btn"><i class="fas fa-moon"></i></button>
+            <button id="settings-toggle" class="btn"><i class="fas fa-cog"></i></button>
+        </div>
+    </div>
+
+    <div class="main">
+        <div class="sidebar">
+            <div class="connection-status" id="connection-status">
+                <i class="fas fa-circle"></i>
+                <span>Connecting...</span>
+            </div>
+            
+            
+            <button id="clear" class="btn"
+                style="background: var(--error-color); color: white; border-radius: 4px; width: auto; padding: 0.5rem 1rem; margin-top: auto;">
+                <i class="fas fa-trash"></i> Clear Chat
+            </button>
+        </div>
+
+        <div class="chat-container">
+            <div class="chat-box" id="chat-box">
+                <div class="message assistant">
+                    <h3>Welcome to the ISO Certificate Query System</h3>
+                    <p>I can help you find information about ISO certifications.</p>
+                    <div class="message-time">Just now</div>
+                </div>
+            </div>
+
+            <div class="input-area">
+                <div class="input-wrapper">
+                    <textarea id="user-input" placeholder="Ask about ISO certificates (e.g., 'Show me all ISO 9001 certificates')..." rows="1"></textarea>
+                    <div class="input-buttons">
+                        <button id="send" class="input-btn primary">
+                            <i class="fas fa-paper-plane"></i>
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="settings-panel" id="settings-panel">
+        <div class="settings-header">
+            <h2>Settings</h2>
+            <button class="settings-close" id="close-settings">
+                <i class="fas fa-times"></i>
+            </button>
+        </div>
+        <div class="settings-group">
+            <h3>Connection</h3>
+            <div class="form-group">
+                <label for="api-url">API URL</label>
+                <input type="text" id="api-url" placeholder="https://inveros-tech-iso-rag.hf.space">
+            </div>
+        </div>
+        <div class="settings-footer">
+            <button id="save-settings">Save Settings</button>
+        </div>
+    </div>
+
+    <div class="toast" id="toast"></div>
+    <script>
+        // Configuration
+        const config = {
+            // apiUrl: localStorage.getItem('apiUrl') || "http://127.0.0.1:8000",
+            apiUrl: localStorage.getItem('apiUrl') || "https://inveros-tech-iso-rag.hf.space",
+            maxChatHistory: 10,
+            typingIndicatorDelay: 300,
+            reconnectDelay: 5000
+        };
+
+        // Global variables
+        let chatState = [];
+        let memoryState = [];
+        let typingIndicatorTimeout = null;
+        let currentAssistantMessageDiv = null;
+        let eventSource = null;
+        let reconnectAttempts = 0;
+        let maxReconnectAttempts = 3;
+
+        // DOM elements
+        const chatBox = document.getElementById("chat-box");
+        const userInput = document.getElementById("user-input");
+        const sendBtn = document.getElementById("send");
+        const clearBtn = document.getElementById("clear");
+        const themeToggle = document.getElementById("theme-toggle");
+        const settingsToggle = document.getElementById("settings-toggle");
+        const settingsPanel = document.getElementById("settings-panel");
+        const saveSettingsBtn = document.getElementById("save-settings");
+        const closeSettingsBtn = document.getElementById("close-settings");
+        const apiUrlInput = document.getElementById("api-url");
+        const toast = document.getElementById("toast");
+        const connectionStatus = document.getElementById("connection-status");
+        const quickActions = document.querySelectorAll('.quick-action');
+
+        // Initialize UI
+        function initializeUI() {
+            apiUrlInput.value = config.apiUrl;
+
+            // Set theme based on preference
+            if (localStorage.getItem('darkMode') === 'true') {
+                document.body.classList.add('dark-mode');
+                themeToggle.innerHTML = '<i class="fas fa-sun"></i>';
+            }
+
+            // Auto-resize textarea
+            userInput.addEventListener('input', function () {
+                this.style.height = 'auto';
+                this.style.height = (this.scrollHeight) + 'px';
+            });
+        }
+
+        // Append message to chat with sanitization
+        function appendMessage(role, text, timestamp = new Date()) {
+            const message = document.createElement("div");
+            message.className = `message ${role}`;
+
+            // Generate unique ID for the message
+            const messageId = 'msg-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
+            message.setAttribute('data-message-id', messageId);
+
+            // Sanitize and parse markdown
+            const cleanText = DOMPurify.sanitize(marked.parse(text));
+
+            message.innerHTML = `
+                ${cleanText}
+                <div class="message-time">${timestamp.toLocaleTimeString()}</div>
+                <div class="message-actions">
+                    <button class="message-action" title="Copy"><i class="fas fa-copy"></i></button>
+                    <button class="message-action" title="Delete"><i class="fas fa-trash"></i></button>
+                </div>
+            `;
+
+            // Add event listeners to action buttons
+            const copyBtn = message.querySelector('.message-action:first-child');
+            const deleteBtn = message.querySelector('.message-action:last-child');
+
+            copyBtn.addEventListener('click', () => {
+                navigator.clipboard.writeText(text);
+                showToast('Message copied to clipboard', 'success');
+            });
+
+            deleteBtn.addEventListener('click', () => {
+                message.remove();
+                showToast('Message deleted', 'info');
+            });
+
+            chatBox.appendChild(message);
+            chatBox.scrollTop = chatBox.scrollHeight;
+
+            return message;
+        }
+
+        // Show typing indicator
+        function showTypingIndicator() {
+            if (document.querySelector('.typing-indicator')) return;
+
+            const typingDiv = document.createElement('div');
+            typingDiv.className = 'typing-indicator';
+            typingDiv.innerHTML = `
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+                <span>Searching certificates...</span>
+            `;
+            chatBox.appendChild(typingDiv);
+            chatBox.scrollTop = chatBox.scrollHeight;
+        }
+
+        // Hide typing indicator
+        function hideTypingIndicator() {
+            const typingIndicator = document.querySelector('.typing-indicator');
+            if (typingIndicator) {
+                typingIndicator.remove();
+            }
+        }
+
+        // Show toast notification
+        function showToast(message, type = 'info', duration = 3000) {
+            toast.textContent = message;
+            toast.className = `toast ${type}`;
+            toast.style.display = 'block';
+
+            setTimeout(() => {
+                toast.style.display = 'none';
+            }, duration);
+        }
+
+        // Show error message
+        function showError(message) {
+            showToast(message, 'error');
+        }
+
+        // Update connection status
+        function updateConnectionStatus(connected) {
+            if (connected) {
+                connectionStatus.innerHTML = '<i class="fas fa-circle" style="color: #2ecc71;"></i> Connected';
+                connectionStatus.style.color = '#2ecc71';
+            } else {
+                connectionStatus.innerHTML = '<i class="fas fa-circle" style="color: #e74c3c;"></i> Disconnected';
+                connectionStatus.style.color = '#e74c3c';
+            }
+        }
+
+        // Send query to backend with auto-reconnect
+        function sendQuery(query = null) {
+            const queryText = query || userInput.value.trim();
+            if (!queryText) return;
+
+            // If coming from text input, clear the input
+            if (!query) {
+                appendMessage("user", queryText);
+                userInput.value = "";
+                userInput.style.height = 'auto';
+            } else {
+                appendMessage("user", queryText);
+            }
+
+            // Show typing indicator after a short delay
+            if (typingIndicatorTimeout) {
+                clearTimeout(typingIndicatorTimeout);
+            }
+            typingIndicatorTimeout = setTimeout(() => {
+                showTypingIndicator();
+            }, config.typingIndicatorDelay);
+
+            // Close any existing event source
+            if (eventSource) {
+                eventSource.close();
+            }
+
+            fetch(`${config.apiUrl}/chat/stream/start`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    user_query: queryText,
+                    chat_state: chatState,
+                    memory_state: memoryState
+                })
+            })
+                .then(res => {
+                    if (!res.ok) {
+                        throw new Error(`HTTP error! status: ${res.status}`);
+                    }
+                    return res.json();
+                })
+                .then(data => {
+                    updateConnectionStatus(true);
+                    reconnectAttempts = 0;
+
+                    const sessionId = data.session_id;
+                    eventSource = new EventSource(`${config.apiUrl}/chat/stream?session_id=${sessionId}`);
+
+                    eventSource.onmessage = (event) => {
+                        hideTypingIndicator();
+                        const data = JSON.parse(event.data);
+
+                        if (data.final) {
+                            chatState = data.chat_state;
+                            memoryState = data.memory_state;
+                            eventSource.close();
+                            currentAssistantMessageDiv = null;
+                        } else {
+                            const assistantMessage = DOMPurify.sanitize(marked.parse(data.partial_response));
+
+                            if (!currentAssistantMessageDiv) {
+                                currentAssistantMessageDiv = document.createElement("div");
+                                currentAssistantMessageDiv.className = "message assistant";
+                                currentAssistantMessageDiv.innerHTML = assistantMessage;
+                                chatBox.appendChild(currentAssistantMessageDiv);
+                            } else {
+                                currentAssistantMessageDiv.innerHTML = assistantMessage;
+                            }
+                            chatBox.scrollTop = chatBox.scrollHeight;
+                        }
+                    };
+
+                    eventSource.onerror = (err) => {
+                        console.error("SSE error", err);
+                        hideTypingIndicator();
+
+                        if (reconnectAttempts < maxReconnectAttempts) {
+                            reconnectAttempts++;
+                            showToast(`Connection lost. Reconnecting (${reconnectAttempts}/${maxReconnectAttempts})...`, 'warning');
+                            setTimeout(() => sendQuery(queryText), config.reconnectDelay);
+                        } else {
+                            appendMessage("assistant", "[Error] Connection closed.");
+                            updateConnectionStatus(false);
+                            eventSource.close();
+                            currentAssistantMessageDiv = null;
+                        }
+                    };
+                })
+                .catch(err => {
+                    console.error("Failed to send query", err);
+                    hideTypingIndicator();
+                    appendMessage("assistant", "[Error] Unable to send request.");
+                    updateConnectionStatus(false);
+
+                    if (reconnectAttempts < maxReconnectAttempts) {
+                        reconnectAttempts++;
+                        showToast(`Connection error. Retrying (${reconnectAttempts}/${maxReconnectAttempts})...`, 'warning');
+                        setTimeout(() => sendQuery(queryText), config.reconnectDelay);
+                    }
+                });
+        }
+
+        // Clear chat history
+        function clearChat() {
+            fetch(`${config.apiUrl}/chat/clear`, { method: "POST" })
+                .then(res => res.json())
+                .then(data => {
+                    chatState = data.chat_state;
+                    memoryState = data.memory_state;
+                    chatBox.innerHTML = "";
+                    userInput.value = "";
+                    showToast("Chat cleared", 'success');
+                })
+                .catch(() => {
+                    appendMessage("assistant", "[Error] Unable to clear chat.");
+                    showToast("Failed to clear chat", 'error');
+                });
+        }
+
+        // Initialize event listeners
+        function initializeEventListeners() {
+            // Send button and input
+            sendBtn.addEventListener('click', () => sendQuery());
+            userInput.addEventListener('keypress', (e) => {
+                if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    sendQuery();
+                }
+            });
+
+            // Quick action buttons
+            quickActions.forEach(button => {
+                button.addEventListener('click', () => {
+                    const query = button.getAttribute('data-query');
+                    userInput.value = query;
+                    sendQuery();
+                });
+            });
+
+            // Clear chat
+            clearBtn.addEventListener('click', clearChat);
+
+            // Theme toggle
+            themeToggle.addEventListener('click', () => {
+                document.body.classList.toggle('dark-mode');
+                const isDark = document.body.classList.contains('dark-mode');
+                themeToggle.innerHTML = isDark ? '<i class="fas fa-sun"></i>' : '<i class="fas fa-moon"></i>';
+                localStorage.setItem('darkMode', isDark);
+            });
+
+            // Settings panel
+            settingsToggle.addEventListener('click', () => {
+                settingsPanel.classList.toggle('open');
+            });
+
+            closeSettingsBtn.addEventListener('click', () => {
+                settingsPanel.classList.remove('open');
+            });
+
+            // Save settings
+            saveSettingsBtn.addEventListener('click', () => {
+                config.apiUrl = apiUrlInput.value.trim();
+                localStorage.setItem('apiUrl', config.apiUrl);
+                settingsPanel.classList.remove('open');
+                showToast('Settings saved', 'success');
+            });
+
+            // Close settings when clicking outside
+            document.addEventListener('click', (e) => {
+                if (!settingsPanel.contains(e.target) && e.target !== settingsToggle) {
+                    settingsPanel.classList.remove('open');
+                }
+            });
+
+            // Cleanup on page unload
+            window.addEventListener('beforeunload', () => {
+                if (eventSource) {
+                    eventSource.close();
+                }
+            });
+        }
+
+        // Initialize the app
+        function initializeApp() {
+            initializeUI();
+            initializeEventListeners();
+            updateConnectionStatus(false);
+
+            // Check initial connection
+            fetch(`${config.apiUrl}/chat/`)
+                .then(() => updateConnectionStatus(true))
+                .catch(() => updateConnectionStatus(false));
+        }
+
+        // Start the app
+        initializeApp();
+    </script>
+</body>
+
+</html>

requirements.txt

@@ -0,0 +1,96 @@
+# ====================
+# Core Data Libraries
+# ====================
+pandas>=2.0.0
+numpy>=1.24.0  # Required for math and signal processing
+
+# ============================
+# File and Directory Handling
+# ============================
+glob2>=0.7
+openpyxl  # Excel processing
+pypdf     # PDF processing
+
+# ======================
+# Environment Variables
+# ======================
+python-dotenv>=1.0.0
+dotenv  # Redundant but sometimes required for legacy support
+
+# ================================
+# Machine Learning & NLP Tooling
+# ================================
+transformers>=4.41.1
+# torch>=2.2.0  # Optional but usually required with transformers
+
+# ====================
+# LangChain Ecosystem
+# ====================
+langchain>=0.1.16
+langchain-core>=0.1.40
+langchain-community>=0.0.32
+langchain-text-splitters>=0.0.1
+
+# ==================
+# OpenAI Integration
+# ==================
+openai>=1.30.1
+
+# ================
+# Vector Databases
+# ================
+pinecone
+pinecone[grpc]
+
+# ============
+# Audio Stack
+# ============
+# portaudio==19.6.0
+sounddevice
+soundfile
+assemblyai[extras]
+SpeechRecognition
+PyWavelets==1.8.0  # For signal processing
+matplotlib         # For audio visualization
+# pipwin             # For Windows-based audio driver installs
+# pyaudio-wheels
+# pyaudio>=0.2.14
+# pyaudio==0.2.11
+
+# ========================
+# Web Framework & Runtime
+# ========================
+fastapi
+uvicorn
+
+# =======================
+# WebSocket Communication
+# =======================
+websocket-client
+# websocket
+
+# ==================
+# Optional Dev Tools
+# ==================
+# ipykernel>=6.29.0
+# jupyter>=1.0.0
+
+# ===================
+# UI Framework (TBD)
+# ===================
+# gradio>=4.28.0
+# gradio
+
+# ===========
+# Hardware AI
+# ===========
+groq
+
+# ============
+# Experimental
+# ============
+# rnnoise-cli
+
+
+cartesia
+ffmpeg