ok

.dockerignore

@@ -0,0 +1,21 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+.env.local
+.env
+chatkit_threads.db
+chatkit_threads.db-shm
+chatkit_threads.db-wal
+user_state.db
+chromafast_db/
+output/
+website/
+.git/
+.gitignore
+.dockerignore
+Dockerfile

.gitattributes

@@ -33,3 +33,7 @@ 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
+app/chatkit_threads.db-wal filter=lfs diff=lfs merge=lfs -text
+app/chromafast_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+chatkit_threads.db-wal filter=lfs diff=lfs merge=lfs -text
+chromafast_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.env
+.ruff_cache/
+.pytest_cache/
+.coverage/
+*.log

DEPLOY.md

@@ -0,0 +1,86 @@
+# Deploying to Fly.io
+
+This backend service uses `Docker` and `uv` for easy deployment. Since it uses SQLite for data persistence, we need to configure a persistent volume on Fly.io.
+
+## Prerequisites
+
+1. Install `flyctl` (Fly.io CLI).
+2. Login: `fly auth login`.
+
+## Deployment Steps
+
+### 1. Initialize the App
+
+Run the launch command in this directory (`backend/`):
+
+```bash
+fly launch
+```
+
+- **Choose a unique app name** (e.g., `my-chatkit-backend`).
+- **Select a region** (choose one close to you).
+- **Would you like to set up a Postgresql database now?** -> **No** (we use SQLite).
+- **Would you like to set up an Upstash Redis database now?** -> **No**.
+- **Do you want to deploy now?** -> **No** (we need to set secrets first).
+
+This creates a `fly.toml` file.
+
+### 2. Set Up Data Persistence (Volumes)
+
+Since the app uses SQLite (`chatkit_threads.db` and `user_state.db`), you need a persistent volume so data isn't lost when the app restarts.
+
+Create a 1GB volume (adjust size if needed):
+
+```bash
+fly volumes create chatkit_data --size 1 --region <your-region>
+```
+*Make sure to use the same region you selected in step 1.*
+
+### 3. Update `fly.toml`
+
+Open `fly.toml` and add the `[mounts]` section to mount the volume to `/data` in the container. Also add the environment variables to tell the app to use that path.
+
+Add this to `fly.toml`:
+
+```toml
+[mounts]
+  source = "chatkit_data"
+  destination = "/data"
+
+[env]
+  CHATKIT_DB_PATH = "/data/chatkit_threads.db"
+  USER_STATE_DB_PATH = "/data/user_state.db"
+  PORT = "8000"
+```
+
+### 4. Set Secrets
+
+Set your API keys using `fly secrets`. Copy values from your `.env.local`:
+
+```bash
+fly secrets set \
+  GROQ_API_KEY=your_groq_key \
+  OPENAI_API_KEY=your_openai_key \
+  OPENROUTER_API_KEY=your_openrouter_key \
+  DEEPSEEK_API_KEY=your_deepseek_key \
+  GOOGLE_API_KEY=your_google_key \
+  CARTESIA_API=your_cartesia_key
+```
+
+### 5. Deploy
+
+Now you are ready to deploy:
+
+```bash
+fly deploy
+```
+
+## Verifying Deployment
+
+Check the logs to ensure everything started correctly:
+
+```bash
+fly logs
+```
+
+Your app should now be running!

DEPLOY_HF.md

@@ -0,0 +1,76 @@
+# Deploying to Hugging Face Spaces (Docker)
+
+You can easily deploy this backend to [Hugging Face Spaces](https://huggingface.co/spaces) using their Docker SDK.
+
+## Prerequisites
+
+1. A Hugging Face account.
+2. `pyproject.toml` and `uv.lock` must be in the backend directory.
+
+## Deployment Steps
+
+### 1. Create a New Space
+
+1. Go to [Creates a new Space](https://huggingface.co/new-space).
+2. **Space Name**: e.g., `chatkit-backend`.
+3. **License**: Apache 2.0 or MIT.
+4. **SDK**: Select **Docker**.
+5. **Template**: Choose "Blank".
+6. **Space Hardware**: CPU Basic (Free) is usually enough for this middleware (since generic LLM inference happens externally).
+
+### 2. Configure the Space
+
+Hugging Face Spaces expects the application to listen on port **7860**.
+
+**Option A: Push via Git (Recommended)**
+
+You can simply push your `backend` folder contents to the Space's repository. Note that the Space root must be the directory containing the `Dockerfile`.
+
+If your repo has `backend/Dockerfile`, you might need to adjust the structure or use the "Docker options" in `README.md` (of the space) to point to the correct folder, OR simply copy the backend contents to the root of the Space repo.
+
+**Option B: Adjust Dockerfile for Port 7860**
+
+Your `Dockerfile` currently defaults to port 8000. Hugging Face sets the `PORT` environment variable to `7860` automatically in most cases, but to be safe, you can update your Dockerfile or just rely on the env var override.
+
+**Env Var Override:**  
+The existing Dockerfile uses:  
+`CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]`
+
+To make it compatible with HF's dynamic port, update the `CMD` in `Dockerfile` to use the shell form or rely on the host variable if we use a starter script. Or simpler, just change the default to 7860.
+
+### 3. Persisting Data (SQLite)
+
+On Hugging Face Spaces (Free Tier), the filesystem is **ephemeral**. This means **your database (`chatkit_threads.db`) will be deleted** every time the Space restarts (which happens frequently).
+
+**To keep your chat history:**
+1. Go to your Space **Settings**.
+2. Scroll to "Persistent Storage".
+3. You can upgrade to a paid tier to get a persistent volume mounted at `/data`.
+
+If you enable persistent storage:
+1. Update your Environment Variables (see step 4) to save DBs in `/data`.
+   - `CHATKIT_DB_PATH` = `/data/chatkit_threads.db`
+   - `USER_STATE_DB_PATH` = `/data/user_state.db`
+
+### 4. Set Secrets (Environment Variables)
+
+Go to your Space -> **Settings** -> **Variables and secrets**.
+
+Add the following **Secrets** (Copy from your `.env.local`):
+
+- `GROQ_API_KEY`
+- `OPENAI_API_KEY`
+- `OPENROUTER_API_KEY`
+- `DEEPSEEK_API_KEY`
+- `GOOGLE_API_KEY`
+- `CARTESIA_API`
+
+And add the following **Variables** (if using persistent storage):
+- `CHATKIT_DB_PATH` = `chatkit_threads.db` (or `/data/...`)
+- `USER_STATE_DB_PATH` = `user_state.db` (or `/data/...`)
+
+### 5. Finalize
+
+Once the files are pushed and secrets set, the Space will build locally. Open the **App** tab to see your running backend. The URL will be something like `https://huggingface.co/spaces/<username>/<space-name>`.
+
+You can now point your frontend to this URL!

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.11-slim-bookworm
+
+# Set working directory
+WORKDIR /app
+
+# Install uv
+RUN pip install --no-cache-dir uv
+
+# Copy dependency files
+COPY pyproject.toml uv.lock README.md ./
+
+# Install dependencies
+# --frozen: use exact versions from uv.lock
+# --no-dev: do not install development dependencies
+RUN uv sync --frozen --no-dev
+
+# Copy application code
+COPY app ./app
+
+# Set environment variables
+# Add the virtual environment to PATH
+ENV PATH="/app/.venv/bin:$PATH"
+ENV HOST=0.0.0.0
+ENV PORT=8000
+
+# Expose the port (Hugging Face typically uses 7860, local uses 8000)
+ENV PORT=7860
+EXPOSE $PORT
+
+# Command to run the application (using shell form to expand variables)
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port $PORT"]

README.md

@@ -1,11 +1,27 @@
----
-title: Agent Backend
-emoji: 📉
-colorFrom: pink
-colorTo: pink
-sdk: docker
-pinned: false
-short_description: rag agent
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ChatKit Python Backend
+
+> For the steps to run both fronend and backend apps in this repo, please refer to the README.md at the top directory insteaad.
+
+This FastAPI service wires up a minimal ChatKit server implementation with a single tool capable of recording short facts that users share in the conversation. Facts that are saved through the widget are exposed via the `/facts` REST endpoint so the frontend can render them alongside the chat experience.
+
+## Features
+
+- **ChatKit endpoint** at `POST /chatkit` that streams responses using the ChatKit protocol when the optional ChatKit Python package is installed.
+- **Fact recording tool** that renders a confirmation widget with _Save_ and _Discard_ actions.
+- **Guardrail-ready system prompt** extracted into `app/constants.py` so it is easy to modify.
+- **Simple fact store** backed by in-memory storage in `app/facts.py`.
+- **REST helpers**
+  - `GET  /facts` – list saved facts (used by the frontend list view)
+  - `POST /facts/{fact_id}/save` – mark a fact as saved
+  - `POST /facts/{fact_id}/discard` – discard a pending fact
+  - `GET  /health` – surface a basic health indicator
+
+## Getting started
+
+To enable the realtime assistant you need to install both the ChatKit Python package and the OpenAI SDK, then provide an `OPENAI_API_KEY` environment variable.
+
+```bash
+uv sync
+export OPENAI_API_KEY=sk-proj-...
+uv run uvicorn app.main:app --reload
+```

app/MultiAgent.py

@@ -0,0 +1,187 @@
+from agents import  Agent, ModelSettings, Runner, RunConfig,OpenAIResponsesModel ,AsyncOpenAI,function_tool,OpenAIChatCompletionsModel
+from pydantic import BaseModel
+from datetime import datetime, date
+from dotenv import load_dotenv
+load_dotenv(dotenv_path="./.env.local")
+import asyncio
+from typing import List
+from .VectorDBManagers import VectorDBManager
+from chatkit.agents import AgentContext
+import os 
+import nest_asyncio
+nest_asyncio.apply()
+from .function_tool import suggestion_ragtool
+kimi_model = OpenAIResponsesModel(
+    model="openai/gpt-oss-20b",  # Valid Groq model
+    openai_client=AsyncOpenAI(
+        base_url="https://api.groq.com/openai/v1",
+        api_key=os.getenv("GROQ_API_KEY"),
+    )
+)
+google_model = OpenAIChatCompletionsModel(
+    model="google/gemini-2.5-flash",  # Google Gemini via OpenRouter
+    openai_client=AsyncOpenAI(
+         base_url="https://openrouter.ai/api/v1",
+        api_key=os.getenv("OPENROUTER_API_KEY"),
+    )
+)
+deepseek_model = OpenAIChatCompletionsModel(
+    model="deepseek/deepseek-chat",  # DeepSeek via OpenRouter
+    openai_client=AsyncOpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=os.getenv("OPENROUTER_API_KEY"),
+    )
+)
+
+sumary_model = OpenAIResponsesModel(
+    model="moonshotai/kimi-k2-instruct-0905",  # Valid Groq model
+    openai_client=AsyncOpenAI(
+        base_url="https://api.groq.com/openai/v1",
+        api_key=os.getenv("GROQ_API_KEY")
+    )
+)
+def build_sugguestion_information_agent()-> Agent[AgentContext]:
+    
+
+    current_time = datetime.now()
+    current_date = date.today()
+    current_day = datetime.today().strftime("%A")
+    information_agent = Agent[AgentContext](
+        name="company_suggestion_information",
+        instructions=(
+    "You are an information agent and customer service representative for the company. "
+    "Your goal is to provide clear, concise answers using ONLY the suggestion_ragtool tool. "
+    "For greeting do not call tool reply by your self add company name "
+    "Always speak as the company using 'we'. Do NOT guess or assume. "
+    "If information is not found, reply politely: "
+    "phraphse according to your intellgence 'No information is available regarding to this . You may book an appointment or speak to our sales agent for more details.' praphrase it "
+    
+    "Make only ONE suggestion_ragtool query that fully represents the user’s request. "
+    "All company-related answers must come strictly from the suggestion_ragtool tool. "
+    "Do not create or assume any details. Always use the correct company name. "
+    "The suggestion_ragtool result is your official answer. "
+    
+    "Respond in under not more than 80 words, in a friendly customer-service tone. "
+    "Never leave incomplete replies and never ignore earlier conversation context. "
+    
+    "As a customer support agent, always answer using official company information found through the suggestion_ragtool tool. for partcular question liek greeting and user info if you have so do not use tool reply by self "
+    f"Current system time : {current_time}, date: {current_date}, day: {current_day}. "
+),
+        model=deepseek_model,
+        tools=[
+            suggestion_ragtool
+        ],
+        model_settings=ModelSettings(
+            temperature=1,
+            top_p=1,
+            max_tokens=2048,
+        ),
+        )
+    return information_agent
+
+def build_summarizer_agent() -> Agent[AgentContext]:
+    """
+    Creates a summarizer agent that condenses chat history
+    into a short, factual summary for context preservation.
+    """
+    summarizer_agent = Agent[AgentContext](
+        name="Summarizer Agent",
+        instructions="""
+        You are a summarization assistant.
+        Your job is to take several user and assistant messages and produce a concise,
+        factual summary that captures key intents, facts, and outcomes.
+
+        Guidelines:
+        - Keep the summary under 80 words.
+        - Focus on what the user is asking for and the assistant's key responses.
+        - Do NOT add new information.
+        - Preserve important context like customer concerns, preferences, or goals.
+        - Write in plain English.
+        """,
+        model=sumary_model,  # or use default_model if configured in your environment
+        model_settings=ModelSettings(
+            temperature=0.3,
+            top_p=0.9,
+            max_tokens=300,
+        ),
+    )
+
+    return summarizer_agent
+def build_kimi_information_agent()-> Agent[AgentContext]:
+    
+
+    current_time = datetime.now()
+    current_date = date.today()
+    current_day = datetime.today().strftime("%A")
+    information_agent = Agent[AgentContext](
+        name="company_suggestion_information",
+        instructions=(
+    "You are an information agent and customer service representative for the company. "
+    "Your goal is to provide clear, concise answers using ONLY the suggestion_ragtool tool. "
+    "For greeting do not call tool reply by your self add company name "
+    "Always speak as the company using 'we'. Do NOT guess or assume. "
+    "If information is not found, reply politely: "
+    "phraphse according to your intellgence 'No information is available regarding to this . You may book an appointment or speak to our sales agent for more details.' praphrase it "
+    
+    "Make only ONE suggestion_ragtool query that fully represents the user’s request. "
+    "All company-related answers must come strictly from the suggestion_ragtool tool. "
+    "Do not create or assume any details. Always use the correct company name. "
+    "The suggestion_ragtool result is your official answer. "
+    
+    "Respond in under not more than 80 words, in a friendly customer-service tone. "
+    "Never leave incomplete replies and never ignore earlier conversation context. "
+    
+    "As a customer support agent, always answer using official company information found through the suggestion_ragtool tool. for partcular question liek greeting and user info if you have so do not use tool reply by self "
+    f"Current system time : {current_time}, date: {current_date}, day: {current_day}. "
+),
+        model=kimi_model,
+        tools=[
+            suggestion_ragtool
+        ],
+        model_settings=ModelSettings(
+            temperature=1,
+            top_p=1,
+            max_tokens=2048,
+        ),
+        )
+    return information_agent
+
+
+def build_google_information_agent()-> Agent[AgentContext]:
+    
+
+    current_time = datetime.now()
+    current_date = date.today()
+    current_day = datetime.today().strftime("%A")
+    information_agent = Agent[AgentContext](
+        name="company_suggestion_information",
+        instructions=(
+    "You are an information agent and customer service representative for the company. "
+    "Your goal is to provide clear, concise answers using ONLY the suggestion_ragtool tool. "
+    "For greeting do not call tool reply by your self add company name "
+    "Always speak as the company using 'we'. Do NOT guess or assume. "
+    "If information is not found, reply politely: "
+    "phraphse according to your intellgence 'No information is available regarding to this . You may book an appointment or speak to our sales agent for more details.' praphrase it "
+    
+    "Make only ONE suggestion_ragtool query that fully represents the user’s request. "
+    "All company-related answers must come strictly from the suggestion_ragtool tool. "
+    "Do not create or assume any details. Always use the correct company name. "
+    "The suggestion_ragtool result is your official answer. "
+    
+    "Respond in under not more than 80 words, in a friendly customer-service tone. "
+    "Never leave incomplete replies and never ignore earlier conversation context. "
+    
+    "As a customer support agent, always answer using official company information found through the suggestion_ragtool tool. for partcular question liek greeting and user info if you have so do not use tool reply by self "
+    f"Current system time : {current_time}, date: {current_date}, day: {current_day}. "
+),
+        model=google_model,
+        tools=[
+            suggestion_ragtool
+        ],
+        model_settings=ModelSettings(
+            temperature=1,
+            top_p=1,
+            max_tokens=2048,
+        ),
+        )
+    return information_agent

app/VectorDBManagers.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, ServiceContext, Settings
+from llama_index.vector_stores.chroma import ChromaVectorStore
+from llama_index.core.storage.storage_context import StorageContext
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.llms.groq import Groq
+import chromadb
+import os
+from dotenv import load_dotenv
+load_dotenv(dotenv_path="./.env.local")
+
+# --- Configure global settings for Groq and embeddings ---
+Settings.llm = Groq(
+    model="meta-llama/llama-4-scout-17b-16e-instruct",
+    api_key=os.getenv("GROQ_API_KEY"),
+    system_prompt="provide information according to context Do NOT guess or make assumptions please do not tell other that overlapping context. Respond briefly in one paragraph.",
+)
+Settings.embed_model = HuggingFaceEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+
+class VectorDBManager:
+    def __init__(self, db_path: str = "./chromafast_db", collection_name: str = "DB_collection"):
+        self.db_path = db_path
+        self.collection_name = collection_name
+
+        # Persistent Chroma client (never ephemeral)
+        self.db_client = chromadb.PersistentClient(path=db_path)
+        self.collection = self.db_client.get_or_create_collection(collection_name)
+
+        # Build vector + storage contexts
+        self.vector_store = ChromaVectorStore(chroma_collection=self.collection)
+        self.storage_context = StorageContext.from_defaults(vector_store=self.vector_store)
+        self.index = None
+
+    def is_collection_empty(self) -> bool:
+        """Check if the Chroma collection has any stored embeddings."""
+        try:
+            return len(self.collection.get()["ids"]) == 0
+        except Exception:
+            return True
+
+    def build_index_from_documents(self, data_path: str):
+        """Build and save a new index from document directory."""
+        print(f"📂 Loading documents from: {data_path}")
+        documents = SimpleDirectoryReader(data_path).load_data()
+        print(f"📄 Loaded {len(documents)} documents.")
+
+        self.index = VectorStoreIndex.from_documents(
+            documents,
+            storage_context=self.storage_context,
+        )
+        print(f"✅ Index built and stored in Chroma at {self.db_path}")
+
+    def load_existing_index(self):
+        """Load index from existing Chroma vector store."""
+        print(f"📦 Loading existing Chroma DB from {self.db_path}")
+        self.index = VectorStoreIndex.from_vector_store(self.vector_store)
+        print("✅ Loaded existing index successfully")
+
+    def get_query_engine(self):
+        if not self.index:  
+            raise ValueError("❌ Index not initialized. Build or load it first.")
+        return self.index.as_query_engine(use_async=True)
+
+    def query(self, text: str):
+        """Run a query against the existing or newly built index."""
+        query_engine = self.get_query_engine()
+        response = query_engine.query(text)
+        return response
+    async def aquery(self, text: str):
+        """Run a query against the existing or newly built index."""
+        import time
+        start_t = time.time()
+        query_engine = self.get_query_engine()
+        response = await query_engine.aquery(text)
+        print(f"🔍 Async query completed in {time.time() - start_t:.2f}s")
+        return response
+
+
+if __name__ == "__main__":
+    DATA_DIR = "../companyData1"
+    DB_PATH = "../chromafast_db"
+
+    manager = VectorDBManager(db_path=DB_PATH, collection_name="DB_collection")
+
+    # Detect if DB exists and has embeddings
+    if not os.path.exists(DB_PATH) or manager.is_collection_empty():
+        print("🆕 No existing embeddings found. Building new Chroma DB...")
+        manager.build_index_from_documents(DATA_DIR)
+    else:
+        print("📂 Existing Chroma DB found. Loading it...")
+        manager.load_existing_index()
+
+    # Test query
+    question = "What are some of the main contributions of this new bitswits?"
+    response = manager.query(question)
+    print("\n🔍 Query Result:\n")
+    print(response)

app/chatkit_threads.db-wal

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a572712d1a8c1c300bbaf0b5f58720eac241013c1afa5c8435d7bbedf3b14b0d
+size 449112

app/chromafast_db/6d7f2a08-25fb-473d-a268-7ec2315530e1/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfc20179bd13ac7810d64fe2b63cd66a87248cb9e41f3ad4ac48e39619041a77
+size 167600

app/chromafast_db/6d7f2a08-25fb-473d-a268-7ec2315530e1/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0e81c3b22454233bc12d0762f06dcca48261a75231cf87c79b75e69a6c00150
+size 100

app/chromafast_db/6d7f2a08-25fb-473d-a268-7ec2315530e1/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41f6bb80280dc803baa57e0ba719186b7c0ee549e8f47c571d5e779d79b89017
+size 400

app/chromafast_db/6d7f2a08-25fb-473d-a268-7ec2315530e1/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+size 0

app/chromafast_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:069858c77f19d2ecccc3b4b4acabbe14f56b2bdfa0d6aea20b5c92029795879c
+size 520192

app/function_tool.py

@@ -0,0 +1,79 @@
+from datetime import datetime, date, timedelta
+from typing import Optional as _Optional
+import json
+import httpx
+from urllib.parse import urljoin
+from llama_index.llms.groq import Groq
+import asyncio
+import random
+import os
+from dotenv import load_dotenv
+load_dotenv(dotenv_path="./.env.local")
+from agents import function_tool , RunContextWrapper
+from .VectorDBManagers import VectorDBManager
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CHROMA_DB_PATH = os.path.join(BASE_DIR, "chromafast_db")
+WEBSITE_PATH = os.path.join(BASE_DIR, "website")
+
+manager = VectorDBManager(db_path=CHROMA_DB_PATH, collection_name="DB_collection")
+if not os.path.exists(CHROMA_DB_PATH) or manager.is_collection_empty():
+    print("🆕 No existing embeddings found. Building new Chroma DB...")
+    manager.build_index_from_documents(WEBSITE_PATH)
+else:
+    print("📂 Existing Chroma DB found. Loading it...")
+    manager.load_existing_index()
+
+
+@function_tool(
+        name_override="suggestion_ragtool",
+            description_override="""
+        Name:    suggestion_ragtool
+        Query the company's knowledge base for information.
+
+        Description:
+        all Question except any meeting , call , invitation like schedule 
+        Searches the company's internal knowledge base to provide informative, paragraph-style answers 
+        related to services, policies, technologies, or any general information embedded in the vector store.
+
+    Parameters:
+        context (RunContextWrapper): The openai session context used for communicating with the user.
+        query (str): The question or query asked by the user about the company.
+
+    Returns:
+        str: 
+        """,
+        )
+async def suggestion_ragtool(ctx: RunContextWrapper, query: str) :
+    """
+    🔍 Tool Name: suggestion_ragtool
+
+    Description:
+        all Question except any meeting , call , invitation like schedule 
+        Searches the company's internal knowledge base to provide informative, paragraph-style answers 
+        related to services, policies, technologies, or any general information embedded in the vector store.
+
+    Parameters:
+        context (RunContext): The Openai session context used for communicating with the user.
+        query (str): The question or query asked by the user about the company.
+
+    Returns:
+        str:
+    """
+    
+    try:   
+        print(f"Answering from knowledgebase: {query}")
+        
+        
+        
+
+        res = await manager.aquery(query)
+        
+        
+        print("Query result:", res)
+        result=str(res)
+        return result 
+    except Exception as e:
+        print(f"Error: {e}")
+        return f"❌ Failed: Unable to answer the question. {str(e)}"
+

app/main.py

@@ -0,0 +1,1026 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator,List 
+from pydantic import BaseModel
+from agents import RunConfig, Runner, SQLiteSession
+from agents.model_settings import ModelSettings
+from chatkit.agents import AgentContext, stream_agent_response
+from chatkit.server import ChatKitServer, StreamingResult
+
+from chatkit.types import (
+    Attachment,
+    ClientToolCallItem,
+    ThreadMetadata,
+    ThreadStreamEvent,
+    UserMessageItem,
+    AssistantMessageItem
+)
+from .MultiAgent import  build_sugguestion_information_agent, build_kimi_information_agent, build_summarizer_agent,build_google_information_agent
+from chatkit.types import AssistantMessageItem as AssistantMsg
+from fastapi import Depends, FastAPI, Query, Request, HTTPException, BackgroundTasks,  Header, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response, StreamingResponse
+from openai.types.responses import ResponseInputContentParam
+from starlette.responses import JSONResponse
+import json
+import asyncio
+from collections import defaultdict
+import random
+import string
+import traceback
+from datetime import datetime, timezone, timedelta
+from .sqlite_store import SQLiteStore
+from .memory_store import MemoryStore
+from .user_state import UserStateManager
+from dotenv import load_dotenv
+load_dotenv(dotenv_path="./.env.local")
+DEFAULT_THREAD_ID = "demo_default_thread"
+def _user_message_text(item: UserMessageItem) -> str:
+    parts: list[str] = []
+    for part in item.content:
+        text = getattr(part, "text", None)
+        if text:
+            parts.append(text)
+    return " ".join(parts).strip()
+
+def _is_tool_completion_item(item: Any) -> bool:
+    return isinstance(item, ClientToolCallItem)
+
+class deepseek_CustomerSupportServer(ChatKitServer[dict[str, Any]]):
+    def __init__(
+        self,
+        agent_state: UserStateManager,
+    ) -> None:
+        store = SQLiteStore(db_path=os.getenv("CHATKIT_DB_PATH", "chatkit_threads.db"))
+        super().__init__(store)
+        self.store = store
+        self.agent_state = agent_state
+
+        self.information_agent = build_sugguestion_information_agent()
+        self.summarizer_agent = build_summarizer_agent()
+    def _resolve_thread_id(self, thread: ThreadMetadata | None) -> str:
+        return thread.id if thread and thread.id else DEFAULT_THREAD_ID
+     
+    async def prepare_conversation_context(self, thread_key: str, message_text: str, status:str) -> str:
+        # Await handle_history which is now fast because summarization is backgrounded
+        summary_text, recent_context = await self.handle_history(thread_key)
+        user_data = self.agent_state.get_user(thread_key)
+
+        customer_context = (
+            "Customer context:\n"
+            f"- Name: {user_data.customer_name or ''}\n"
+            f"- Email: {user_data.customer_email or ''}\n"
+            f"- Phone: {user_data.customer_phone or ''}\n"
+           
+            f"- Timezone: {user_data.Timezone or ''}\n"
+        )
+        if status.lower() == "offline":
+            combined_prompt = (
+                f"{customer_context}\n"
+                f"Previous summary:\n{summary_text}\n\n"
+                f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+                f"If the user asks to talk to a human sales agent, respond: "
+                f"-This Company you are representing for : Sunmarke School\n"
+                f"Current request: {message_text}\n"
+            )
+            return combined_prompt
+            
+        combined_prompt = (
+            f"{customer_context}\n"
+            f"Previous summary:\n{summary_text}\n\n"
+            f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+            f"-This Company you are representing for : Sunmarke School\n"
+            f"Current request: {message_text}\n"
+        )
+        return combined_prompt
+
+        # Await handle_history which is now fast because summarization is backgrounded
+        summary_text, recent_context = await self.handle_history(thread_key)
+        user_data = self.agent_state.get_user(thread_key)
+
+        customer_context = (
+            "Customer context:\n"
+            f"- Name: {user_data.customer_name or ''}\n"
+            f"- Email: {user_data.customer_email or ''}\n"
+            f"- Phone: {user_data.customer_phone or ''}\n"
+            f"- Company: {user_data.company_name or ''}\n"
+            f"- Timezone: {user_data.Timezone or ''}\n"
+        )
+        if status.lower() == "offline":
+            combined_prompt = (
+                f"{customer_context}\n"
+                f"Previous summary:\n{summary_text}\n\n"
+                f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+                f"If the user asks to talk to a human sales agent, respond: "
+                f'\"Our human sales agent is currently offline, May i help in book an appointment for you.\" '
+                f"Current request: {message_text}\n"
+            )
+            return combined_prompt
+            
+        combined_prompt = (
+            f"{customer_context}\n"
+            f"Previous summary:\n{summary_text}\n\n"
+            f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+            f"Current request: {message_text}\n"
+        )
+        return combined_prompt
+
+    async def _async_summarize(self, thread_key: str, user_messages: list, previous_summary: str):
+        """Background task to perform summarization without blocking the main flow."""
+        try:
+            to_summarize = user_messages[:-5]
+            combined_text = "\n".join(
+                f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+                for i in to_summarize
+            )
+            summarizer_prompt = (
+                f"Previous summary:\n{previous_summary}\n\n"
+                f"Add the following messages into the summary:\n{combined_text}\n"
+                f"Return a concise updated summary of the entire conversation."
+            )
+            session = SQLiteSession(thread_key)
+            result = await Runner.run(
+                self.summarizer_agent,
+                summarizer_prompt,
+                session=session,
+            )
+
+            self.agent_state.set_summary(thread_key, result.final_output)
+            print(f"🧠 [BACKGROUND] Summary updated for thread: {thread_key}")
+        except Exception as e:
+            print(f"⚠️ [BACKGROUND] Summarization failed for thread {thread_key}: {e}")
+
+    async def handle_history(self, thread_key: str) -> tuple[str, str]:
+        """Handles message history, returns current state, and triggers summarization in background if needed."""
+        # 1. Fetch history from store (Fast)
+        history = self.store._items(thread_key)
+        user_messages = [i for i in history if isinstance(i, (UserMessageItem, AssistantMessageItem))]
+
+        # Keep context within limits
+        if len(user_messages) > 15:
+            user_messages = user_messages[-15:]
+
+        # 2. Get existing summary from persistence (Fast)
+        summary_text = self.agent_state.get_summary(thread_key)
+
+        # 3. Trigger summarization in background if criteria met (Non-blocking)
+        if len(user_messages) >= 5 and len(user_messages) % 5 == 0:
+            print(f"🧠 [HISTORY] Triggering background summarization for {thread_key}")
+            asyncio.create_task(self._async_summarize(thread_key, user_messages, summary_text))
+
+        # 4. Compute recent context for the prompt (Fast)
+        last_five = user_messages[-10:]
+        recent_context = "\n".join(
+            f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+            for i in last_five
+        )
+
+        return summary_text, recent_context
+
+    async def respond(
+        self,
+        thread: ThreadMetadata,
+        item: UserMessageItem | None,
+        context: dict[str, Any],
+    ) -> AsyncIterator[ThreadStreamEvent]:
+        if item is None:
+            return
+
+        message_text = _user_message_text(item)
+        if not message_text:
+            return
+        
+        thread_key = self._resolve_thread_id(thread)
+        
+        try:
+            user_data = self.agent_state.get_user(thread_key)
+            request_context_enriched = {
+                **(context or {}),
+                
+            }
+        except Exception:
+            request_context_enriched = context or {}
+
+        session = SQLiteSession(thread_key)
+        agent_context = AgentContext(thread=thread, store=self.store, request_context=request_context_enriched)
+
+        combined_prompt = await self.prepare_conversation_context(thread_key, message_text, 'offline')
+        
+        result_stream = Runner.run_streamed(self.information_agent, combined_prompt, context=agent_context, session=session)
+        async for event in stream_agent_response(agent_context, result_stream):
+            yield event
+
+
+class kimi_CustomerSupportServer(ChatKitServer[dict[str, Any]]):
+    def __init__(
+        self,
+        agent_state: UserStateManager,
+    ) -> None:
+        store = SQLiteStore(db_path="chatkit_threads.db")
+        super().__init__(store)
+        self.store = store
+        self.agent_state = agent_state
+        self.summarizer_agent = build_summarizer_agent()
+        self.information_agent = build_kimi_information_agent()
+    
+    def _resolve_thread_id(self, thread: ThreadMetadata | None) -> str:
+        return thread.id if thread and thread.id else DEFAULT_THREAD_ID
+     
+    async def prepare_conversation_context(self, thread_key: str, message_text: str, status:str) -> str:
+        # Await handle_history which is now fast because summarization is backgrounded
+        summary_text, recent_context = await self.handle_history(thread_key)
+        user_data = self.agent_state.get_user(thread_key)
+
+        customer_context = (
+            "Customer context:\n"
+            f"- Name: {user_data.customer_name or ''}\n"
+            f"- Email: {user_data.customer_email or ''}\n"
+            f"- Phone: {user_data.customer_phone or ''}\n"
+           
+            f"- Timezone: {user_data.Timezone or ''}\n"
+        )
+        if status.lower() == "offline":
+            combined_prompt = (
+                f"{customer_context}\n"
+                f"Previous summary:\n{summary_text}\n\n"
+                f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+                f"If the user asks to talk to a human sales agent, respond: "
+                f"-This Company you are representing for : Sunmarke School\n"
+                f"Current request: {message_text}\n"
+            )
+            return combined_prompt
+            
+        combined_prompt = (
+            f"{customer_context}\n"
+            f"Previous summary:\n{summary_text}\n\n"
+            f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+            f"-This Company you are representing for : Sunmarke School\n"
+            f"Current request: {message_text}\n"
+        )
+        return combined_prompt
+
+        # Await handle_history which is now fast because summarization is backgrounded
+        summary_text, recent_context = await self.handle_history(thread_key)
+        user_data = self.agent_state.get_user(thread_key)
+
+        customer_context = (
+            "Customer context:\n"
+            f"- Name: {user_data.customer_name or ''}\n"
+            f"- Email: {user_data.customer_email or ''}\n"
+            f"- Phone: {user_data.customer_phone or ''}\n"
+            f"- Company: {user_data.company_name or ''}\n"
+            f"- Timezone: {user_data.Timezone or ''}\n"
+        )
+        if status.lower() == "offline":
+            combined_prompt = (
+                f"{customer_context}\n"
+                f"Previous summary:\n{summary_text}\n\n"
+                f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+                f"If the user asks to talk to a human sales agent, respond: "
+                f'\"Our human sales agent is currently offline, May i help in book an appointment for you.\" '
+                f"Current request: {message_text}\n"
+            )
+            return combined_prompt
+            
+        combined_prompt = (
+            f"{customer_context}\n"
+            f"Previous summary:\n{summary_text}\n\n"
+            f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+            f"Current request: {message_text}\n"
+        )
+        return combined_prompt
+
+    async def _async_summarize(self, thread_key: str, user_messages: list, previous_summary: str):
+        """Background task to perform summarization without blocking the main flow."""
+        try:
+            to_summarize = user_messages[:-5]
+            combined_text = "\n".join(
+                f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+                for i in to_summarize
+            )
+            summarizer_prompt = (
+                f"Previous summary:\n{previous_summary}\n\n"
+                f"Add the following messages into the summary:\n{combined_text}\n"
+                f"Return a concise updated summary of the entire conversation."
+            )
+            session = SQLiteSession(thread_key)
+            result = await Runner.run(
+                self.summarizer_agent,
+                summarizer_prompt,
+                session=session,
+            )
+
+            self.agent_state.set_summary(thread_key, result.final_output)
+            print(f"🧠 [BACKGROUND] Summary updated for thread: {thread_key}")
+        except Exception as e:
+            print(f"⚠️ [BACKGROUND] Summarization failed for thread {thread_key}: {e}")
+
+    async def handle_history(self, thread_key: str) -> tuple[str, str]:
+        """Handles message history, returns current state, and triggers summarization in background if needed."""
+        # 1. Fetch history from store (Fast)
+        history = self.store._items(thread_key)
+        user_messages = [i for i in history if isinstance(i, (UserMessageItem, AssistantMessageItem))]
+
+        # Keep context within limits
+        if len(user_messages) > 15:
+            user_messages = user_messages[-15:]
+
+        # 2. Get existing summary from persistence (Fast)
+        summary_text = self.agent_state.get_summary(thread_key)
+
+        # 3. Trigger summarization in background if criteria met (Non-blocking)
+        if len(user_messages) >= 5 and len(user_messages) % 5 == 0:
+            print(f"🧠 [HISTORY] Triggering background summarization for {thread_key}")
+            asyncio.create_task(self._async_summarize(thread_key, user_messages, summary_text))
+
+        # 4. Compute recent context for the prompt (Fast)
+        last_five = user_messages[-10:]
+        recent_context = "\n".join(
+            f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+            for i in last_five
+        )
+
+        return summary_text, recent_context
+
+    async def respond(
+        self,
+        thread: ThreadMetadata,
+        item: UserMessageItem | None,
+        context: dict[str, Any],
+    ) -> AsyncIterator[ThreadStreamEvent]:
+        if item is None:
+            return
+
+        message_text = _user_message_text(item)
+        if not message_text:
+            return
+        
+        thread_key = self._resolve_thread_id(thread)
+        
+        try:
+            user_data = self.agent_state.get_user(thread_key)
+            request_context_enriched = {
+                **(context or {}),
+                
+            }
+        except Exception:
+            request_context_enriched = context or {}
+
+        session = SQLiteSession(thread_key)
+        agent_context = AgentContext(thread=thread, store=self.store, request_context=request_context_enriched)
+
+        combined_prompt = await self.prepare_conversation_context(thread_key, message_text, 'offline')
+        
+        result_stream = Runner.run_streamed(self.information_agent, combined_prompt, context=agent_context, session=session)
+        async for event in stream_agent_response(agent_context, result_stream):
+            yield event
+
+class google_CustomerSupportServer(ChatKitServer[dict[str, Any]]):
+    def __init__(
+        self,
+        agent_state: UserStateManager,
+    ) -> None:
+        store = SQLiteStore(db_path="chatkit_threads.db")
+        super().__init__(store)
+        self.store = store
+        self.agent_state = agent_state
+
+        self.information_agent = build_google_information_agent()
+        self.summarizer_agent = build_summarizer_agent()
+    def _resolve_thread_id(self, thread: ThreadMetadata | None) -> str:
+        return thread.id if thread and thread.id else DEFAULT_THREAD_ID
+     
+    async def prepare_conversation_context(self, thread_key: str, message_text: str, status:str) -> str:
+        # Await handle_history which is now fast because summarization is backgrounded
+        summary_text, recent_context = await self.handle_history(thread_key)
+        user_data = self.agent_state.get_user(thread_key)
+
+        customer_context = (
+            "Customer context:\n"
+            f"- Name: {user_data.customer_name or ''}\n"
+            f"- Email: {user_data.customer_email or ''}\n"
+            f"- Phone: {user_data.customer_phone or ''}\n"
+           
+            f"- Timezone: {user_data.Timezone or ''}\n"
+        )
+        if status.lower() == "offline":
+            combined_prompt = (
+                f"{customer_context}\n"
+                f"Previous summary:\n{summary_text}\n\n"
+                f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+                f"If the user asks to talk to a human sales agent, respond: "
+                f"-This Company you are representing for : Sunmarke School\n"
+                f"Current request: {message_text}\n"
+            )
+            return combined_prompt
+            
+        combined_prompt = (
+            f"{customer_context}\n"
+            f"Previous summary:\n{summary_text}\n\n"
+            f"Recent conversation (last 5 messages):\n{recent_context}\n\n"
+            f"-This Company you are representing for : Sunmarke School\n"
+            f"Current request: {message_text}\n"
+        )
+        return combined_prompt
+
+    async def _async_summarize(self, thread_key: str, user_messages: list, previous_summary: str):
+        """Background task to perform summarization without blocking the main flow."""
+        try:
+            to_summarize = user_messages[:-5]
+            combined_text = "\n".join(
+                f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+                for i in to_summarize
+            )
+            summarizer_prompt = (
+                f"Previous summary:\n{previous_summary}\n\n"
+                f"Add the following messages into the summary:\n{combined_text}\n"
+                f"Return a concise updated summary of the entire conversation."
+            )
+            session = SQLiteSession(thread_key)
+            result = await Runner.run(
+                self.summarizer_agent,
+                summarizer_prompt,
+                session=session,
+            )
+
+            self.agent_state.set_summary(thread_key, result.final_output)
+            print(f"🧠 [BACKGROUND] Summary updated for thread: {thread_key}")
+        except Exception as e:
+            print(f"⚠️ [BACKGROUND] Summarization failed for thread {thread_key}: {e}")
+
+    async def handle_history(self, thread_key: str) -> tuple[str, str]:
+        """Handles message history, returns current state, and triggers summarization in background if needed."""
+        # 1. Fetch history from store (Fast)
+        history = self.store._items(thread_key)
+        user_messages = [i for i in history if isinstance(i, (UserMessageItem, AssistantMessageItem))]
+
+        # Keep context within limits
+        if len(user_messages) > 15:
+            user_messages = user_messages[-15:]
+
+        # 2. Get existing summary from persistence (Fast)
+        summary_text = self.agent_state.get_summary(thread_key)
+
+        # 3. Trigger summarization in background if criteria met (Non-blocking)
+        if len(user_messages) >= 5 and len(user_messages) % 5 == 0:
+            print(f"🧠 [HISTORY] Triggering background summarization for {thread_key}")
+            asyncio.create_task(self._async_summarize(thread_key, user_messages, summary_text))
+
+        # 4. Compute recent context for the prompt (Fast)
+        last_five = user_messages[-10:]
+        recent_context = "\n".join(
+            f"{'User' if isinstance(i, UserMessageItem) else 'Assistant'}: {_user_message_text(i)}" 
+            for i in last_five
+        )
+
+        return summary_text, recent_context
+
+    async def respond(
+        self,
+        thread: ThreadMetadata,
+        item: UserMessageItem | None,
+        context: dict[str, Any],
+    ) -> AsyncIterator[ThreadStreamEvent]:
+        if item is None:
+            return
+
+        message_text = _user_message_text(item)
+        if not message_text:
+            return
+        
+        thread_key = self._resolve_thread_id(thread)
+        
+        try:
+            user_data = self.agent_state.get_user(thread_key)
+            request_context_enriched = {
+                **(context or {}),
+                
+            }
+        except Exception:
+            request_context_enriched = context or {}
+
+        session = SQLiteSession(thread_key)
+        agent_context = AgentContext(thread=thread, store=self.store, request_context=request_context_enriched)
+
+        combined_prompt = await self.prepare_conversation_context(thread_key, message_text, 'offline')
+        
+        result_stream = Runner.run_streamed(self.information_agent, combined_prompt, context=agent_context, session=session)
+        async for event in stream_agent_response(agent_context, result_stream):
+            yield event
+
+
+state_manager = UserStateManager(db_path=os.getenv("USER_STATE_DB_PATH", "user_state.db"))
+support_server = deepseek_CustomerSupportServer(agent_state=state_manager)
+kimi_support_server = kimi_CustomerSupportServer(agent_state=state_manager)
+google_support_server = google_CustomerSupportServer(agent_state=state_manager)
+
+app = FastAPI(title="ChatKit Customer Support API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def get_server() -> deepseek_CustomerSupportServer:
+    return support_server
+
+def get_kimi_server() -> kimi_CustomerSupportServer:
+    return kimi_support_server
+
+def get_google_server() -> google_CustomerSupportServer:
+    return google_support_server
+
+@app.post("/deepseek/support/chatkit")
+async def chatkit_endpoint(
+    request: Request, server: deepseek_CustomerSupportServer = Depends(get_server)
+) -> Response:
+    payload = await request.body()
+    result = await server.process(payload, {"request": request})
+    if isinstance(result, StreamingResult):
+        return StreamingResponse(result, media_type="text/event-stream")
+    if hasattr(result, "json"):
+        return Response(content=result.json, media_type="application/json")
+    return JSONResponse(result)
+
+@app.post("/kimi/support/chatkit")
+async def chatkit_endpoint(
+    request: Request, server: kimi_CustomerSupportServer = Depends(get_kimi_server)
+) -> Response:
+    payload = await request.body()
+    result = await server.process(payload, {"request": request})
+    if isinstance(result, StreamingResult):
+        return StreamingResponse(result, media_type="text/event-stream")
+    if hasattr(result, "json"):
+        return Response(content=result.json, media_type="application/json")
+    return JSONResponse(result)
+@app.post("/google/support/chatkit")
+async def chatkit_endpoint(
+    request: Request, server: google_CustomerSupportServer = Depends(get_google_server)
+) -> Response:
+    payload = await request.body()
+    result = await server.process(payload, {"request": request})
+    if isinstance(result, StreamingResult):
+        return StreamingResponse(result, media_type="text/event-stream")
+    if hasattr(result, "json"):
+        return Response(content=result.json, media_type="application/json")
+    return JSONResponse(result)
+
+@app.post("/api/chat/debug")
+async def chat_debug(request: Request):
+    body = await request.body()
+    print("RAW BODY RECEIVED:", body)
+    return {"received": body.decode()}
+def _thread_param(thread_id: str | None) -> str:
+    return thread_id or DEFAULT_THREAD_ID
+
+@app.get("/deepseek/support/customer")
+async def deepseek_customer_snapshot(
+    thread_id: str | None = Query(None, description="ChatKit thread identifier"),
+    server: deepseek_CustomerSupportServer = Depends(get_server),
+) -> dict[str, Any]:
+    key = _thread_param(thread_id)
+    data = server.agent_state.to_dict(key)
+    print("data", data)
+    return {"customer": data}
+
+@app.get("/kimi/support/customer")
+async def kimi_customer_snapshot(
+    thread_id: str | None = Query(None, description="ChatKit thread identifier"),
+    server: kimi_CustomerSupportServer = Depends(get_kimi_server),
+) -> dict[str, Any]:
+    key = _thread_param(thread_id)
+    data = server.agent_state.to_dict(key)
+    print("data", data)
+    return {"customer": data}
+
+@app.get("/google/support/customer")
+async def google_customer_snapshot(
+    thread_id: str | None = Query(None, description="ChatKit thread identifier"),
+    server: google_CustomerSupportServer = Depends(get_google_server),
+) -> dict[str, Any]:
+    key = _thread_param(thread_id)
+    data = server.agent_state.to_dict(key)
+    print("data", data)
+    return {"customer": data}
+
+@app.get("/support/customer")
+async def customer_snapshot(
+    thread_id: str | None = Query(None, description="ChatKit thread identifier"),
+    server: google_CustomerSupportServer = Depends(get_google_server),
+) -> dict[str, Any]:
+    key = _thread_param(thread_id)
+    data = server.agent_state.to_dict(key)
+    print("data", data)
+    return {"customer": data}
+
+
+
+
+@app.post("/support/transcribe")
+async def transcribe_audio(file: UploadFile = File(...)):
+    """Transcribe audio using Groq Whisper model"""
+    import tempfile
+    import os
+    from groq import Groq
+    
+    try:
+        # Initialize Groq client with API key from environment
+        groq_api_key = os.getenv("GROQ_API_KEY")
+        if not groq_api_key:
+            raise HTTPException(status_code=500, detail="GROQ_API_KEY not found in environment")
+        
+        client = Groq(api_key=groq_api_key)
+        
+        # Read audio file
+        audio_data = await file.read()
+        
+        # Create temporary file with original extension or default to .webm
+        file_extension = os.path.splitext(file.filename)[1] if file.filename else ".webm"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            temp_file.write(audio_data)
+            temp_file_path = temp_file.name
+        
+        # Transcribe with Groq Whisper
+        with open(temp_file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                file=audio_file,
+                model="whisper-large-v3-turbo",
+                response_format="verbose_json",
+                timestamp_granularities=["word", "segment"],
+                language="en",
+                temperature=0.0
+            )
+        
+        # Cleanup temporary file
+        os.unlink(temp_file_path)
+        
+        # Return transcription text and full details
+        return {
+            "text": transcription.text,
+            "details": json.loads(json.dumps(transcription, default=str))
+        }
+    
+    except Exception as e:
+        # Cleanup temp file if it exists
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)
+        
+        print(f"❌ Transcription error: {str(e)}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
+@app.post("/deepseek/support/transcribe")
+async def deepseek_transcribe_audio(file: UploadFile = File(...)):
+    """Transcribe audio using Groq Whisper model"""
+    import tempfile
+    import os
+    from groq import Groq
+    
+    try:
+        # Initialize Groq client with API key from environment
+        groq_api_key = os.getenv("GROQ_API_KEY")
+        if not groq_api_key:
+            raise HTTPException(status_code=500, detail="GROQ_API_KEY not found in environment")
+        
+        client = Groq(api_key=groq_api_key)
+        
+        # Read audio file
+        audio_data = await file.read()
+        
+        # Create temporary file with original extension or default to .webm
+        file_extension = os.path.splitext(file.filename)[1] if file.filename else ".webm"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            temp_file.write(audio_data)
+            temp_file_path = temp_file.name
+        
+        # Transcribe with Groq Whisper
+        with open(temp_file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                file=audio_file,
+                model="whisper-large-v3-turbo",
+                response_format="verbose_json",
+                timestamp_granularities=["word", "segment"],
+                language="en",
+                temperature=0.0
+            )
+        
+        # Cleanup temporary file
+        os.unlink(temp_file_path)
+        
+        # Return transcription text and full details
+        return {
+            "text": transcription.text,
+            "details": json.loads(json.dumps(transcription, default=str))
+        }
+    
+    except Exception as e:
+        # Cleanup temp file if it exists
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)
+        
+        print(f"❌ Transcription error: {str(e)}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
+
+@app.post("/google/support/transcribe")
+async def google_transcribe_audio(file: UploadFile = File(...)):
+    """Transcribe audio using Groq Whisper model"""
+    import tempfile
+    import os
+    from groq import Groq
+    
+    try:
+        # Initialize Groq client with API key from environment
+        groq_api_key = os.getenv("GROQ_API_KEY")
+        if not groq_api_key:
+            raise HTTPException(status_code=500, detail="GROQ_API_KEY not found in environment")
+        
+        client = Groq(api_key=groq_api_key)
+        
+        # Read audio file
+        audio_data = await file.read()
+        
+        # Create temporary file with original extension or default to .webm
+        file_extension = os.path.splitext(file.filename)[1] if file.filename else ".webm"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            temp_file.write(audio_data)
+            temp_file_path = temp_file.name
+        
+        # Transcribe with Groq Whisper
+        with open(temp_file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                file=audio_file,
+                model="whisper-large-v3-turbo",
+                response_format="verbose_json",
+                timestamp_granularities=["word", "segment"],
+                language="en",
+                temperature=0.0
+            )
+        
+        # Cleanup temporary file
+        os.unlink(temp_file_path)
+        
+        # Return transcription text and full details
+        return {
+            "text": transcription.text,
+            "details": json.loads(json.dumps(transcription, default=str))
+        }
+    
+    except Exception as e:
+        # Cleanup temp file if it exists
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)
+        
+        print(f"❌ Transcription error: {str(e)}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
+
+@app.post("/kimi/support/transcribe")
+async def kimi_transcribe_audio(file: UploadFile = File(...)):
+    """Transcribe audio using Groq Whisper model"""
+    import tempfile
+    import os
+    from groq import Groq
+    
+    try:
+        # Initialize Groq client with API key from environment
+        groq_api_key = os.getenv("GROQ_API_KEY")
+        if not groq_api_key:
+            raise HTTPException(status_code=500, detail="GROQ_API_KEY not found in environment")
+        
+        client = Groq(api_key=groq_api_key)
+        
+        # Read audio file
+        audio_data = await file.read()
+        
+        # Create temporary file with original extension or default to .webm
+        file_extension = os.path.splitext(file.filename)[1] if file.filename else ".webm"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            temp_file.write(audio_data)
+            temp_file_path = temp_file.name
+        
+        # Transcribe with Groq Whisper
+        with open(temp_file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                file=audio_file,
+                model="whisper-large-v3-turbo",
+                response_format="verbose_json",
+                timestamp_granularities=["word", "segment"],
+                language="en",
+                temperature=0.0
+            )
+        
+        # Cleanup temporary file
+        os.unlink(temp_file_path)
+        
+        # Return transcription text and full details
+        return {
+            "text": transcription.text,
+            "details": json.loads(json.dumps(transcription, default=str))
+        }
+    
+    except Exception as e:
+        # Cleanup temp file if it exists
+        if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)
+        
+        print(f"❌ Transcription error: {str(e)}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
+
+
+@app.get("/deepseek/support/threads/{thread_id}/messages")
+async def deepseek_get_thread_messages(
+    thread_id: str,
+    server: deepseek_CustomerSupportServer = Depends(get_server)
+):
+    """Get last 10 messages for a specific thread."""
+    try:
+        # Get all items from the thread
+        items = server.store._items(thread_id)
+        
+        # Filter to only UserMessageItem and AssistantMessageItem
+        messages = []
+        for item in items:
+            if isinstance(item, (UserMessageItem, AssistantMessageItem)):
+                message_dict = item.model_dump()
+                
+                # Ensure created_at is a string
+                if hasattr(message_dict.get('created_at'), 'isoformat'):
+                    message_dict['created_at'] = message_dict['created_at'].isoformat()
+                elif message_dict.get('created_at'):
+                    message_dict['created_at'] = str(message_dict['created_at'])
+                
+                messages.append(message_dict)
+        
+        # Get last 10 messages
+        last_10_messages = messages[-10:] if len(messages) > 10 else messages
+        
+        return {
+            "thread_id": thread_id,
+            "total_message_count": len(messages),
+            "returned_message_count": len(last_10_messages),
+            "messages": last_10_messages
+        }
+    
+    except Exception as e:
+        print(f"❌ Error fetching messages for thread {thread_id}: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to fetch messages: {str(e)}")
+
+@app.get("/support/threads/{thread_id}/messages")
+async def get_thread_messages(
+    thread_id: str,
+    server: deepseek_CustomerSupportServer = Depends(get_server)
+):
+    """Get last 10 messages for a specific thread."""
+    try:
+        # Get all items from the thread
+        items = server.store._items(thread_id)
+        
+        # Filter to only UserMessageItem and AssistantMessageItem
+        messages = []
+        for item in items:
+            if isinstance(item, (UserMessageItem, AssistantMessageItem)):
+                message_dict = item.model_dump()
+                
+                # Ensure created_at is a string
+                if hasattr(message_dict.get('created_at'), 'isoformat'):
+                    message_dict['created_at'] = message_dict['created_at'].isoformat()
+                elif message_dict.get('created_at'):
+                    message_dict['created_at'] = str(message_dict['created_at'])
+                
+                messages.append(message_dict)
+        
+        # Get last 10 messages
+        last_10_messages = messages[-10:] if len(messages) > 10 else messages
+        
+        return {
+            "thread_id": thread_id,
+            "total_message_count": len(messages),
+            "returned_message_count": len(last_10_messages),
+            "messages": last_10_messages
+        }
+    
+    except Exception as e:
+        print(f"❌ Error fetching messages for thread {thread_id}: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to fetch messages: {str(e)}")
+
+@app.get("/kimi/support/threads/{thread_id}/messages")
+async def kimi_get_thread_messages(
+    thread_id: str,
+    server:kimi_CustomerSupportServer = Depends(get_kimi_server)
+):
+    """Get last 10 messages for a specific thread."""
+    try:
+        # Get all items from the thread
+        items = server.store._items(thread_id)
+        
+        # Filter to only UserMessageItem and AssistantMessageItem
+        messages = []
+        for item in items:
+            if isinstance(item, (UserMessageItem, AssistantMessageItem)):
+                message_dict = item.model_dump()
+                
+                # Ensure created_at is a string
+                if hasattr(message_dict.get('created_at'), 'isoformat'):
+                    message_dict['created_at'] = message_dict['created_at'].isoformat()
+                elif message_dict.get('created_at'):
+                    message_dict['created_at'] = str(message_dict['created_at'])
+                
+                messages.append(message_dict)
+        
+        # Get last 10 messages
+        last_10_messages = messages[-10:] if len(messages) > 10 else messages
+        
+        return {
+            "thread_id": thread_id,
+            "total_message_count": len(messages),
+            "returned_message_count": len(last_10_messages),
+            "messages": last_10_messages
+        }
+    
+    except Exception as e:
+        print(f"❌ Error fetching messages for thread {thread_id}: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to fetch messages: {str(e)}")
+
+@app.get("/google/support/threads/{thread_id}/messages")
+async def google_get_thread_messages(
+    thread_id: str,
+    server:google_CustomerSupportServer = Depends(get_google_server)
+):
+    """Get last 10 messages for a specific thread."""
+    try:
+        # Get all items from the thread
+        items = server.store._items(thread_id)
+        
+        # Filter to only UserMessageItem and AssistantMessageItem
+        messages = []
+        for item in items:
+            if isinstance(item, (UserMessageItem, AssistantMessageItem)):
+                message_dict = item.model_dump()
+                
+                # Ensure created_at is a string
+                if hasattr(message_dict.get('created_at'), 'isoformat'):
+                    message_dict['created_at'] = message_dict['created_at'].isoformat()
+                elif message_dict.get('created_at'):
+                    message_dict['created_at'] = str(message_dict['created_at'])
+                
+                messages.append(message_dict)
+        
+        # Get last 10 messages
+        last_10_messages = messages[-10:] if len(messages) > 10 else messages
+        
+        return {
+            "thread_id": thread_id,
+            "total_message_count": len(messages),
+            "returned_message_count": len(last_10_messages),
+            "messages": last_10_messages
+        }
+    
+    except Exception as e:
+        print(f"❌ Error fetching messages for thread {thread_id}: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to fetch messages: {str(e)}")
+
+@app.post("/support/customer")
+async def customer_update(
+    request: Request,
+    thread_id: str | None = Query(None, description="ChatKit thread identifier"),
+    server: deepseek_CustomerSupportServer = Depends(get_server),
+) -> dict[str, str]:
+    try:
+        payload = await request.json()
+    except Exception:
+        payload = {}
+    key = _thread_param(thread_id)
+    try:
+        print(f"payload: {payload}")
+        name = (payload.get("name") or "").strip()
+        email = (payload.get("email") or "").strip()
+        phone = (payload.get("phone") or "").strip()
+        company_name = (payload.get("company_name") or payload.get("company") or "").strip()
+        timezone = (payload.get("timeZone") or payload.get("timezone") or "").strip()
+        server.agent_state.set_customer_info(
+            key,
+            name=name or None,
+            email=email or None,
+            phone=phone or None,
+            company_name=company_name or None,
+        )
+        if timezone:
+            server.agent_state.set_timezone(key, timezone)
+        
+        # 🔥 Preload vector index for company to avoid 19s delay on first message
+        
+        return {"status": "ok"}
+    except Exception:
+        return {"status": "error"}
+
+@app.get("/support/health")
+async def health_check() -> dict[str, str]:
+    return {"status": "healthy"}

app/memory_store.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List
+
+from chatkit.store import NotFoundError, Store
+from chatkit.types import Attachment, Page, Thread, ThreadItem, ThreadMetadata
+
+
+@dataclass
+class _ThreadState:
+    thread: ThreadMetadata
+    items: List[ThreadItem]
+
+
+class MemoryStore(Store[dict[str, Any]]):
+    """Simple in-memory store compatible with the ChatKit server interface."""
+
+    def __init__(self) -> None:
+        self._threads: Dict[str, _ThreadState] = {}
+        # Attachments intentionally unsupported; use a real store that enforces auth.
+
+    @staticmethod
+    def _coerce_thread_metadata(thread: ThreadMetadata | Thread) -> ThreadMetadata:
+        """Return thread metadata without any embedded items (openai-chatkit>=1.0)."""
+        has_items = isinstance(thread, Thread) or "items" in getattr(
+            thread, "model_fields_set", set()
+        )
+        if not has_items:
+            return thread.model_copy(deep=True)
+
+        data = thread.model_dump()
+        data.pop("items", None)
+        return ThreadMetadata(**data).model_copy(deep=True)
+
+    # -- Thread metadata -------------------------------------------------
+    async def load_thread(self, thread_id: str, context: dict[str, Any]) -> ThreadMetadata:
+        state = self._threads.get(thread_id)
+        if not state:
+            raise NotFoundError(f"Thread {thread_id} not found")
+        return self._coerce_thread_metadata(state.thread)
+
+    async def save_thread(self, thread: ThreadMetadata, context: dict[str, Any]) -> None:
+        metadata = self._coerce_thread_metadata(thread)
+        state = self._threads.get(thread.id)
+        if state:
+            state.thread = metadata
+        else:
+            self._threads[thread.id] = _ThreadState(
+                thread=metadata,
+                items=[],
+            )
+
+    async def load_threads(
+        self,
+        limit: int,
+        after: str | None,
+        order: str,
+        context: dict[str, Any],
+    ) -> Page[ThreadMetadata]:
+        threads = sorted(
+            (self._coerce_thread_metadata(state.thread) for state in self._threads.values()),
+            key=lambda t: t.created_at or datetime.min,
+            reverse=(order == "desc"),
+        )
+
+        if after:
+            index_map = {thread.id: idx for idx, thread in enumerate(threads)}
+            start = index_map.get(after, -1) + 1
+        else:
+            start = 0
+
+        slice_threads = threads[start : start + limit + 1]
+        has_more = len(slice_threads) > limit
+        slice_threads = slice_threads[:limit]
+        next_after = slice_threads[-1].id if has_more and slice_threads else None
+        return Page(
+            data=slice_threads,
+            has_more=has_more,
+            after=next_after,
+        )
+
+    async def delete_thread(self, thread_id: str, context: dict[str, Any]) -> None:
+        self._threads.pop(thread_id, None)
+
+    # -- Thread items ----------------------------------------------------
+    def _items(self, thread_id: str) -> List[ThreadItem]:
+        state = self._threads.get(thread_id)
+        if state is None:
+            state = _ThreadState(
+                thread=ThreadMetadata(id=thread_id, created_at=datetime.utcnow()),
+                items=[],
+            )
+            self._threads[thread_id] = state
+        return state.items
+
+    async def load_thread_items(
+        self,
+        thread_id: str,
+        after: str | None,
+        limit: int,
+        order: str,
+        context: dict[str, Any],
+    ) -> Page[ThreadItem]:
+        items = [item.model_copy(deep=True) for item in self._items(thread_id)]
+        items.sort(
+            key=lambda item: getattr(item, "created_at", datetime.utcnow()),
+            reverse=(order == "desc"),
+        )
+
+        if after:
+            index_map = {item.id: idx for idx, item in enumerate(items)}
+            start = index_map.get(after, -1) + 1
+        else:
+            start = 0
+
+        slice_items = items[start : start + limit + 1]
+        has_more = len(slice_items) > limit
+        slice_items = slice_items[:limit]
+        next_after = slice_items[-1].id if has_more and slice_items else None
+        return Page(data=slice_items, has_more=has_more, after=next_after)
+
+    async def add_thread_item(
+        self, thread_id: str, item: ThreadItem, context: dict[str, Any]
+    ) -> None:
+        print("Adding item", item)
+        self._items(thread_id).append(item.model_copy(deep=True))
+
+    async def save_item(self, thread_id: str, item: ThreadItem, context: dict[str, Any]) -> None:
+        items = self._items(thread_id)
+        for idx, existing in enumerate(items):
+            if existing.id == item.id:
+                items[idx] = item.model_copy(deep=True)
+                return
+        items.append(item.model_copy(deep=True))
+
+    async def load_item(self, thread_id: str, item_id: str, context: dict[str, Any]) -> ThreadItem:
+        for item in self._items(thread_id):
+            if item.id == item_id:
+                return item.model_copy(deep=True)
+        raise NotFoundError(f"Item {item_id} not found")
+
+    async def delete_thread_item(
+        self, thread_id: str, item_id: str, context: dict[str, Any]
+    ) -> None:
+        items = self._items(thread_id)
+        self._threads[thread_id].items = [item for item in items if item.id != item_id]
+
+    # -- Files -----------------------------------------------------------
+    # These methods are not currently used but required to be compatible with the Store interface.
+
+    async def save_attachment(
+        self,
+        attachment: Attachment,
+        context: dict[str, Any],
+    ) -> None:
+        raise NotImplementedError(
+            "MemoryStore does not persist attachments. Provide a Store implementation "
+            "that enforces authentication and authorization before enabling uploads."
+        )
+
+    async def load_attachment(
+        self,
+        attachment_id: str,
+        context: dict[str, Any],
+    ) -> Attachment:
+        raise NotImplementedError(
+            "MemoryStore does not load attachments. Provide a Store implementation "
+            "that enforces authentication and authorization before enabling uploads."
+        )
+
+    async def delete_attachment(self, attachment_id: str, context: dict[str, Any]) -> None:
+        raise NotImplementedError(
+            "MemoryStore does not delete attachments because they are never stored."
+        )

app/scrapping.py

@@ -0,0 +1,32 @@
+from crewai_tools import ScrapeWebsiteTool
+import os
+
+# List of pages you want to scrape
+pages = [
+    "https://www.sunmarke.com/",
+]
+
+all_text = []
+
+for url in pages:
+    tool = ScrapeWebsiteTool(website_url=url)
+    content = tool.run()
+    all_text.append(content)
+
+# Remove duplicates
+all_text = list(set(all_text))
+
+# Combine into one string
+text = "\n\n".join(all_text)
+
+# Save to file
+output_folder = "website"
+os.makedirs(output_folder, exist_ok=True)
+file_path = os.path.join(output_folder, "output.txt")
+
+with open(file_path, "w", encoding="utf-8") as f:
+    f.write("=== Output Start ===\n\n")
+    f.write(text.strip())
+    f.write("\n\n=== Output End ===\n")
+
+print(f"Text saved to {file_path}")

app/sqlite_store.py

@@ -0,0 +1,536 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from datetime import datetime
+from typing import Any, Dict, List
+
+from chatkit.store import NotFoundError, Store
+from chatkit.types import Attachment, Page, Thread, ThreadItem, ThreadMetadata
+
+
+class SQLiteStore(Store[dict[str, Any]]):
+    """Persistent SQLite-backed store compatible with the ChatKit server interface."""
+
+    def __init__(self, db_path: str = "chatkit_threads.db") -> None:
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        
+        # 🚀 Performance optimizations
+        self.conn.execute("PRAGMA journal_mode=WAL")           # Better concurrency
+        self.conn.execute("PRAGMA synchronous=NORMAL")         # Faster writes
+        self.conn.execute("PRAGMA cache_size=10000")           # Larger cache (10MB)
+        self.conn.execute("PRAGMA temp_store=MEMORY")          # Temp tables in RAM
+        self.conn.execute("PRAGMA mmap_size=268435456")        # 256MB memory-mapped I/O
+        self.conn.execute("PRAGMA page_size=4096")             # Optimal page size
+        
+        self._lock = threading.RLock()  # Thread-safe locking
+        self._init_db()
+
+    def _init_db(self) -> None:
+        """Initialize database tables."""
+        with self._lock:
+            cursor = self.conn.cursor()
+            
+            # Threads table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS threads (
+                    thread_id TEXT PRIMARY KEY,
+                    metadata TEXT NOT NULL,
+                    created_at TEXT NOT NULL
+                )
+            """)
+            
+            # Thread items table with sequence number for guaranteed ordering
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS thread_items (
+                    item_id TEXT PRIMARY KEY,
+                    thread_id TEXT NOT NULL,
+                    item_data TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    sequence_num INTEGER NOT NULL,
+                    FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+                )
+            """)
+            
+            # Create optimized indexes for fast retrieval
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_thread_items_thread_id 
+                ON thread_items(thread_id)
+            """)
+            
+            # 🚀 Composite index for ORDER BY queries - CRITICAL for performance!
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_thread_items_thread_sequence 
+                ON thread_items(thread_id, sequence_num, created_at)
+            """)
+            
+            # Index for created_at lookups
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_thread_items_created_at 
+                ON thread_items(created_at)
+            """)
+            
+            # Index for item_id lookups (primary key already indexed, but explicit is better)
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_thread_items_item_id 
+                ON thread_items(item_id)
+            """)
+            
+            # Analyze tables for query optimizer
+            cursor.execute("ANALYZE")
+            
+            self.conn.commit()
+
+    @staticmethod
+    def _coerce_thread_metadata(thread: ThreadMetadata | Thread) -> ThreadMetadata:
+        """Return thread metadata without any embedded items (openai-chatkit>=1.0)."""
+        has_items = isinstance(thread, Thread) or "items" in getattr(
+            thread, "model_fields_set", set()
+        )
+        if not has_items:
+            return thread.model_copy(deep=True)
+
+        data = thread.model_dump()
+        data.pop("items", None)
+        return ThreadMetadata(**data).model_copy(deep=True)
+
+    # -- Thread metadata -------------------------------------------------
+    async def load_thread(self, thread_id: str, context: dict[str, Any]) -> ThreadMetadata:
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute(
+                "SELECT metadata FROM threads WHERE thread_id = ?",
+                (thread_id,)
+            )
+            row = cursor.fetchone()
+            if not row:
+                raise NotFoundError(f"Thread {thread_id} not found")
+            
+            metadata_dict = json.loads(row["metadata"])
+            return ThreadMetadata(**metadata_dict)
+
+    async def save_thread(self, thread: ThreadMetadata, context: dict[str, Any]) -> None:
+        with self._lock:
+            metadata = self._coerce_thread_metadata(thread)
+            metadata_json = metadata.model_dump_json()
+            created_at = (metadata.created_at or datetime.utcnow()).isoformat()
+            
+            cursor = self.conn.cursor()
+            cursor.execute(
+                """
+                INSERT INTO threads (thread_id, metadata, created_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(thread_id) DO UPDATE SET
+                    metadata = excluded.metadata
+                """,
+                (thread.id, metadata_json, created_at)
+            )
+            self.conn.commit()
+
+    async def load_threads(
+        self,
+        limit: int,
+        after: str | None,
+        order: str,
+        context: dict[str, Any],
+    ) -> Page[ThreadMetadata]:
+        with self._lock:
+            cursor = self.conn.cursor()
+            
+            order_clause = "DESC" if order == "desc" else "ASC"
+            
+            if after:
+                # Get the created_at of the 'after' thread
+                cursor.execute(
+                    "SELECT created_at FROM threads WHERE thread_id = ?",
+                    (after,)
+                )
+                after_row = cursor.fetchone()
+                if after_row:
+                    after_time = after_row["created_at"]
+                    comparison = "<" if order == "desc" else ">"
+                    cursor.execute(
+                        f"""
+                        SELECT metadata FROM threads
+                        WHERE created_at {comparison} ?
+                        ORDER BY created_at {order_clause}
+                        LIMIT ?
+                        """,
+                        (after_time, limit + 1)
+                    )
+                else:
+                    cursor.execute(
+                        f"""
+                        SELECT metadata FROM threads
+                        ORDER BY created_at {order_clause}
+                        LIMIT ?
+                        """,
+                        (limit + 1,)
+                    )
+            else:
+                cursor.execute(
+                    f"""
+                    SELECT metadata FROM threads
+                    ORDER BY created_at {order_clause}
+                    LIMIT ?
+                    """,
+                    (limit + 1,)
+                )
+            
+            rows = cursor.fetchall()
+            threads = [ThreadMetadata(**json.loads(row["metadata"])) for row in rows]
+            
+            has_more = len(threads) > limit
+            threads = threads[:limit]
+            next_after = threads[-1].id if has_more and threads else None
+            
+            return Page(
+                data=threads,
+                has_more=has_more,
+                after=next_after,
+            )
+
+    async def delete_thread(self, thread_id: str, context: dict[str, Any]) -> None:
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute("DELETE FROM threads WHERE thread_id = ?", (thread_id,))
+            cursor.execute("DELETE FROM thread_items WHERE thread_id = ?", (thread_id,))
+            self.conn.commit()
+
+    # -- Thread items ----------------------------------------------------
+    def _get_next_sequence_num(self, thread_id: str) -> int:
+        """Get the next sequence number for a thread."""
+        cursor = self.conn.cursor()
+        cursor.execute(
+            "SELECT MAX(sequence_num) as max_seq FROM thread_items WHERE thread_id = ?",
+            (thread_id,)
+        )
+        row = cursor.fetchone()
+        max_seq = row["max_seq"] if row and row["max_seq"] is not None else 0
+        return max_seq + 1
+
+    async def load_thread_items(
+        self,
+        thread_id: str,
+        after: str | None,
+        limit: int,
+        order: str,
+        context: dict[str, Any],
+    ) -> Page[ThreadItem]:
+        with self._lock:
+            cursor = self.conn.cursor()
+            
+            # Use sequence_num for reliable ordering, with created_at as secondary
+            order_clause = "DESC" if order == "desc" else "ASC"
+            
+            if after:
+                # Get the sequence_num of the 'after' item
+                cursor.execute(
+                    "SELECT sequence_num FROM thread_items WHERE item_id = ?",
+                    (after,)
+                )
+                after_row = cursor.fetchone()
+                if after_row:
+                    after_seq = after_row["sequence_num"]
+                    comparison = "<" if order == "desc" else ">"
+                    cursor.execute(
+                        f"""
+                        SELECT item_data FROM thread_items
+                        WHERE thread_id = ? AND sequence_num {comparison} ?
+                        ORDER BY sequence_num {order_clause}, created_at {order_clause}
+                        LIMIT ?
+                        """,
+                        (thread_id, after_seq, limit + 1)
+                    )
+                else:
+                    cursor.execute(
+                        f"""
+                        SELECT item_data FROM thread_items
+                        WHERE thread_id = ?
+                        ORDER BY sequence_num {order_clause}, created_at {order_clause}
+                        LIMIT ?
+                        """,
+                        (thread_id, limit + 1)
+                    )
+            else:
+                cursor.execute(
+                    f"""
+                    SELECT item_data FROM thread_items
+                    WHERE thread_id = ?
+                    ORDER BY sequence_num {order_clause}, created_at {order_clause}
+                    LIMIT ?
+                    """,
+                    (thread_id, limit + 1)
+                )
+            
+            rows = cursor.fetchall()
+            items = []
+            for row in rows:
+                try:
+                    item_dict = json.loads(row["item_data"])
+                    item_type = item_dict.get("type")
+                    
+                    # Import all available message types
+                    from chatkit.types import (
+                        UserMessageItem,
+                        AssistantMessageItem,
+                        ClientToolCallItem,
+                        WorkflowItem,
+                        WidgetItem,
+                        TaskItem,
+                        HiddenContextItem,
+                    )
+                    
+                    # Reconstruct based on type
+                    if item_type == "user_message":
+                        items.append(UserMessageItem(**item_dict))
+                    elif item_type == "assistant_message":
+                        items.append(AssistantMessageItem(**item_dict))
+                    elif item_type == "client_tool_call":
+                        items.append(ClientToolCallItem(**item_dict))
+                    elif item_type == "workflow":
+                        items.append(WorkflowItem(**item_dict))
+                    elif item_type == "widget":
+                        items.append(WidgetItem(**item_dict))
+                    elif item_type == "task":
+                        items.append(TaskItem(**item_dict))
+                    elif item_type == "hidden_context_item":
+                        items.append(HiddenContextItem(**item_dict))
+                    else:
+                        # Unknown type - log but continue
+                        print(f"⚠️ Skipping unknown item type: {item_type}")
+                        continue
+                        
+                except (ImportError, TypeError, KeyError, ValueError, Exception) as e:
+                    # If reconstruction fails, skip this item
+                    print(f"⚠️ Failed to reconstruct item: {e}")
+                    continue
+            
+            has_more = len(items) > limit
+            items = items[:limit]
+            next_after = items[-1].id if has_more and items else None
+            
+            return Page(data=items, has_more=has_more, after=next_after)
+
+
+    async def add_thread_item(
+        self, thread_id: str, item: ThreadItem, context: dict[str, Any]
+    ) -> None:
+        with self._lock:
+            # FIX: ChatKit/ChatCompletionsModel produces "__fake_id__" which causes collisions.
+            # We enforce a unique ID only for items with actual content to ensure their persistence.
+            if item.id == "__fake_id__":
+                has_content = False
+                # Check if message has meaningful text content
+                if hasattr(item, 'content'):
+                    for part in item.content:
+                        if getattr(part, 'type', '') == 'output_text' and getattr(part, 'text', '').strip():
+                            has_content = True
+                            break
+                
+                if has_content:
+                    import uuid
+                    new_id = f"gen_{uuid.uuid4().hex[:12]}"
+                    item = item.model_copy(update={"id": new_id})
+                    print(f"🔄 Resolved fake_id (with content) to unique ID: {new_id}")
+                else:
+                    print(f"⚠️ Keeping __fake_id__ for empty/tool placeholder")
+
+            item_json = item.model_dump_json()
+            created_at_val = getattr(item, "created_at", None)
+            if created_at_val:
+                if isinstance(created_at_val, str):
+                    created_at = created_at_val
+                else:
+                    created_at = created_at_val.isoformat()
+            else:
+                created_at = datetime.utcnow().isoformat()
+            
+            cursor = self.conn.cursor()
+            
+            # Check if item already exists
+            cursor.execute(
+                "SELECT item_id FROM thread_items WHERE item_id = ?",
+                (item.id,)
+            )
+            existing = cursor.fetchone()
+            
+            if existing:
+                # Update existing item - keep original sequence_num
+                cursor.execute(
+                    """
+                    UPDATE thread_items 
+                    SET item_data = ?, created_at = ?
+                    WHERE item_id = ?
+                    """,
+                    (item_json, created_at, item.id)
+                )
+                print(f"✅ Updated existing item {item.id}")
+            else:
+                # Insert new item with next sequence number
+                sequence_num = self._get_next_sequence_num(thread_id)
+                cursor.execute(
+                    """
+                    INSERT INTO thread_items (item_id, thread_id, item_data, created_at, sequence_num)
+                    VALUES (?, ?, ?, ?, ?)
+                    """,
+                    (item.id, thread_id, item_json, created_at, sequence_num)
+                )
+                print(f"✅ Inserted new item {item.id} with sequence {sequence_num}")
+            
+            self.conn.commit()
+            
+            # Verify insertion
+            cursor.execute(
+                "SELECT COUNT(*) as count FROM thread_items WHERE thread_id = ?",
+                (thread_id,)
+            )
+            count = cursor.fetchone()["count"]
+            print(f"🔍 Total items in thread {thread_id}: {count}")
+
+    async def save_item(self, thread_id: str, item: ThreadItem, context: dict[str, Any]) -> None:
+        # Use add_thread_item which handles both insert and update
+        await self.add_thread_item(thread_id, item, context)
+
+    async def load_item(self, thread_id: str, item_id: str, context: dict[str, Any]) -> ThreadItem:
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute(
+                "SELECT item_data FROM thread_items WHERE thread_id = ? AND item_id = ?",
+                (thread_id, item_id)
+            )
+            row = cursor.fetchone()
+            if not row:
+                raise NotFoundError(f"Item {item_id} not found")
+            
+            item_dict = json.loads(row["item_data"])
+            item_type = item_dict.get("type")
+            
+            try:
+                from chatkit.types import (
+                    UserMessageItem,
+                    AssistantMessageItem,
+                    ClientToolCallItem,
+                    WorkflowItem,
+                    WidgetItem,
+                    TaskItem,
+                    HiddenContextItem,
+                )
+                
+                # Reconstruct based on type
+                if item_type == "user_message":
+                    return UserMessageItem(**item_dict)
+                elif item_type == "assistant_message":
+                    return AssistantMessageItem(**item_dict)
+                elif item_type == "client_tool_call":
+                    return ClientToolCallItem(**item_dict)
+                elif item_type == "workflow":
+                    return WorkflowItem(**item_dict)
+                elif item_type == "widget":
+                    return WidgetItem(**item_dict)
+                elif item_type == "task":
+                    return TaskItem(**item_dict)
+                elif item_type == "hidden_context_item":
+                    return HiddenContextItem(**item_dict)
+                else:
+                    raise NotFoundError(f"Item {item_id} has unknown type: {item_type}")
+            except (ImportError, TypeError, KeyError, ValueError) as e:
+                raise NotFoundError(f"Failed to load item {item_id}: {e}")
+
+    async def delete_thread_item(
+        self, thread_id: str, item_id: str, context: dict[str, Any]
+    ) -> None:
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute(
+                "DELETE FROM thread_items WHERE thread_id = ? AND item_id = ?",
+                (thread_id, item_id)
+            )
+            self.conn.commit()
+
+    # -- Files -----------------------------------------------------------
+    async def save_attachment(
+        self,
+        attachment: Attachment,
+        context: dict[str, Any],
+    ) -> None:
+        raise NotImplementedError(
+            "SQLiteStore does not persist attachments. Provide a Store implementation "
+            "that enforces authentication and authorization before enabling uploads."
+        )
+
+    async def load_attachment(
+        self,
+        attachment_id: str,
+        context: dict[str, Any],
+    ) -> Attachment:
+        raise NotImplementedError(
+            "SQLiteStore does not load attachments. Provide a Store implementation "
+            "that enforces authentication and authorization before enabling uploads."
+        )
+
+    async def delete_attachment(self, attachment_id: str, context: dict[str, Any]) -> None:
+        raise NotImplementedError(
+            "SQLiteStore does not delete attachments because they are never stored."
+        )
+    
+    # Helper method to get items (used by zendesk integration)
+    def _items(self, thread_id: str) -> List[ThreadItem]:
+        """Synchronous helper to get all items for a thread (for compatibility with existing code)."""
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute(
+                """
+                SELECT item_data FROM thread_items
+                WHERE thread_id = ?
+                ORDER BY sequence_num ASC, created_at ASC
+                """,
+                (thread_id,)
+            )
+            rows = cursor.fetchall()
+            items = []
+            for row in rows:
+                try:
+                    item_dict = json.loads(row["item_data"])
+                    item_type = item_dict.get("type")
+                    
+                    from chatkit.types import (
+                        UserMessageItem,
+                        AssistantMessageItem,
+                        ClientToolCallItem,
+                        WorkflowItem,
+                        WidgetItem,
+                        TaskItem,
+                        HiddenContextItem,
+                    )
+                    
+                    # Reconstruct based on type
+                    if item_type == "user_message":
+                        items.append(UserMessageItem(**item_dict))
+                    elif item_type == "assistant_message":
+                        items.append(AssistantMessageItem(**item_dict))
+                    elif item_type == "client_tool_call":
+                        items.append(ClientToolCallItem(**item_dict))
+                    elif item_type == "workflow":
+                        items.append(WorkflowItem(**item_dict))
+                    elif item_type == "widget":
+                        items.append(WidgetItem(**item_dict))
+                    elif item_type == "task":
+                        items.append(TaskItem(**item_dict))
+                    elif item_type == "hidden_context_item":
+                        items.append(HiddenContextItem(**item_dict))
+                    else:
+                        print(f"⚠️ Skipping unknown item type in _items: {item_type}")
+                        continue
+                except (ImportError, TypeError, KeyError, ValueError, Exception) as e:
+                    print(f"⚠️ Failed to reconstruct item in _items: {e}")
+                    continue
+            return items
+
+    def close(self):
+        """Close the database connection."""
+        with self._lock:
+            self.conn.close()

app/user_state.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass(slots=True)
+class UserData:
+    customer_id: Optional[str] = None
+    customer_name: Optional[str] = None
+    customer_email: Optional[str] = None
+    customer_phone: Optional[str] = None
+    purpose_call: Optional[str] = None
+    is_paused: bool = False
+    Timezone: Optional[str] = None
+    agent_memories: Dict[str, Any] = field(default_factory=dict)
+    access_token: Optional[str] = None
+    company_name: Optional[str] = None
+    Booked_appointment: Optional[str] = None
+    agents: Dict[str, Any] = field(default_factory=dict)
+    prev_agent: Any | None = None
+    summary: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class UserStateManager:
+    """Manages per-thread user/customer state for the multi-agent flow with SQLite persistence."""
+
+    def __init__(self, db_path: str = "user_state.db") -> None:
+        self._states: Dict[str, UserData] = {}
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._init_db()
+        self._load_all_states()
+
+    def _init_db(self) -> None:
+        """Initialize the user state database table."""
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS user_states (
+                thread_id TEXT PRIMARY KEY,
+                state_data TEXT NOT NULL,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        self.conn.commit()
+
+    def _load_all_states(self) -> None:
+        """Load all user states from database into memory on startup."""
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT thread_id, state_data FROM user_states")
+        for row in cursor.fetchall():
+            thread_id, state_json = row
+            try:
+                state_dict = json.loads(state_json)
+                self._states[thread_id] = UserData(**state_dict)
+            except Exception as e:
+                print(f"⚠️ Failed to load state for thread {thread_id}: {e}")
+
+    def _save_state(self, thread_id: str) -> None:
+        """Persist a thread's state to the database."""
+        state = self._states.get(thread_id)
+        if state is None:
+            return
+        
+        try:
+            state_json = json.dumps(state.to_dict())
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                INSERT INTO user_states (thread_id, state_data, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(thread_id) DO UPDATE SET
+                    state_data = excluded.state_data,
+                    updated_at = CURRENT_TIMESTAMP
+            """, (thread_id, state_json))
+            self.conn.commit()
+        except Exception as e:
+            print(f"⚠️ Failed to save state for thread {thread_id}: {e}")
+
+    def _create_default_state(self) -> UserData:
+        return UserData()
+
+    def get_user(self, thread_id: str) -> UserData:
+        if thread_id not in self._states:
+            self._states[thread_id] = self._create_default_state()
+            self._save_state(thread_id)
+        return self._states[thread_id]
+
+    # -- Mutators --------------------------------------------------------
+    def set_customer_info(
+        self,
+        thread_id: str,
+        *,
+        customer_id: Optional[str] = None,
+        name: Optional[str] = None,
+        email: Optional[str] = None,
+        phone: Optional[str] = None,
+        company_name: Optional[str] = None,
+    ) -> None:
+        data = self.get_user(thread_id)
+        if customer_id is not None:
+            data.customer_id = customer_id
+        if name is not None:
+            data.customer_name = name
+        if email is not None:
+            data.customer_email = email
+        if phone is not None:
+            data.customer_phone = phone
+        if company_name is not None:
+            data.company_name = company_name
+        self._save_state(thread_id)
+
+    def set_purpose(self, thread_id: str, purpose: Optional[str]) -> None:
+        self.get_user(thread_id).purpose_call = purpose
+        self._save_state(thread_id)
+
+    def set_timezone(self, thread_id: str, timezone: Optional[str]) -> None:
+        self.get_user(thread_id).Timezone = timezone
+        self._save_state(thread_id)
+
+    def set_paused(self, thread_id: str, paused: bool) -> None:
+        self.get_user(thread_id).is_paused = bool(paused)
+        self._save_state(thread_id)
+
+    def set_access_token(self, thread_id: str, token: Optional[str]) -> None:
+        self.get_user(thread_id).access_token = token
+        self._save_state(thread_id)
+
+    def set_booked_appointment(self, thread_id: str, value: Optional[str]) -> None:
+        self.get_user(thread_id).Booked_appointment = value
+        self._save_state(thread_id)
+
+    def get_cached_access_token(self, thread_id: str) -> Optional[str]:
+        """Get the access token if it exists and is less than 12 hours old."""
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            SELECT state_data, updated_at FROM user_states WHERE thread_id = ?
+        """, (thread_id,))
+        row = cursor.fetchone()
+        if not row:
+            return None
+        
+        state_json, updated_at_str = row
+        from datetime import datetime, timezone, timedelta
+        
+        try:
+            # updated_at is stored in UTC by the DB
+            updated_at = datetime.fromisoformat(updated_at_str.replace(' ', 'T') + "+00:00")
+            if datetime.now(timezone.utc) - updated_at > timedelta(hours=12):
+                print(f"🕒 Access token for {thread_id} expired (> 12h)")
+                return None
+            
+            state_dict = json.loads(state_json)
+            return state_dict.get("access_token")
+        except Exception as e:
+            print(f"⚠️ Error checking token expiration: {e}")
+            return None
+
+    def update_access_token(self, thread_id: str, token: str) -> None:
+        """Update the access token and reset the updated_at timestamp."""
+        data = self.get_user(thread_id)
+        data.access_token = token
+        # _save_state updates updated_at to CURRENT_TIMESTAMP
+        self._save_state(thread_id)
+
+    def set_summary(self, thread_id: str, summary: str) -> None:
+        self.get_user(thread_id).summary = summary
+        self._save_state(thread_id)
+
+    def get_summary(self, thread_id: str) -> str:
+        return self.get_user(thread_id).summary or ""
+
+    # Agent registry helpers
+    def register_agent(self, thread_id: str, key: str, agent: Any) -> None:
+        self.get_user(thread_id).agents[key] = agent
+        self._save_state(thread_id)
+
+    def get_agent(self, thread_id: str, key: str) -> Any:
+        return self.get_user(thread_id).agents.get(key)
+
+    def set_prev_agent(self, thread_id: str, agent: Any | None) -> None:
+        self.get_user(thread_id).prev_agent = agent
+        self._save_state(thread_id)
+
+    # Memories helpers
+    def remember(self, thread_id: str, key: str, value: Any) -> None:
+        self.get_user(thread_id).agent_memories[key] = value
+        self._save_state(thread_id)
+
+    def recall(self, thread_id: str, key: str, default: Any = None) -> Any:
+        return self.get_user(thread_id).agent_memories.get(key, default)
+
+    # -- Serialization ---------------------------------------------------
+    def to_dict(self, thread_id: str) -> Dict[str, Any]:
+        return self.get_user(thread_id).to_dict()
+

app/website/output.txt

@@ -0,0 +1,7 @@
+=== Output Start ===
+
+The following text is scraped website content:
+
+British Curriculum Schools - Sunmarke School, Best School in Dubai Apply Visit Enquire VLE Login About Principal’s Message Mission, Vision, Values A Positive Education School Leadership Academic Results Inspection Reports Our Achievements Sunmarke Alumni Wellbeing The Achievement Centre – Inclusion Department Our Campus Learning Nursery Our Approach Enriched Learning EYFS Our Approach Early Years Curriculum Enriched Learning Primary Our Approach Primary Curriculum Sports & PE Creative & Performing Arts Enriched Learning Coding Student Council and Ambassadors Secondary Our Approach Secondary Curriculum Sports & PE Creative & Performing Arts Enriched Learning Coding Sunmarke Mini MBA Student Council and Ambassadors Sixth Form Our Approach A-Levels  BTECs IB Diploma Programme (IBDP) Student Enrichment Coding CIVITAS Careers Counsellor Student Leadership Signature Programmes STEAM & Design Thinking Environment & Sustainability University & Career Readiness Programme Fortes Pro Sports Academy Positive Education Global Language Academy  Financial Literacy Programme Enterprise & Mini-MBA Programme Communications, Media & the Performing Arts Programme Admissions Apply Online Schedule a Visit Tuition Fees Scholarships Re-enrol Online School Forms FAQs For Parents School Uniform School Timings Academic Calendar School Events Calendar Policies Transport Services Dining & Catering Sports Hub Parent Engagement Governance Committee Activities Sunmarke Free Extracurricular Activities (ECAs) Sunmarke Paid Extracurricular Activities Third-Party Paid Extracurricular Activities News & Events Weekly Buzz Blog Press Podcasts Contact Us  Work With Us Apply Visit Enquire VLE Login About Principal’s Message Mission, Vision, Values A Positive Education School Leadership Academic Results Inspection Reports Our Achievements Sunmarke Alumni Wellbeing The Achievement Centre – Inclusion Department Our Campus Learning Nursery Our Approach Enriched Learning EYFS Our Approach Early Years Curriculum Enriched Learning Primary Our Approach Primary Curriculum Sports & PE Creative & Performing Arts Enriched Learning Coding Student Council and Ambassadors Secondary Our Approach Secondary Curriculum Sports & PE Creative & Performing Arts Enriched Learning Coding Sunmarke Mini MBA Student Council and Ambassadors Sixth Form Our Approach A-Levels  BTECs IB Diploma Programme (IBDP) Student Enrichment Coding CIVITAS Careers Counsellor Student Leadership Signature Programmes STEAM & Design Thinking Environment & Sustainability University & Career Readiness Programme Fortes Pro Sports Academy Positive Education Global Language Academy  Financial Literacy Programme Enterprise & Mini-MBA Programme Communications, Media & the Performing Arts Programme Admissions Apply Online Schedule a Visit Tuition Fees Scholarships Re-enrol Online School Forms FAQs For Parents School Uniform School Timings Academic Calendar School Events Calendar Policies Transport Services Dining & Catering Sports Hub Parent Engagement Governance Committee Activities Sunmarke Free Extracurricular Activities (ECAs) Sunmarke Paid Extracurricular Activities Third-Party Paid Extracurricular Activities News & Events Weekly Buzz Blog Press Podcasts Contact Us  Work With Us Carlota & Ruben win the ‘World’s Best Debater’ competition at the ‘World Scholars Cup’ Global Finals held at Yale University competing against 1000’s of students from schools across 40 countries International School Welcome to Sunmarke School A Passionately Character-Building & Innovative School in the Middle East Sunmarke provides an ambitious and inspiring values-based education nurturing the hearts and minds of young boys and girls so that they can flourish and achieve their dreams. Simply put, we transform young lives. Powered by our unique, leading-edge Signature Programmes, we are an incredibly innovative school reshaping and inspiring tomorrow’s generation. We are amongst the top 5 schools in Dubai, as seen by our outstanding IB and A-Level results, top university placements, and notable student achievements in the arts, sports, and extracurriculars. We are a recognised global leader in Positive Education – a paradigm shift in education worldwide – where it’s increasingly acknowledged that truly outstanding teaching and learning is only attained by developing “academic and personal excellence” as well as “well-being and character”. We are one of the few schools in the UAE to offer both the IB and A-Level curriculum pathways, as well as the BTECs. Backed by Fortes Education’s rich history of over 40 years in academia, Sunmarke is rated “Outstanding” by the British School Overseas Inspection Authority and “Very Good” by KHDA. Our Purpose We aim to inspire young boys and girls to thrive and flourish with purpose. A Rigorous & Ambitious Education We deliver an education that emphasises academic excellence and participation in diverse sports, performing arts and extracurricular activities. Outstanding Senior Leaders & Teachers Our educators are ambassadors of Positive Education and inspirational teachers. 40 Years of History Sunmarke School is backed by Fortes Education’s four decades of excellence in education Nursery Ages 45 days to 3 years EYFS Ages 3 to 5 years Primary Ages 5 to 11 years Secondary Ages 11 to 16 years Sixth Form Ages 16 to 18 years Sunmarke - Pathway to Top Universities Top University Destinations Sunmarke’s Unique & Leading-edge Signature Programmes STEAM & Design Thinking Students become creative problem-solvers through hands-on projects in coding, robotics, AI, 3D printing, and sustainable design, developing critical thinking, collaboration, and innovative solutions with real-world impact. Learn more Environment & Sustainability Students develop eco-leadership through outdoor learning, gardens, and real-world experiences, gaining sustainability skills, respect for nature, and the ability to drive positive environmental change in communities. Learn more University & Career Readiness The University & Career Readiness Programme empowers students with personalised guidance, internships, global engagement, and career counselling, equipping them with skills, confidence, and clarity for future success. Learn more Pro Sports Academy Sunmarke’s Pro Sports Academy develops athletes through elite coaching, 100+ squads, and global competitions, integrating fitness, nutrition, and resilience for lifelong excellence, discipline, and success beyond sport. Learn more Positive Education Internationally recognised for its holistic approach, the school blends wellbeing, character development, and Positive Psychology, nurturing resilient, empathetic, confident learners who thrive academically, socially, and emotionally. Learn more Global Language Programme The Global Languages Programme immerses students in Hindi and Mandarin, fostering communication, cultural awareness, empathy, and adaptability through storytelling, projects, traditions, and real-life experiences for global readiness. Learn more Financial Literacy The programme equips students with practical financial skills, ethical investment habits, and entrepreneurial thinking through interactive learning, fostering confidence, critical thinking, and responsible decision-making in real-world financial contexts. Learn more Enterprise & Mini-MBA Programme Sunmarke’s Enterprise & Mini-MBA empowers Years 10–13 with business, leadership, and innovation skills through workshops, mentorship, and industry exposure, preparing resilient future leaders and entrepreneurs. Learn more Communications, Media & the Performing Arts A dynamic programme combining drama, media, film, and communication, building confidence, creativity, and critical thinking through storytelling, performance, collaboration, and industry workshops from EYFS to Year 13. Learn more Excellent Academic Results 2024-25 0 IBDP AVERAGE POINTS SCORE more than 6 points above the world average 0 % IBDP RESULTS students exceeding the world average 0 % IBDP RESULTS students exceeding 35+ points 0 % IBDP RESULTS more than one in four students achieved 40+ points 0 % A-LEVEL & BTEC RESULTS 100% student pass rate at A-Level & BTEC 0 % A-LEVEL A*- C BTEC D*-M 0 % A-LEVEL A*- B BTEC D*-D 0 % A-LEVEL A*- A BTEC D* 0 % GCSE RESULTS 100% student pass rate at GCSE 0 % GCSE 9-4 (A*- C) including English & Maths 0 % GCSE 9-6 (A*- B) 0 % GCSE 9-7 (A*- A) Sunmarke - Launchpad to Future Success Our Summer Workplace Internships for Students Parent Testimonials “ My daughter has discovered an incredible passion for media over the last 2 years under the coaching of the teachers here at Sunmarke. Mrs Rebekah Parent, Sunmarke School “ Seeing our daughter excel right from understanding pre-production, production to post-production, we absolutely love Sunmarake School.  Mrs Nandita Parent, Sunmarke School “ Today’s experience has been really valuable for me, appreciating just how well the science, technology, arts, and mathematical elements come together.  Parent Sunmarke School “ I’d like to say thank you to Sunmarke that you have such a perfect opportunity to have this experience with our kids. Parent Sunmarke School “ I’m super happy for my daughter that has the opportunity to make experiments, and prototypes, try something, and create something. It’s amazing for every child. Parent Sunmarke School “ It’s great to see how they want to develop kids more with the creative mind in the STEAM Programme. We loved it. We are looking forward to more! Parent Sunmarke School “ We are very happy to come today. I think it’s a very nice experience for both the kids and the parents…it’s amazing. Parent Sunmarke School “ Our children are growing up as future citizens of the world, and they are super happy and enthusiastic to go to school every day. Emily Parent, Sunmarke School “ I am genuinely impressed with everything that the kids are exposed to here at Sunmarke School. Also, immensely thankful for everything that the school is providing them. Sherif Parent, Sunmarke School “ What I like about Sunmarke is its environment and sustainability programme, as it raises children’s awareness about the world. Christina & Mike Parent, Sunmarke School “ Sunmarke is the best school choice for us because my daughter is very happy to go to school every day. As a parent, I am highly satisfied with the quality of education provided here at Sunmarke School, as I can witness my daughter’s consistent progress and improvement each day. Tetiana Parent, Sunmarke School “ I am really impressed with the STEAM programme they have here at Sunmarke. Moreover, my kids have the opportunity to explore and learn about environmental and sustainability programme as well. I am very thankful for all the opportunities Sunmarke is providing for my kids. Leandra Parent, Sunmarke School “ Sunmarke School is truly amazing. I couldn’t have asked for more. It’s been the perfect school for my son. Saireh Parent, Sunmarke School “ As a family, we have travelled a lot and our children have attended the top schools in the world. I can confidently say Sunmarke is amongst the top schools. It’s competitive both in academics and sports and offers a wide range of extracurriculars. The school keeps surprising us with its innovative programs and yet never forgets the heart and soul of the child. Pillaar Parent, Sunmarke School “ We have been at Sunmarke from the beginning and have seen our children grow into character-strong, confident young adults. They are well-balanced, have a strong sense of values, and approach each day with a sense of gratitude. Honestly, as parents, we could not have asked for more.  Parent Sunmarke School “ This is a fantastic school. We have been here for 5 years and our kids are really, really happy. The school is a home away from home. The teachers are really what make a difference – passionate about teaching, the children, and dynamic practitioners. Parent Sunmarke School “ I was blown away and super impressed with Sunmarke’s STEAM programme where multiple classes such as science, technology and computing, math, art and media, and design technology are collapsed into one massive lab which the school calls SPACE-X (in nod to Elon Musk himself). STEAM is interwoven across the whole curriculum. Sunmarke takes the learning journey to the next level. My son is always very excited about STEAM. Sunmarke’s teaching style has lifted his critical thinking skills, enabling him to find solutions to real-life problems. Rasha Khalil Parent, Sunmarke School “ Sunmarke is not just about the regular staple diet of education schools give. It goes way beyond anything we have experienced. My child, Alfa, has benefited tremendously with the school’s various signature programmes, such as the Forest School and the STEAM programme. During our visit to the school’s STEAM showcase, Alfa, my child mentioned, showed what he had created with great interest. As parents we were fascinated by his learning journey, how he took the concept of catapult studied in Stone Age man to a full blown model with all the ways the catapult was used in hunting for food. Sunmarke encapsulates real and practical learning and engagement at its best. Mrs. Breman Parent, Sunmarke School “ My son’s learning from Sunmarke’s unbelievably creative Signature Programmes has been the hallmark of his growth at school. He has grown to have a real love for Nature and truly cares about conservation, all learned through Sunmarke’s Forest School programme. At Sunmarke’s STEAM programme and Space-X, he tinkers, ideates and tries, fails, and tries and finally successfully makes products and solutions, learning perseverance and the patience that even if you fail, always keep trying till you succeed.  Marianne Boushra Parent, Sunmarke School “ Children truly learn when they have fun and that is exactly what Sunmarke achieves daily in and out of the classroom. My child has shown his immense excitement about STEAM and constantly updates me about the progress of his projects. I love being able to see my child express his work and his learning journey. He is engaged, involved, and passionate, and he looks forward to going to school every day. Nura Al Gaddah Parent, Sunmarke School “ Sunmarke is an amazing school for students of all ages, with its state of the art campus, well behaved students, qualified faculty and efficient admin team. That’s when we decided to enrol our child in the IB curriculum. It’s been a great experience for us as parents. Anita Isaac Parent, Sunmarke School “ Focuses on the individual. Mutual respect. Building a genuine relationship with child and parent. Parent Sunmarke School “ Happy to have my daughter in this amazing school. Ahlam Bounaim Parent, Sunmarke School “ Great school to learn and play. The teacher and assistant are all benevolent with children. Virginie Parent, Sunmarke School “ The most important thing about Sunmarke is the fact that it is a school that listens positively and take prompt action and my child’s progress is its number one priority. Parent Sunmarke School “ My elder son is in primary at Sunmarke School. We are really happy with the curriculum here and all the Signature programmes offered especially Performing Arts where my son got the opportunity to showcase his talent. Okesia Panina Parent, Sunmarke School “ Beside the impressive facilities and very strong academic track record, the school is remarkable in ensuring it’s ‘positive education’ philosophy is lived and breathed every day. Far from being just a tag line applied by a marketeer, the pastoral care and support for the children is second to none. Parent Sunmarke School “ My children at Sunmarke are extremely happy with the environment and the encouragement that’s being provided by the teachers. Its indeed commendable for a friendly atmosphere where all the kids are provided platform to showcase their potential. Sheeba Suresh Parent, Sunmarke School “ No bullying policy, positive education, good teachers and organization. Parent Sunmarke School “ Sunmarke’s education is beyond compare – strong academics, a caring atmosphere, attention to every child, and a wide range of extracurricular and sports activities. Our children and us as a family have been extremely happy with Sunmarke. Pillaar Parent, Sunmarke School “ At Sunmarke, my daughter has grown into a young adult with a strong sense of values and character. She excels in her academics, is thoughtful and kind, approaches each day with a positive attitude, and is a joy to be around. As a family, we are deeply grateful to Sunmarke and its absolutely wonderful and caring teachers who are wonderful role models and truly embody the character strengths and wellbeing the school and its ethos of Positive Education espouse. Shereen Raggel Parent, Sunmarke School “ I have been truly impressed by my child’s learning at Sunmarke. However, this level of education is evident amongst his entire class. My child and his cohort’s depth of knowledge, innovative approach to problem-solving and thinking, and respectful nature have all impressed me. Each zone in the school is very well resourced, equipped both technologically and academically. Keep up the good work Sunmarke! Zaid Hassan Parent, Sunmarke School “ Sunmarke School is an across the board “Outstanding School” and provides an outstanding quality of education for all its pupils. BSO Inspection Report “ Sunmarke School is outstanding in almost all respects. Student’s learning skills are very strong. A significant key strength of the school is the outstanding wellbeing and personal development of all students. KHDA Report “ Sunmarke School is genuinely a ground-breaking school and offers the broadest curriculum options of ANY other school in the Emirates. SchoolsCompared.com “ We would encourage interested parents to visit this school. We are impressed by the commitment of the school to an open policy towards students of all abilities and the development of the curriculum to provide a far wider range of Sixth Form options than has been seen to date in Dubai. WhichSchoolAdvisor.com “ Sunmarke meets the criteria of a ‘School of Character’ many times over. It is an ‘Outstanding School of Character’ and makes a huge difference to the lives of the children in this school. Character and the idea of ‘flourishing’ is embedded within everything this school does. I am hugely impressed! Prof. James Arthur, Director of the Jubilee Centre for Character & Virtues at The University of Birmingham, UK Insights and Latest News Visit Our Blog 28/11/2025 Career Readiness: Why It Matters for Students Today In today’s fast-evolving world, preparing students for the future goes... Read More 14/11/2025 How Schools Can Lead the Way in Sustainable Practices In a world facing growing environmental challenges, schools have a... Read More 07/11/2025 The Rise of AI in Media: Opportunities for Young Creators In the past decade, artificial intelligence (AI) has transformed industries... Read More 21/10/2025 From Passion to Profession: Student-Led Startups & Enterprise Projects at Sunmarke At Sunmarke School, we believe that education should go beyond... Read More 14/10/2025 Well-being in the Digital World: Balancing Screen Time, Sleep & Study for Teen Learners In today’s fast-paced digital age, our students live in a... Read More 07/10/2025 Beyond Grammar: How the Fortes English Language Programme Shapes Confident Communicators At Sunmarke School, we believe that mastering a language is... Read More 28/09/2025 Beyond the Textbook: Sunmarke’s Innovative Approach to Secondary Education In today’s fast-changing world, education can no longer be confined... Read More 21/09/2025 Learning Through Doing: The Power of Projects in Sunmarke’s STEAM Education At Sunmarke School, education goes far beyond textbooks and exams.... Read More 14/09/2025 Little Learners, Big Numbers: Bringing Maths to Life in the Early Years Mathematics is often thought of as a subject of precision,... Read More Follow Us Our Stories Sunmarke School Oliver - Secondary Musical Teaser ✨ Get Ready! Lionel Bart’s Oliver! Is Coming to the Sunmarke Stage ✨ Step into the streets of Victorian London and experience a powerful story of hope, resilience, and the courage to dream. Born with nothing. Fighting for everything. One chance ... Posted: 4 days ago Sunmarke School Discover Sunmarke School | Our Principal on Learning, Values & Community In this Principal's Message, Mr Nicholas Rickford shares insights into Sunmarke School’s academic pathways and the thinking behind our carefully designed curriculum. He highlights our signature programmes, strong positive education ethos, and commitment to nurturing confident, well-rounded learners. From A-Levels ... Posted: 2 weeks ago Sunmarke School Think & Thrive Career Development Programme Think & Thrive is Sunmarke’s signature speaker series designed to inspire, inform, and empower our Secondary students as they explore future pathways. Bringing together innovators, artists, sports personalities, entrepreneurs, and business leaders from across the region, the programme creates meaningful ... Posted: 2 weeks ago Sunmarke School Think & Thrive with Mr. Aaron Stroble, Director at Oceaneering (UAE: Surf Abu Dhabi) Our Year 10 student, Daria, led an engaging ‘Think & Thrive’ session, an integral part of our signature programme, with Mr Aaron Stroble, Director at Oceaneering, where they explored the future of sustainability and renewable energy. 🤩👏✨ It was a wonderful ... Posted: Last month Sunmarke School Think & Thrive with Mr. Aaron Stroble, Director at Oceaneering (UAE: Surf Abu Dhabi) Posted: Last month Sunmarke School Parent Testimonial: Growing and Thriving at Sunmarke Posted: 2 months ago Sunmarke School Sunmarke Parent Survey 2025-2026 At Sunmarke School, we truly value our parents’ feedback. 🤩💯 Today, our Principal, Mr Nicholas Rickford, launched the Your Voice Counts survey — an opportunity for our parent community to share what they love most about Sunmarke and the areas they’d ... Posted: 2 months ago Sunmarke School GCSE Results 2024–2025: Outstanding Achiever – Parent Testimonial Posted: 4 months ago Sunmarke School GCSE Results 2024–2025: Outstanding Achiever – Student Testimonial Posted: 4 months ago Sunmarke School GCSE Results 2024–2025: Outstanding Achiever – Student Testimonial Posted: 4 months ago Sunmarke School BTEC Results 2024-2025: Outstanding Achiever Posted: 4 months ago Sunmarke School Sunmarke Synergy Summer Internship Programme At Sunmarke, we take pride in equipping our students with real-world skills that help them thrive in professional setups beyond school. Our recent graduate, Kaveh, got a glimpse of how our Marketing team functions as he completed a four-week stint with ... Posted: 5 months ago Sunmarke School Sunmarke Synergy Summer Internship Programme Our recent graduate, Nathan, who will soon be flying to the University of Toronto for further studies, completed an exciting four-week stint with our Marketing team as part of the Sunmarke Synergy Summer Internship Programme. Nathan worked across multiple marketing ... Posted: 5 months ago Sunmarke School The Wiz – A Magical Secondary Production at Sunmarke We enjoyed a delightful retelling of the timeless classic The Wiz at Sunmarke. Each character brought their unique energy to the stage with their vibrant performances, soulful tunes and colourful costumes. The bold Dorothy, the heartwarming Lion, the Tin ... Posted: 5 months ago Sunmarke School Sunmarke Synergy Summer Internship Programme Synergising with Sunmarke! 🤩 Hear what our Year 10 student Paloma has to say about her exciting four-week stint with our Admissions team as part of the Sunmarke Synergy Summer Internship Programme. She dived into a dynamic environment, leading school tours, ... Posted: 5 months ago Virtual Tour Tour Sunmarke and our amazing facilities Disclaimer: Sunmarke School is not responsible for any losses or damages incurred as a result of interacting with or making transactions on scam or fraudulent websites. We do not endorse, verify, or guarantee the authenticity of any third-party websites or services linked to or mentioned on our platform. Sunmarke School Telephone:   +971 4 423 8900 Email:   Click here to contact us Behind Limitless Building Al Khail Road District 5, Jumeirah Village Triangle PO Box 24857, Dubai, UAE Useful Links Parent Portal (VLE) Tuition Fees Vacancies DSIB Inspection Report IBDP, GCSE, A-Level & BTEC Results Sunmarke Sixth Form School Dubai EYFS Curriculum Dubai Sunmarke Primary School Dubai Sunmarke Secondary School Dubai Fortes Family Sunmarke School Regent International School Jumeirah International Nurseries Fortes Education Copyright All Right Reserved 2025. Sunmarke School | Terms & Conditions
+
+=== Output End ===

chatkit_threads.db-wal

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b2c676248e91d338f81d69ab6b9b09d759e310cc0de47a2bacf06e32e892274
+size 2657432

chromafast_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4b89606a53e90d5da168959f098b209854f25d8bb9182de97cbc067d03b3b0e
+size 167936

pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "chatkit-backend"
+version = "0.1.0"
+description = "FastAPI backend service for ChatKit boilerplate"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.114.1,<0.116",
+    "httpx>=0.28,<0.29",
+    "uvicorn[standard]>=0.36,<0.37",
+    "openai>=1.40",
+    "openai-chatkit>=1.0.2,<2",
+    "llama-index-llms-groq",
+    "llama-index",
+    "llama-index-embeddings-huggingface",
+    "llama-index-vector-stores-chroma",
+    "nest_asyncio",
+    "InstructorEmbedding",
+    "chromadb",
+    "lc-sdk-python>=0.4.1",
+    "loguru>=0.7.3",
+    "groq>=0.37.1",
+    "crewai-tools>=0.76.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.6.4,<0.7",
+    "mypy>=1.8,<2",
+]
+
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["app"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+extend-select = ["I"]