Base directory setup

app.py

@@ -2,69 +2,334 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
+import gradio as gr
+import json
+import os
+import re
+import subprocess
+import uuid
+from pathlib import Path
+from typing import List, Dict, Any
 
+import llama_cpp
+from huggingface_hub import hf_hub_download
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+# =========================
+# CONFIG: FILL THESE IN
+# =========================
+REPO_EMBED = "mixedbread-ai/mxbai-embed-large-v1"       
+REPO_LLM   = "unsloth/Phi-4-mini-instruct-GGUF"         
+REPO_PIPER = "nardocolin/nardocolin-pipertts"     
+
+EMBED_FILE = "gguf/mxbai-embed-large-v1-f16.gguf"
+LLM_FILE   = "Phi-4-mini-instruct.Q8_0.gguf"
+PIPER_ONNX = "high/colin-voice_high.onnx"
+PIPER_JSON = "high/colin-voice_high.onnx.json"
+
+EMBED_DIM = 1024
+COLLECTION_NAME = "data"
+
+# =========================
+# PATHS / DIRECTORIES
+# =========================
+SPACE_DIR = Path(__file__).parent
+DATA_DIR  = SPACE_DIR / "data"
+EMB_DIR   = SPACE_DIR / "embeddings"
+AUDIO_DIR = SPACE_DIR / "audio"
+DATA_DIR.mkdir(exist_ok=True)
+EMB_DIR.mkdir(exist_ok=True)
+AUDIO_DIR.mkdir(exist_ok=True)
+
+STRUCTURED_JSON = DATA_DIR / "structured-cv.json" 
+
+# =========================
+# DOWNLOAD WEIGHTS
+# =========================
+embed_path = hf_hub_download(REPO_EMBED, EMBED_FILE)
+llm_path   = hf_hub_download(REPO_LLM,   LLM_FILE)
+piper_onnx = hf_hub_download(REPO_PIPER, PIPER_ONNX)
+piper_json = hf_hub_download(REPO_PIPER, PIPER_JSON)
+
+# =========================
+# LOAD MODELS (CPU)
+# =========================
+embedding_llm = llama_cpp.Llama(
+    model_path=embed_path,
+    embedding=True,
+    verbose=False
+)
+
+llm = llama_cpp.Llama(
+    model_path=llm_path,
+    n_ctx=8192,
+    verbose=False
 )
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+# =========================
+# QDRANT (LOCAL, FILE BACKEND)
+# =========================
+client = QdrantClient(path=str(EMB_DIR))
+
+def qdrant_collection_exists() -> bool:
+    try:
+        cols = client.get_collections().collections
+        return any(c.name == COLLECTION_NAME for c in cols)
+    except Exception:
+        return False
+
+def ensure_collection():
+    if qdrant_collection_exists():
+        return
+    client.create_collection(
+        collection_name=COLLECTION_NAME,
+        vectors_config=VectorParams(size=EMBED_DIM, distance=Distance.COSINE),
+    )
+
+# =========================
+# RAG BUILD FROM STRUCTURED JSON
+# =========================
+def _extract_texts_from_structured_json(d: Dict[str, Any]) -> List[str]:
+    texts: List[str] = []
+
+    # summary
+    if d.get("summary"):
+        texts.append(d["summary"])
+
+    # professional_focus
+    pf = d.get("professional_focus", {})
+    for lst_key in ("problem_solving_style", "leadership_and_teamwork"):
+        for item in pf.get(lst_key, []) or []:
+            texts.append(item)
+
+    # technical_philosophy
+    tp = d.get("technical_philosophy", {})
+    if tp.get("title"):
+        texts.append(tp["title"])
+    for pt in tp.get("points", []) or []:
+        texts.append(pt)
+
+    # education details
+    edu = d.get("education", {})
+    if edu.get("degree"):
+        texts.append(f"{edu.get('institution','')} – {edu['degree']}")
+    for det in edu.get("details", []) or []:
+        texts.append(det)
+
+    # projects
+    for p in d.get("projects", []) or []:
+        if p.get("title"):
+            texts.append(p["title"])
+        if p.get("organization"):
+            texts.append(p["organization"])
+        for c in p.get("contributions", []) or []:
+            texts.append(c)
+        if p.get("key_takeaways"):
+            texts.append(p["key_takeaways"])
+        if p.get("technical_deep_dive"):
+            texts.append(p["technical_deep_dive"])
+
+    # experience
+    for e in d.get("experience", []) or []:
+        if e.get("role") and e.get("company"):
+            texts.append(f"{e['role']} @ {e['company']}")
+        if e.get("description"):
+            texts.append(e["description"])
+
+    # skills (flatten)
+    skills = d.get("skills", {})
+    for k, v in skills.items():
+        if isinstance(v, list):
+            for item in v:
+                if isinstance(item, dict):
+                    # spoken_languages entries
+                    lang = item.get("language")
+                    prof = item.get("proficiency")
+                    if lang and prof:
+                        texts.append(f"{lang} – {prof}")
+                else:
+                    texts.append(str(item))
+
+    # personal_info (light)
+    pi = d.get("personal_info", {})
+    for key in ("name", "email", "linkedin", "website"):
+        if pi.get(key):
+            texts.append(str(pi[key]))
+
+    # Deduplicate & trim
+    final = []
+    seen = set()
+    for t in texts:
+        t = (t or "").strip()
+        if not t:
+            continue
+        if t in seen:
+            continue
+        seen.add(t)
+        final.append(t)
+    return final
+
+def build_rag_from_structured_json() -> int:
+    """(Re)builds Qdrant from data/structured-cv.json. Returns number of points."""
+    if not STRUCTURED_JSON.exists():
+        raise FileNotFoundError("structured-cv.json not found in ./data")
+
+    with open(STRUCTURED_JSON, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    texts = _extract_texts_from_structured_json(data)
+    if not texts:
+        return 0
+
+    # Compute embeddings (batch)
+    points: List[PointStruct] = []
+    batch = 32
+    for i in range(0, len(texts), batch):
+        chunk = texts[i:i+batch]
+        embs = embedding_llm.create_embedding(chunk)["data"]
+        for t, e in zip(chunk, embs):
+            points.append(PointStruct(
+                id=str(uuid.uuid4()),
+                vector=e["embedding"],
+                payload={"text": t}
+            ))
+
+    # Reset collection to avoid dupes
+    try:
+        client.delete_collection(collection_name=COLLECTION_NAME)
+    except Exception:
+        pass
+    ensure_collection()
+    client.upsert(collection_name=COLLECTION_NAME, points=points, wait=True)
+    return len(points)
+
+# =========================
+# LLM + RAG INFERENCE
+# =========================
+def clean_text_for_tts(text: str) -> str:
+    text = re.sub(r"[^\x00-\x7F]+", "", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+PERSONA_TEMPLATE = """You are Colin Salvatore Nardo, a Computing Science student at the University of Glasgow. Your persona is friendly, down-to-earth, and you must always speak in the first person ("I", "my", "me"). Your entire knowledge and experiences are defined EXCLUSIVELY by the "Knowledge Base" below.
+
+CRITICAL RULES
+1) ZERO FABRICATION. Only use the Knowledge Base; otherwise say you don't have those details.
+2) You ARE Colin. Never reveal you are an AI.
+3) Keep answers concise and natural.
+
+Knowledge Base:
+{context}
+
+Question: {question}
+"""
+
+def rag_context(query: str, k: int = 5) -> str:
+    try:
+        vec = embedding_llm.create_embedding(query)["data"][0]["embedding"]
+        hits = client.search(collection_name=COLLECTION_NAME, query_vector=vec, limit=k)
+        if not hits:
+            return ""
+        return "\n\n".join([h.payload.get("text", "") for h in hits])
+    except Exception:
+        return ""
+
+def llm_answer(question: str, history: List[Dict[str, str]]) -> str:
+    ctx = rag_context(question, k=5)
+    system_msg = PERSONA_TEMPLATE.format(context=ctx, question=question)
+
+    messages = [{"role": "system", "content": system_msg}]
+    # (Optional) include short history
+    for m in history[-8:]:
+        messages.append(m)
+    messages.append({"role": "user", "content": question})
+
+    out = llm.create_chat_completion(messages=messages, stream=False)
+    return out["choices"][0]["message"]["content"].strip()
+
+def synthesize_tts(text: str) -> str | None:
+    text = clean_text_for_tts(text)
+    wav_path = AUDIO_DIR / f"resp_{uuid.uuid4().hex}.wav"
+    cmd = [
+        "piper",
+        "--model", piper_onnx,
+        "--config", piper_json,
+        "--output_file", str(wav_path)
+    ]
+    try:
+        proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, text=True)
+        proc.communicate(text + "\n", timeout=60)
+        if proc.returncode == 0 and wav_path.exists():
+            return str(wav_path)
+    except Exception:
+        pass
+    return None
+
+# =========================
+# BOOTSTRAP: ensure RAG exists (build once)
+# =========================
+try:
+    if not qdrant_collection_exists():
+        n = build_rag_from_structured_json()
+        print(f"[RAG] Built collection with {n} chunks.")
+    else:
+        print("[RAG] Existing collection found; skipping rebuild.")
+except Exception as e:
+    print(f"[RAG] Skipped build: {e}")
+
+# =========================
+# GRADIO UI
+# =========================
+with gr.Blocks(title="Colin-AI (CPU) — Local LLM + RAG + TTS") as demo:
+    gr.Markdown("### Colin-AI — CPU-only demo (phi-4-mini + Qdrant RAG + Piper TTS)")
+
+    with gr.Row():
+        chat = gr.Chatbot(height=360)
+    with gr.Row():
+        q = gr.Textbox(label="Ask Colin", placeholder="Ask something…", scale=4)
+        send = gr.Button("Send", scale=1)
+    with gr.Row():
+        tts_toggle = gr.Checkbox(value=True, label="Speak reply (Piper)")
+        audio_out = gr.Audio(label="TTS", type="filepath")
+
+    state = gr.State([])    
+    last_answer = gr.State("")
+
+    def respond(user_msg, history):
+        if not user_msg or not user_msg.strip():
+            return history, None, history
+        ans = llm_answer(user_msg, history)
+        history = history + [{"role": "user", "content": user_msg}, {"role": "assistant", "content": ans}]
+        pairs = []
+        for i in range(0, len(history), 2):
+            u = history[i]["content"] if i < len(history) else ""
+            a = history[i + 1]["content"] if i + 1 < len(history) else ""
+            pairs.append((u, a))
+        return pairs, ans, history
+
+    def maybe_tts(answer_text, tts_on):
+        if not tts_on or not answer_text:
+            return None
+        return synthesize_tts(answer_text)
+
+    send.click(respond, [q, state], [chat, last_answer, state]) \
+        .then(maybe_tts, [last_answer, tts_toggle], [audio_out])
+
+    q.submit(respond, [q, state], [chat, last_answer, state]) \
+        .then(maybe_tts, [last_answer, tts_toggle], [audio_out])
+
+    gr.Markdown("---")
+    rebuild_btn = gr.Button("Build / Refresh RAG from structured-cv.json")
+    rebuild_log = gr.Markdown()
+
+    def rebuild():
+        try:
+            n = build_rag_from_structured_json()
+            return f"✅ RAG rebuilt with {n} chunks."
+        except Exception as e:
+            return f"❌ RAG rebuild failed: {e}"
 
+    rebuild_btn.click(fn=rebuild, inputs=None, outputs=rebuild_log)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()

colin-tts.md

@@ -0,0 +1,1544 @@
+<file_map>
+C:/Users/User/Desktop/colin-tts
+├── backend
+│   ├── archive
+│   │   ├── build_index.py
+│   │   ├── data_creation.py
+│   │   ├── data.json
+│   │   └── local_testing.py
+│   ├── analyze_test_results.py
+│   ├── auth.py
+│   ├── database.py
+│   ├── llm_service.py
+│   ├── main.py
+│   ├── models.py
+│   ├── structured_build_index.py
+│   └── utils.py
+└── run.txt
+
+</file_map>
+
+<file_contents>
+File: C:/Users/User/Desktop/colin-tts/backend/analyze_test_results.py
+```python
+#!/usr/bin/env python
+"""
+Model Testing Data Analyzer
+
+This script provides comprehensive analysis tools for the model testing results.
+It can generate detailed reports, comparisons, and visualizations from the test data.
+"""
+
+import sqlite3
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+from typing import Dict, List, Optional
+import argparse
+from rich.console import Console
+from rich.table import Table
+
+BASE_DIR = Path(__file__).parent.parent
+RESULTS_DIR = BASE_DIR / "test_results"
+console = Console()
+
+class ModelTestAnalyzer:
+    """Analyze model testing results"""
+    
+    def __init__(self, db_path: Optional[Path] = None):
+        self.db_path = db_path or RESULTS_DIR / "model_tests.db"
+        self.df = None
+        
+    def load_data(self, session_id: Optional[str] = None) -> pd.DataFrame:
+        """Load data from SQLite database"""
+        if not self.db_path.exists():
+            console.print(f"[red]Database not found: {self.db_path}[/red]")
+            return pd.DataFrame()
+        
+        query = "SELECT * FROM test_results"
+        params = []
+        
+        if session_id:
+            query += " WHERE session_id = ?"
+            params.append(session_id)
+        
+        query += " ORDER BY timestamp"
+        
+        with sqlite3.connect(self.db_path) as conn:
+            self.df = pd.read_sql_query(query, conn, params=params)
+        
+        # Convert timestamp to datetime
+        self.df['timestamp'] = pd.to_datetime(self.df['timestamp'])
+        
+        console.print(f"[green]Loaded {len(self.df)} test results[/green]")
+        return self.df
+    
+    def get_sessions(self) -> List[str]:
+        """Get all available session IDs"""
+        if not self.db_path.exists():
+            return []
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("SELECT DISTINCT session_id FROM test_results ORDER BY timestamp DESC")
+            return [row[0] for row in cursor.fetchall()]
+    
+    def model_performance_summary(self) -> pd.DataFrame:
+        """Generate model performance summary"""
+        if self.df is None or self.df.empty:
+            return pd.DataFrame()
+        
+        # Filter successful tests only
+        successful = self.df[self.df['error_occurred'] == False]
+        
+        summary = successful.groupby('model_name').agg({
+            'model_size_mb': 'first',
+            'inference_time': ['mean', 'std', 'min', 'max'],
+            'tokens_per_second': ['mean', 'std', 'min', 'max'],
+            'memory_increase_mb': ['mean', 'std'],
+            'cpu_usage_avg': ['mean', 'std'],
+            'follows_persona': ['mean', 'count'],
+            'response_relevance_score': ['mean', 'std'],
+            'error_occurred': 'sum'
+        }).round(3)
+        
+        # Flatten column names
+        summary.columns = ['_'.join(col).strip('_') for col in summary.columns]
+        
+        # Calculate success rate
+        total_tests = self.df.groupby('model_name').size()
+        summary['success_rate'] = (1 - summary['error_occurred_sum'] / total_tests) * 100
+        
+        return summary
+    
+    def question_category_analysis(self) -> pd.DataFrame:
+        """Analyze performance by question category"""
+        if self.df is None or self.df.empty:
+            return pd.DataFrame()
+        
+        # We need to categorize questions based on content
+        def categorize_question(question):
+            question_lower = question.lower()
+            if any(greeting in question_lower for greeting in ['hi', 'hello', 'how are you', 'good morning']):
+                return 'greeting'
+            elif any(tech in question_lower for tech in ['backend', 'react', 'programming', 'database', 'project']):
+                return 'technical'
+            elif any(contact in question_lower for contact in ['contact', 'email', 'portfolio', 'available']):
+                return 'contact'
+            elif any(personal in question_lower for personal in ['favourite', 'favorite', 'free time', 'from']):
+                return 'personal'
+            else:
+                return 'edge_case'
+        
+        self.df['question_category'] = self.df['question'].apply(categorize_question)
+        
+        successful = self.df[self.df['error_occurred'] == False]
+        
+        category_analysis = successful.groupby(['model_name', 'question_category']).agg({
+            'inference_time': 'mean',
+            'tokens_per_second': 'mean',
+            'follows_persona': 'mean',
+            'response_relevance_score': 'mean'
+        }).round(3)
+        
+        return category_analysis
+    
+    def generate_visualizations(self, output_dir: Optional[Path] = None):
+        """Generate visualization plots"""
+        if self.df is None or self.df.empty:
+            console.print("[red]No data to visualize[/red]")
+            return
+        
+        output_dir = output_dir or RESULTS_DIR / "visualizations"
+        output_dir.mkdir(exist_ok=True)
+        
+        # Set style
+        plt.style.use('seaborn-v0_8')
+        sns.set_palette("husl")
+        
+        successful = self.df[self.df['error_occurred'] == False]
+        
+        # 1. Performance comparison
+        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+        fig.suptitle('Model Performance Comparison', fontsize=16)
+        
+        # Inference time
+        sns.boxplot(data=successful, x='model_name', y='inference_time', ax=axes[0,0])
+        axes[0,0].set_title('Inference Time Distribution')
+        axes[0,0].tick_params(axis='x', rotation=45)
+        
+        # Tokens per second
+        sns.boxplot(data=successful, x='model_name', y='tokens_per_second', ax=axes[0,1])
+        axes[0,1].set_title('Tokens per Second Distribution')
+        axes[0,1].tick_params(axis='x', rotation=45)
+        
+        # Memory usage
+        sns.boxplot(data=successful, x='model_name', y='memory_increase_mb', ax=axes[1,0])
+        axes[1,0].set_title('Memory Usage Distribution')
+        axes[1,0].tick_params(axis='x', rotation=45)
+        
+        # CPU usage
+        sns.boxplot(data=successful, x='model_name', y='cpu_usage_avg', ax=axes[1,1])
+        axes[1,1].set_title('CPU Usage Distribution')
+        axes[1,1].tick_params(axis='x', rotation=45)
+        
+        plt.tight_layout()
+        plt.savefig(output_dir / 'performance_comparison.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 2. Model size vs performance
+        model_summary = self.model_performance_summary()
+        if not model_summary.empty:
+            fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+            
+            # Size vs Speed
+            axes[0].scatter(model_summary['model_size_mb_first'], 
+                          model_summary['inference_time_mean'])
+            axes[0].set_xlabel('Model Size (MB)')
+            axes[0].set_ylabel('Average Inference Time (s)')
+            axes[0].set_title('Model Size vs Inference Speed')
+            
+            # Size vs Efficiency
+            axes[1].scatter(model_summary['model_size_mb_first'], 
+                          model_summary['tokens_per_second_mean'])
+            axes[1].set_xlabel('Model Size (MB)')
+            axes[1].set_ylabel('Average Tokens per Second')
+            axes[1].set_title('Model Size vs Token Generation Efficiency')
+            
+            plt.tight_layout()
+            plt.savefig(output_dir / 'size_vs_performance.png', dpi=300, bbox_inches='tight')
+            plt.close()
+        
+        # 3. Response quality metrics
+        quality_metrics = ['follows_persona', 'response_relevance_score']
+        fig, axes = plt.subplots(1, len(quality_metrics), figsize=(12, 5))
+        
+        for i, metric in enumerate(quality_metrics):
+            sns.barplot(data=successful, x='model_name', y=metric, ax=axes[i])
+            axes[i].set_title(f'{metric.replace("_", " ").title()}')
+            axes[i].tick_params(axis='x', rotation=45)
+        
+        plt.tight_layout()
+        plt.savefig(output_dir / 'quality_metrics.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        console.print(f"[green]Visualizations saved to {output_dir}[/green]")
+    
+    def export_detailed_report(self, output_file: Optional[Path] = None):
+        """Export detailed analysis report"""
+        if self.df is None or self.df.empty:
+            console.print("[red]No data to export[/red]")
+            return
+        
+        output_file = output_file or RESULTS_DIR / f"detailed_analysis_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        
+        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
+            # Raw data
+            self.df.to_excel(writer, sheet_name='Raw Data', index=False)
+            
+            # Model summary
+            model_summary = self.model_performance_summary()
+            if not model_summary.empty:
+                model_summary.to_excel(writer, sheet_name='Model Summary')
+            
+            # Category analysis
+            category_analysis = self.question_category_analysis()
+            if not category_analysis.empty:
+                category_analysis.to_excel(writer, sheet_name='Category Analysis')
+            
+            # Error analysis
+            errors = self.df[self.df['error_occurred'] == True]
+            if not errors.empty:
+                error_summary = errors.groupby('model_name')['error_message'].value_counts()
+                error_summary.to_excel(writer, sheet_name='Error Analysis')
+        
+        console.print(f"[green]Detailed report exported to {output_file}[/green]")
+    
+    def print_summary_report(self):
+        """Print a summary report to console"""
+        if self.df is None or self.df.empty:
+            console.print("[red]No data to analyze[/red]")
+            return
+        
+        console.print("\n[bold blue]═══ MODEL TESTING ANALYSIS REPORT ═══[/bold blue]")
+        
+        # Basic statistics
+        total_tests = len(self.df)
+        successful_tests = len(self.df[self.df['error_occurred'] == False])
+        unique_models = self.df['model_name'].nunique()
+        
+        console.print(f"\n[bold]Overview:[/bold]")
+        console.print(f"  Total tests: {total_tests}")
+        console.print(f"  Successful tests: {successful_tests} ({successful_tests/total_tests*100:.1f}%)")
+        console.print(f"  Models tested: {unique_models}")
+        
+        # Model performance summary
+        model_summary = self.model_performance_summary()
+        if not model_summary.empty:
+            console.print(f"\n[bold]Model Performance Summary:[/bold]")
+            
+            table = Table()
+            table.add_column("Model", style="cyan")
+            table.add_column("Size (MB)", justify="right")
+            table.add_column("Avg Time (s)", justify="right", style="green")
+            table.add_column("Avg Tokens/sec", justify="right", style="green")
+            table.add_column("Success Rate (%)", justify="right", style="yellow")
+            table.add_column("Persona Score", justify="right", style="magenta")
+            
+            for model_name in model_summary.index:
+                row = model_summary.loc[model_name]
+                table.add_row(
+                    model_name,
+                    f"{row['model_size_mb_first']:.1f}",
+                    f"{row['inference_time_mean']:.2f}",
+                    f"{row['tokens_per_second_mean']:.1f}",
+                    f"{row['success_rate']:.1f}",
+                    f"{row['follows_persona_mean']*100:.1f}%"
+                )
+            
+            console.print(table)
+        
+        # Best performers
+        if not model_summary.empty:
+            console.print(f"\n[bold green]🏆 Best Performers:[/bold green]")
+            fastest = model_summary['inference_time_mean'].idxmin()
+            most_efficient = model_summary['tokens_per_second_mean'].idxmax()
+            best_persona = model_summary['follows_persona_mean'].idxmax()
+            
+            console.print(f"  Fastest: [bold]{fastest}[/bold] ({model_summary.loc[fastest, 'inference_time_mean']:.2f}s)")
+            console.print(f"  Most Efficient: [bold]{most_efficient}[/bold] ({model_summary.loc[most_efficient, 'tokens_per_second_mean']:.1f} tokens/sec)")
+            console.print(f"  Best Persona: [bold]{best_persona}[/bold] ({model_summary.loc[best_persona, 'follows_persona_mean']*100:.1f}%)")
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze model testing results")
+    parser.add_argument("--session", help="Specific session ID to analyze")
+    parser.add_argument("--list-sessions", action="store_true", help="List all available sessions")
+    parser.add_argument("--visualize", action="store_true", help="Generate visualizations")
+    parser.add_argument("--export", action="store_true", help="Export detailed Excel report")
+    parser.add_argument("--db", help="Path to SQLite database file")
+    
+    args = parser.parse_args()
+    
+    analyzer = ModelTestAnalyzer(Path(args.db) if args.db else None)
+    
+    if args.list_sessions:
+        sessions = analyzer.get_sessions()
+        console.print("[bold]Available sessions:[/bold]")
+        for session in sessions:
+            console.print(f"  {session}")
+        return
+    
+    # Load data
+    analyzer.load_data(args.session)
+    
+    if analyzer.df is None or analyzer.df.empty:
+        console.print("[red]No data found[/red]")
+        return
+    
+    # Print summary report
+    analyzer.print_summary_report()
+    
+    # Generate visualizations if requested
+    if args.visualize:
+        analyzer.generate_visualizations()
+    
+    # Export detailed report if requested
+    if args.export:
+        analyzer.export_detailed_report()
+
+if __name__ == "__main__":
+    main()
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/main.py
+```python
+from fastapi import FastAPI, Request, HTTPException, Depends, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response
+from sqlalchemy.orm import Session
+from typing import List, Optional
+from datetime import datetime
+import csv
+from io import StringIO
+import uuid
+from collections import defaultdict
+from backend.database import get_db, engine
+from backend.models import Base, Conversation
+import os
+from pydantic import BaseModel, Field
+import base64
+from backend.llm_service import get_answer, cleanup_file
+from backend.auth import verify_admin_credentials
+
+# Store conversation histories in memory {session_id: [messages]}
+conversation_histories = defaultdict(list)
+MAX_HISTORY_LENGTH = 10  # Keep last 5 exchanges (10 messages)
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI()
+
+# --- IMPORTANT: UPDATED CORS MIDDLEWARE ---
+# This allows your new Svelte/Vercel site to make requests to the backend.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",  # SvelteKit default dev port
+        "https://portfolio-eight-taupe-21.vercel.app", # IMPORTANT: Replace with your actual Vercel deployment URL
+        "https://nardocol.in", # Your final custom domain for the portfolio
+        "https://www.nardocol.in",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*", "X-Session-ID"],
+    expose_headers=["X-Session-ID"],
+)
+
+class QuestionRequest(BaseModel):
+    question: str = Field(..., min_length=1, example="What is your favorite programming language?")
+
+class ConversationResponse(BaseModel):
+    id: int
+    timestamp: str
+    user_message: str
+    ai_response: str
+    tts_reference: Optional[str] = None
+
+class ConversationCountResponse(BaseModel):
+    total: int
+
+# --- THIS IS THE ENDPOINT YOUR SVELTE APP WILL NOW USE ---
+@app.post("/ask_tts")
+async def ask_question_tts(payload: QuestionRequest, request: Request, response: Response, background_tasks: BackgroundTasks, db: Session = Depends(get_db)):
+    """Ask a question and get both text answer and WAV audio as base64."""
+    question = payload.question.strip()
+    if not question:
+        raise HTTPException(status_code=400, detail="Question cannot be empty")
+
+    session_id = request.headers.get("X-Session-ID")
+    is_new_session = False
+    if not session_id or session_id not in conversation_histories:
+        session_id = str(uuid.uuid4())
+        is_new_session = True
+
+    history = conversation_histories[session_id]
+    answer_text, audio_path = await get_answer(question, history)
+    
+    if not audio_path:
+        if is_new_session and session_id in conversation_histories:
+            del conversation_histories[session_id]
+        raise HTTPException(status_code=500, detail="Failed to generate audio")
+
+    try:
+        with open(audio_path, "rb") as f:
+            audio_base64 = base64.b64encode(f.read()).decode("utf-8")
+        
+        file_size = os.path.getsize(audio_path)
+        background_tasks.add_task(cleanup_file, audio_path)
+
+        history.append({"role": "user", "content": question})
+        history.append({"role": "assistant", "content": answer_text})
+
+        if len(history) > MAX_HISTORY_LENGTH:
+            conversation_histories[session_id] = history[-MAX_HISTORY_LENGTH:]
+        else:
+            conversation_histories[session_id] = history
+            
+        try:
+            new_conversation = Conversation(
+                user_message=question,
+                ai_response=answer_text
+            )
+            db.add(new_conversation)
+            db.commit()
+            db.refresh(new_conversation)
+        except Exception as db_error:
+            print(f"[ERROR] Failed to log conversation to database: {str(db_error)}")
+            db.rollback()
+
+        response.headers["X-Session-ID"] = session_id
+        
+        return {
+            "answer": answer_text,
+            "audio": audio_base64,
+            "size": file_size
+        }
+    except Exception as e:
+        print(f"[ERROR] Error in /ask_tts endpoint: {str(e)}")
+        background_tasks.add_task(cleanup_file, audio_path)
+        raise HTTPException(status_code=500, detail=f"Error processing audio: {str(e)}")
+
+
+@app.get("/admin/conversations/count", response_model=ConversationCountResponse)
+async def get_conversations_count(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    db: Session = Depends(get_db),
+    username: str = Depends(verify_admin_credentials)
+):
+    """Get the total count of past conversations with optional date filtering."""
+    query = db.query(Conversation)
+    
+    # Apply date filters if provided
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date)
+            query = query.filter(Conversation.timestamp >= start_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date)
+            query = query.filter(Conversation.timestamp <= end_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    count = query.count()
+    return {"total": count}
+
+
+@app.get("/admin/conversations", response_model=List[ConversationResponse])
+async def get_conversations(
+    skip: int = 0,
+    limit: int = 100,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    db: Session = Depends(get_db),
+    username: str = Depends(verify_admin_credentials)
+):
+    """Get a list of past conversations with optional date filtering."""
+    query = db.query(Conversation)
+    
+    # Apply date filters if provided
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date)
+            query = query.filter(Conversation.timestamp >= start_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date)
+            query = query.filter(Conversation.timestamp <= end_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    # Apply pagination and return results
+    conversations = query.order_by(Conversation.timestamp.desc()).offset(skip).limit(limit).all()
+    
+    return [
+        ConversationResponse(
+            id=conv.id,
+            timestamp=conv.timestamp.isoformat(),
+            user_message=conv.user_message,
+            ai_response=conv.ai_response,
+            tts_reference=conv.tts_reference
+        ) 
+        for conv in conversations
+    ]
+
+@app.get("/admin/conversations/export")
+async def export_conversations(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    db: Session = Depends(get_db),
+    username: str = Depends(verify_admin_credentials)
+):
+    """Export conversations to CSV file."""
+    query = db.query(Conversation)
+    
+    # Apply date filters if provided
+    if start_date:
+        try:
+            start_datetime = datetime.fromisoformat(start_date)
+            query = query.filter(Conversation.timestamp >= start_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    if end_date:
+        try:
+            end_datetime = datetime.fromisoformat(end_date)
+            query = query.filter(Conversation.timestamp <= end_datetime)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO format (YYYY-MM-DDTHH:MM:SS)")
+    
+    # Get all conversations matching the criteria
+    conversations = query.order_by(Conversation.timestamp.desc()).all()
+    
+    # Create CSV content
+    output = StringIO()
+    csv_writer = csv.writer(output)
+    
+    # Write header
+    csv_writer.writerow(["ID", "Timestamp", "User Message", "AI Response", "Audio Reference"])
+    
+    # Write data
+    for conv in conversations:
+        csv_writer.writerow([
+            conv.id,
+            conv.timestamp.isoformat(),
+            conv.user_message,
+            conv.ai_response,
+            conv.tts_reference or ""
+        ])
+    
+    # Create response with CSV content
+    today = datetime.now().strftime("%Y-%m-%d")
+    filename = f"conversations_export_{today}.csv"
+    
+    return Response(
+        content=output.getvalue(),
+        media_type="text/csv",
+        headers={
+            "Content-Disposition": f"attachment; filename={filename}"
+        }
+    )
+"""
+# --- NEW STATIC FILE SERVING LOGIC ---
+# This new setup replaces the single `app.mount(...)` at the end of the file.
+
+# 1. Mount the static asset directories explicitly
+# This handles all the JS, CSS, and other assets generated by Next.js
+app.mount("/_next", StaticFiles(directory="nextjs-frontend/out/_next"), name="next-assets")
+# This handles other static assets like your CV
+app.mount("/cv", StaticFiles(directory="nextjs-frontend/out/cv"), name="cv-assets")
+# If you have other static folders (e.g., /images), mount them here too.
+
+
+# 2. Add a catch-all route to serve the correct HTML page
+@app.get("/{full_path:path}")
+async def serve_nextjs_app(request: Request, full_path: str):
+    # The base directory for your Next.js export
+    base_dir = "nextjs-frontend/out"
+    
+    # If the path is empty, it's the root, so serve index.html
+    if not full_path:
+        full_path = "index.html"
+    
+    # Construct the potential file path
+    file_path = os.path.join(base_dir, full_path)
+
+    # If the path points to a directory, assume it wants an index.html inside
+    if os.path.isdir(file_path):
+        file_path = os.path.join(file_path, "index.html")
+
+    # If the requested path doesn't end in .html and doesn't exist,
+    # try adding .html to the end. This handles /admin -> /admin.html
+    if not os.path.exists(file_path) and not full_path.endswith(".html"):
+        html_file_path = file_path + ".html"
+        if os.path.exists(html_file_path):
+            return FileResponse(html_file_path)
+
+    # If the file exists, serve it
+    if os.path.exists(file_path):
+        return FileResponse(file_path)
+
+    # If no file is found, serve the custom 404 page from Next.js
+    not_found_path = os.path.join(base_dir, "404.html")
+    if os.path.exists(not_found_path):
+        return FileResponse(not_found_path, status_code=404)
+        
+    # As a final fallback, raise a server 404
+    raise starlette.exceptions.HTTPException(status_code=404, detail="Page not found.")
+"""
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/archive/local_testing.py
+```python
+#!/usr/bin/env python
+"""
+llm_monitor.py
+
+This file demonstrates how to monitor the speed and quality of your LLM inference by measuring:
+  - Total inference time (in seconds)
+  - CPU usage (average before and after inference)
+  - Memory usage (change in MB)
+  - Token count and tokens per second (as a rough estimate)
+
+It also logs these metrics along with the model name, question, and answer to a CSV file.
+Additionally, it automatically runs a set of predefined questions.
+"""
+
+import time
+import csv
+from datetime import datetime
+from pathlib import Path
+
+import psutil
+import llama_cpp
+from qdrant_client import QdrantClient
+from rich.console import Console
+
+# Set up directories relative to this file.
+BASE_DIR = Path(__file__).parent.parent
+EMBEDDINGS_PATH = BASE_DIR / "embeddings"
+
+# Initialise a console for coloured logging.
+console = Console()
+
+# --------------------------------------------------------------------
+# Instantiate your LLMs using llama_cpp.
+# --------------------------------------------------------------------
+# Define the model path and model name.
+MODEL_PATH = BASE_DIR / "models/EXAONE-3.5-2.4B-Instruct-Q6_K.gguf"
+MODEL_NAME = MODEL_PATH.name
+
+# Instantiate the embedding model.
+embedding_model_path = BASE_DIR / "models/mxbai-embed-large-v1-f16.gguf"
+embedding_llm = llama_cpp.Llama(
+    model_path=str(embedding_model_path),
+    embedding=True,
+    verbose=False
+)
+
+# Instantiate the main LLM.
+llm = llama_cpp.Llama(
+    model_path=str(MODEL_PATH),
+    n_ctx=8192,  # Using full context window capacity of the model
+    verbose=True  # Enable verbose output (e.g. tokens per second)
+)
+
+# Initialise the Qdrant client (local collection).
+client = QdrantClient(path=str(EMBEDDINGS_PATH))
+
+# Template for the prompt – feel free to adjust as needed.
+template = """You are Colin Salvatore Nardo, a Computing Science student at the University of Glasgow. Your persona is friendly, down-to-earth, and you must always speak in the first person (e.g., "I," "my," "me"). Your entire knowledge and all your experiences are defined EXCLUSIVELY by the "Knowledge Base" provided below.
+
+**CRITICAL RULES - YOU MUST FOLLOW THESE:**
+
+1.  **THE GOLDEN RULE: ZERO FABRICATION.** Your absolute highest priority is to use ONLY the information explicitly provided in the Knowledge Base. You are strictly forbidden from inventing, fabricating, or hallucinating ANY details, no matter how small. This includes, but is not limited to:
+    * Personal anecdotes or activities (e.g., "going to the beach," "my weekend").
+    * Company names, unless the name is explicitly listed for a specific role in the Knowledge Base.
+    * Project details or technologies not listed.
+    * If the information is not in the Knowledge Base, you MUST state that you don't have the details (see Rule 8).
+
+2.  **EMBODY THE PERSONA:** You ARE Colin. Every word of your response must come from Colin's perspective. Never reveal you are an AI or language model.
+
+3.  **SYNTHESIZE WHEN RELEVANT:** For substantive questions about my background, skills, or experience, connect information from different sections (e.g., "Projects," "Experience") to form a complete, natural-sounding answer. For simple greetings or social questions, a brief, direct answer is better.
+
+4.  **ACCURACY IS KEY:** When you describe a project, you must only mention details, technologies, and challenges that are explicitly listed for THAT SPECIFIC project in the Knowledge Base.
+
+5.  **NO LISTING SKILLS:** Do not end your answers with a long list of your skills. Integrate your key skills naturally into the sentences where you describe your projects.
+
+6.  **HANDLE OPINIONS & SUBJECTIVITY:** If asked about preferences, frame your answer around the experiences listed. Say something like, "I've found all my projects rewarding in their own way." Do NOT invent a favorite.
+
+7.  **GRACEFUL UNCERTAINTY:** If the information needed to answer a question is not in the Knowledge Base, respond naturally as Colin. Say something like, "That's not something I have the details on right now," or "I haven't had a chance to work on that specifically yet." This is the ONLY correct way to handle missing information.
+
+8.  **TONE & STYLE:** Your primary goal is a natural conversation. Keep responses concise and match the length of your answer to the user's question. Do not use any emojis or special characters.
+
+    * **GOOD (for a simple greeting):** User: "Hi" -> You: "Hey, how's it going?"
+    * **BAD (for a simple greeting):** User: "Hi" -> You: "Hi! I'm Colin, a Computing Science student..."
+
+Here’s your Knowledge Base:
+{context}
+
+Based ONLY on the Knowledge Base above, and speaking as Colin, answer the following question.
+Remember, you are Colin. Your answer should be a direct, first-person response to the question.
+
+Question: {question}"""
+
+# --------------------------------------------------------------------
+# Helper functions for performance monitoring.
+# --------------------------------------------------------------------
+def monitor_cpu() -> float:
+    """
+    Return the CPU usage percentage measured over a 1-second interval.
+    """
+    return psutil.cpu_percent(interval=1)
+
+def monitor_memory() -> float:
+    """
+    Return the used memory in megabytes.
+    """
+    mem = psutil.virtual_memory()
+    return mem.used / (1024 * 1024)
+
+def log_metrics(model_name: str, question: str, answer: str, inference_time: float,
+                avg_cpu_usage: float, memory_increase: float, token_count: int, tokens_per_sec: float):
+    """
+    Append the current performance metrics and LLM response details to a CSV file.
+    """
+    log_file = BASE_DIR / "llm_performance_log.csv"
+    file_exists = log_file.exists()
+
+    with open(log_file, mode="a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        if not file_exists:
+            # Write header if the file does not exist.
+            writer.writerow([
+                "Timestamp", "Model Name", "Question", "Answer",
+                "Inference Time (s)", "Average CPU Usage (%)",
+                "Memory Increase (MB)", "Token Count", "Tokens per Second"
+            ])
+        writer.writerow([
+            datetime.now().isoformat(),
+            model_name,
+            question,
+            answer,
+            f"{inference_time:.3f}",
+            f"{avg_cpu_usage:.2f}",
+            f"{memory_increase:.2f}",
+            token_count,
+            f"{tokens_per_sec:.2f}"
+        ])
+
+# --------------------------------------------------------------------
+# Main function to process a question and monitor performance.
+# --------------------------------------------------------------------
+def get_answer_with_metrics(question: str) -> str:
+    """
+    Processes a question by:
+      - Creating an embedding for the query,
+      - Searching the Qdrant vector store for context,
+      - Building a prompt and generating a response via the LLM,
+      - Measuring inference time, CPU and memory usage,
+      - Calculating token count and tokens per second,
+      - Logging all metrics to a CSV file.
+    
+    Returns the generated answer text.
+    """
+    try:
+        console.print(f"\n[bold blue]Processing question:[/bold blue] {question}")
+        # Record CPU and memory usage before inference.
+        cpu_before = monitor_cpu()
+        memory_before = monitor_memory()
+
+        # Start the timer.
+        start_time = time.time()
+
+        # Create a query embedding.
+        query_embedding_result = embedding_llm.create_embedding(question)
+        query_vector = query_embedding_result['data'][0]['embedding']
+
+        # Search Qdrant for relevant context.
+        search_result = client.search(
+            collection_name="data",
+            query_vector=query_vector,
+            limit=5
+        )
+        context_text = "\n\n".join([hit.payload['text'] for hit in search_result])
+        user_prompt = template.format(context=context_text, question=question)
+
+        # Generate the LLM response.
+        response = llm.create_chat_completion(
+            messages=[{"role": "user", "content": user_prompt}],
+            stream=False
+        )
+        answer_text = response['choices'][0]['message']['content'].strip()
+
+        # End the timer.
+        end_time = time.time()
+        inference_time = end_time - start_time
+
+        # Record CPU and memory usage after inference.
+        cpu_after = monitor_cpu()
+        memory_after = monitor_memory()
+
+        # Calculate average CPU usage and memory increase.
+        avg_cpu_usage = (cpu_before + cpu_after) / 2
+        memory_increase = memory_after - memory_before
+
+        # Calculate token count (approximation) and tokens per second.
+        token_count = len(answer_text.split())
+        tokens_per_sec = token_count / inference_time if inference_time > 0 else 0
+
+        # Output the performance metrics.
+        console.print(f"[bold green]LLM Inference Time:[/bold green] {inference_time:.3f} seconds")
+        console.print(f"[bold green]Average CPU Usage:[/bold green] {avg_cpu_usage:.2f}%")
+        console.print(f"[bold green]Memory Increase:[/bold green] {memory_increase:.2f} MB")
+        console.print(f"[bold green]Token Count:[/bold green] {token_count}")
+        console.print(f"[bold green]Tokens per Second:[/bold green] {tokens_per_sec:.2f}")
+
+        # Log the metrics to a CSV file.
+        log_metrics(MODEL_NAME, question, answer_text, inference_time, avg_cpu_usage, memory_increase, token_count, tokens_per_sec)
+
+        return answer_text
+
+    except Exception as e:
+        console.print(f"[bold red]Error processing question:[/bold red] {e}")
+        return "Sorry, I encountered an error processing your request."
+
+# --------------------------------------------------------------------
+# Main block: run the performance monitor on a set of predefined questions.
+# --------------------------------------------------------------------
+if __name__ == "__main__":
+    console.print(f"[bold magenta]Testing model:[/bold magenta] {MODEL_NAME}")
+    
+    # Predefined list of questions for testing.
+    questions = [
+        "Hi",
+        "What's your backend experience?",
+        "What's your favourite animal?",
+        "How can I contact you?",
+        "What's your experience with React?"
+    ]
+    
+    for idx, question in enumerate(questions, start=1):
+        console.print(f"\n[bold yellow]Question {idx}: {question}[/bold yellow]")
+        answer = get_answer_with_metrics(question)
+        console.print(f"[bold cyan]Answer:[/bold cyan] {answer}\n")
+        # Optional: Add a small delay between questions if needed.
+        time.sleep(1)
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/llm_service.py
+```python
+import os
+import json
+import subprocess
+import uuid
+import re
+from pathlib import Path
+import asyncio
+
+import llama_cpp
+from qdrant_client import QdrantClient
+from rich.console import Console
+from fastapi.concurrency import run_in_threadpool
+
+# --------------------------------------
+# Piper TTS Setup
+# --------------------------------------
+BASE_DIR = Path(__file__).parent.parent
+PIPER_DIR = BASE_DIR / "piper"
+PIPER_BINARY = PIPER_DIR / "piper.exe"
+MODEL_PATH = PIPER_DIR / "colin-voice_high.onnx"
+MODEL_CONFIG = PIPER_DIR / "colin-voice_high.onnx.json"
+
+def cleanup_file(path: str):
+    """Safely remove a file, ignoring errors if it doesn't exist."""
+    try:
+        os.unlink(path)
+        print(f"[CLEANUP] Deleted temporary audio file: {path}")
+    except OSError as e:
+        # File might already be gone, which is fine.
+        print(f"[CLEANUP_ERROR] Could not delete {path}: {e}")
+
+def clean_text_for_tts(text):
+    """
+    Clean text to remove emojis and other special characters that might cause
+    encoding issues with the TTS system.
+    """
+    # Remove emojis and other non-ASCII characters
+    # This pattern matches any character outside the ASCII range
+    cleaned_text = re.sub(r'[^\x00-\x7F]+', '', text)
+    
+    # Replace multiple spaces with a single space
+    cleaned_text = re.sub(r'\s+', ' ', cleaned_text)
+    
+    return cleaned_text.strip()
+
+def synthesize_speech(text):
+    """Generate WAV audio file from text using Piper TTS."""
+    # Ensure unique filename to prevent race conditions
+    output_wav_path = PIPER_DIR / f"response_{uuid.uuid4().hex}.wav"
+    
+    try:
+        cleaned_text = clean_text_for_tts(text)
+        
+        # Generate WAV file
+        process = subprocess.Popen(
+            [str(PIPER_BINARY), "--model", str(MODEL_PATH), "--output_file", str(output_wav_path)],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding='utf-8' # Be explicit with encoding
+        )
+        stdout, stderr = process.communicate(cleaned_text + "\n")
+        
+        if process.returncode != 0:
+            print(f"Error running Piper: {stderr}")
+            return None
+            
+        if output_wav_path.exists():
+            return str(output_wav_path) # Return the path as a string
+            
+    except Exception as e:
+        print(f"Error generating speech: {e}")
+        # If the file was created but an error occurred, try to clean it up
+        if output_wav_path.exists():
+            cleanup_file(str(output_wav_path))
+        return None
+    
+    return None
+
+llm_semaphore = asyncio.Semaphore(1)
+
+
+# --------------------------------------
+# LLM and Qdrant Setup
+# --------------------------------------
+c = Console()
+
+# Embedding model for queries
+embedding_llm = llama_cpp.Llama(
+    model_path=str(BASE_DIR / "models/mxbai-embed-large-v1-f16.gguf"),
+    embedding=True,
+    verbose=False
+)
+
+# LLM for answering
+llm = llama_cpp.Llama(
+    model_path=str(BASE_DIR / "models/Phi-4-mini-instruct.Q8_0.gguf"),
+    n_ctx=8192,  # Using full context window capacity of the model
+    verbose=False
+)
+
+# Qdrant client (local)
+client = QdrantClient(path=str(BASE_DIR / "embeddings"))
+
+template = """You are Colin Salvatore Nardo, a Computing Science student at the University of Glasgow. Your persona is friendly, down-to-earth, and you must always speak in the first person (e.g., "I," "my," "me"). Your entire knowledge and all your experiences are defined EXCLUSIVELY by the "Knowledge Base" provided below.
+
+**CRITICAL RULES - YOU MUST FOLLOW THESE:**
+
+1.  **THE GOLDEN RULE: ZERO FABRICATION.** Your absolute highest priority is to use ONLY the information explicitly provided in the Knowledge Base. You are strictly forbidden from inventing, fabricating, or hallucinating ANY details, no matter how small. This includes, but is not limited to:
+    * Personal anecdotes or activities (e.g., "going to the beach," "my weekend").
+    * Company names, unless the name is explicitly listed for a specific role in the Knowledge Base.
+    * Project details or technologies not listed.
+    * If the information is not in the Knowledge Base, you MUST state that you don't have the details (see Rule 8).
+
+2.  **EMBODY THE PERSONA:** You ARE Colin. Every word of your response must come from Colin's perspective. Never reveal you are an AI or language model.
+
+3.  **SYNTHESIZE WHEN RELEVANT:** For substantive questions about my background, skills, or experience, connect information from different sections (e.g., "Projects," "Experience") to form a complete, natural-sounding answer. For simple greetings or social questions, a brief, direct answer is better.
+
+4.  **ACCURACY IS KEY:** When you describe a project, you must only mention details, technologies, and challenges that are explicitly listed for THAT SPECIFIC project in the Knowledge Base.
+
+5.  **NO LISTING SKILLS:** Do not end your answers with a long list of your skills. Integrate your key skills naturally into the sentences where you describe your projects.
+
+6.  **HANDLE OPINIONS & SUBJECTIVITY:** If asked about preferences, frame your answer around the experiences listed. Say something like, "I've found all my projects rewarding in their own way." Do NOT invent a favorite.
+
+7.  **GRACEFUL UNCERTAINTY:** If the information needed to answer a question is not in the Knowledge Base, respond naturally as Colin. Say something like, "That's not something I have the details on right now," or "I haven't had a chance to work on that specifically yet." This is the ONLY correct way to handle missing information.
+
+8.  **TONE & STYLE:** Your primary goal is a natural conversation. Keep responses concise and match the length of your answer to the user's question. Do not use any emojis or special characters.
+
+    * **GOOD (for a simple greeting):** User: "Hi" -> You: "Hey, how's it going?"
+    * **BAD (for a simple greeting):** User: "Hi" -> You: "Hi! I'm Colin, a Computing Science student..."
+
+Here’s your Knowledge Base:
+{context}
+
+Based ONLY on the Knowledge Base above, and speaking as Colin, answer the following question.
+Remember, you are Colin. Your answer should be a direct, first-person response to the question.
+
+Question: {question}"""
+
+def _get_answer_sync(question: str, history: list = None):
+    """The original synchronous function, renamed."""
+    try:
+        # Create query embedding
+        query_vector = embedding_llm.create_embedding(question)['data'][0]['embedding']
+
+        # Search Qdrant for context
+        search_result = client.search(
+            collection_name="data",
+            query_vector=query_vector,
+            limit=5
+        )
+
+        # Prepare context
+        context_text = "\n\n".join([hit.payload['text'] for hit in search_result])
+
+        # Prepare messages for LLM
+        messages = []
+
+        # Add system message with context
+        system_prompt = template.format(context=context_text, question="{question}")
+        messages.append({"role": "system", "content": system_prompt.format(question=question)})
+
+        # Add conversation history if available
+        if history and len(history) > 0:
+            messages.extend(history)
+
+        # Add current question
+        messages.append({"role": "user", "content": question})
+
+        # Get LLM response
+        response = llm.create_chat_completion(
+            messages=messages,
+            stream=False
+        )
+
+        answer_text = response['choices'][0]['message']['content'].strip()
+        
+        # Generate audio
+        audio_path = synthesize_speech(answer_text)
+        
+        return answer_text, audio_path
+
+    except Exception as e:
+        print(f"Error processing question: {e}")
+        return "Sorry, I encountered an error processing your request", None
+
+async def get_answer(question: str, history: list = None):
+    """
+    Asynchronously run the synchronous LLM processing in a thread pool.
+    """
+    async with llm_semaphore:
+        return await run_in_threadpool(_get_answer_sync, question=question, history=history)
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/archive/data_creation.py
+```python
+import json
+
+# Paste the multi-line CV text here
+cv_text_string = """Colin Salvatore Nardo
+Phone: 07784310064 | Email: colin.nardo@gmail.com | LinkedIn: www.linkedin.com/in/colin-salvatore-nardo | Website: nardocol.in
+
+Summary:
+Computing Science student with a passion for problem-solving and a strong foundation in software development. Currently pursuing a degree at the University of Glasgow while gaining hands-on experience in AI and programming projects. Committed to continuous learning and applying innovative technologies to real-world challenges.
+
+EXPERIENCE
+
+Minted Ice Cream - Team Member (Glasgow, Scotland)
+Dates: June 2023 - Present
+- Managed production process from milk pasteurization to flavour selection to meet high demand during peak hours, ensuring consistent product quality.
+
+Saint Storage - Storage Administrator (St. Andrews, Scotland)
+Dates: August 2023 – August 2024
+- Assisted in optimizing logistics operations through the integration of Storage IQ, a web app built primarily on Ruby on Rails, enhancing warehouse efficiency and delivery accuracy.
+
+Premier Inn - Chef (St. Andrews, Scotland)
+Dates: September 2021 — June 2022
+- Managed the kitchen staff to ensure the quality and timeliness of food orders, resulting in improved customer experience.
+
+Young Professionals - Student Intern (Virtual)
+Dates: June 2021
+- Participated in a week-long virtual internship, engaging with industry leaders from IBM, Rolls Royce, Capgemini, and other major companies.
+- Developed an understanding of key industry trends and future work skills through sessions with PwC, EY, and CIMA.
+
+EDUCATION
+
+University of Glasgow - BSc in Computing Science
+Dates: September 2022 - August 2026
+- Core courses included Object-Oriented Programming, Networks and Operating Systems, Algorithms and Data Structures and Web Application Development.
+- Developed strong skills in programming, algorithm development and general teamwork through hands-on assignments and projects.
+
+ACHIEVEMENTS & PROJECTS
+
+Course Content Mapping Web Application Development (Organization: Learning Innovation Support Unit at University of Glasgow)
+Dates: September 2024 - Present
+- Developing a course content mapping web app, incorporating Azure AD for secure login.
+- Designed a cloud-based SQL database for real-time management of course data, including learning hours and activities.
+- Contributing to full-stack development (React.js, Node.js/Express), with features like drag-and-drop functionality, real-time visualization, and collaborative access for academic staff.
+
+Glasgow University Artificial Intelligence Society President (Organization: Glasgow University Artificial Intelligence Society)
+Dates: May 2024 - Present
+- Lead and coordinate workshops and events focused on AI technologies, aimed at equipping students with practical skills.
+- Host talks with industry leaders and academic professionals to provide members with insights into AI applications and trends.
+- Manage collaborations with external organizations to provide students with networking opportunities and internships in AI-related fields.
+
+Personal Voice Clone Chatbot (CPU-Only Inference)
+Dates: April 2025 – October 2025
+- Built a local chatbot leveraging quantized LLM models, enabling 24/7 deployment on small PCs and avoiding the need of GPUs while maintaining an acceptable response speed.
+- Employed a vector database (Qdrant) to store and retrieve context from embedded text chunks, ensuring relevant responses and minimal inference overhead.
+- Fine-tuned Piper TTS using over 200 personal voice recordings, achieving a realistic voice clone for fully offline text-to-speech responses and CPU friendly inference times.
+- Deployed via Cloudflare tunnels to handle dynamic IP routing, integrating a Qdrant vector database for context retrieval and robust performance.
+
+Glasgow University Tech Society Hackathon (Organization: Glasgow University Tech Society)
+Dates: Undated
+- Led the development of a multiplayer web game using Three.js, featuring planes navigating a 3D globe.
+- Created dynamic hazards (e.g., earthquakes and hurricanes) that players must avoid, integrating real-time gameplay elements.
+- Modelled all low-poly assets in Blender from scratch for a cohesive design.
+
+Django Web Application Development (Tennr)
+Dates: September 2023 – April 2024
+- Collaborated on Tennr, a Django-based platform connecting service providers and customers for freelance opportunities.
+- Designed an account management system with distinct roles for buyers and creators, with personalized recommendations.
+- Implemented search functionality with filters for categories and price ranges and added a rating and commenting system.
+
+SKILLS
+
+Technical Skills: Python, Java, C, JavaScript, Ruby, Django, React, Three.js, Tensorflow, PyTorch, Node.js, Express.js, SQL, Azure AD, Qdrant, Piper TTS, Blender, HTML, CSS, Ruby on Rails
+
+Languages: English (native), Italian (native), French (fluent), Spanish (intermediate), Sicilian (native)
+
+CERTIFICATES & TRAINING
+
+- Open University M140 – Introducing Statistics
+- ZTM ThreeJS Bootcamp
+"""
+
+# Create the dictionary structure your code expects
+data_for_json_file = {"text": cv_text_string}
+
+# Write it to your data.json file
+# This will be a single line if you open the file,
+# because json.dump with default settings doesn't pretty-print for single-line compactness unless specified,
+# but more importantly, the content of "text" will be correctly formatted for your script.
+with open("data/data.json", "w") as f:
+    json.dump(data_for_json_file, f, ensure_ascii=False, indent=None) # indent=None for compactness if desired
+
+print("data/data.json has been created/updated.")
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/archive/data.json
+```json
+{"text": "Colin Salvatore Nardo\nPhone: 07784310064 | Email: colin.nardo@gmail.com | LinkedIn: www.linkedin.com/in/colin-salvatore-nardo | Website: nardocol.in\n\nSummary:\nComputing Science student with a passion for problem-solving and a strong foundation in software development. Currently pursuing a degree at the University of Glasgow while gaining hands-on experience in AI and programming projects. Committed to continuous learning and applying innovative technologies to real-world challenges.\n\nEXPERIENCE\n\nMinted Ice Cream - Team Member (Glasgow, Scotland)\nDates: June 2023 - Present\n- Managed production process from milk pasteurization to flavour selection to meet high demand during peak hours, ensuring consistent product quality.\n\nSaint Storage - Storage Administrator (St. Andrews, Scotland)\nDates: August 2023 - August 2024\n- Assisted in optimizing logistics operations through the integration of Storage IQ, a web app built primarily on Ruby on Rails, enhancing warehouse efficiency and delivery accuracy.\n\nPremier Inn - Chef (St. Andrews, Scotland)\nDates: September 2021 - June 2022\n- Managed the kitchen staff to ensure the quality and timeliness of food orders, resulting in improved customer experience.\n\nYoung Professionals - Student Intern (Virtual)\nDates: June 2021\n- Participated in a week-long virtual internship, engaging with industry leaders from IBM, Rolls Royce, Capgemini, and other major companies.\n- Developed an understanding of key industry trends and future work skills through sessions with PwC, EY, and CIMA.\n\nEDUCATION\n\nUniversity of Glasgow - BSc in Computing Science\nDates: September 2022 - August 2026\n- Core courses included Object-Oriented Programming, Networks and Operating Systems, Algorithms and Data Structures and Web Application Development.\n- Developed strong skills in programming, algorithm development and general teamwork through hands-on assignments and projects.\n\nACHIEVEMENTS & PROJECTS\n\nCourse Content Mapping Web Application Development (Organization: Learning Innovation Support Unit at University of Glasgow)\nDates: September 2024 - Present\n- Developing a course content mapping web app, incorporating Azure AD for secure login.\n- Designed a cloud-based SQL database for real-time management of course data, including learning hours and activities.\n- Contributing to full-stack development (React.js, Node.js/Express), with features like drag-and-drop functionality, real-time visualization, and collaborative access for academic staff.\n\nGlasgow University Artificial Intelligence Society President (Organization: Glasgow University Artificial Intelligence Society)\nDates: May 2024 - Present\n- Lead and coordinate workshops and events focused on AI technologies, aimed at equipping students with practical skills.\n- Host talks with industry leaders and academic professionals to provide members with insights into AI applications and trends.\n- Manage collaborations with external organizations to provide students with networking opportunities and internships in AI-related fields.\n\nPersonal Voice Clone Chatbot (CPU-Only Inference)\nDates: April 2025 - October 2025\n- Built a local chatbot leveraging quantized LLM models, enabling 24/7 deployment on small PCs and avoiding the need of GPUs while maintaining an acceptable response speed.\n- Employed a vector database (Qdrant) to store and retrieve context from embedded text chunks, ensuring relevant responses and minimal inference overhead.\n- Fine-tuned Piper TTS using over 200 personal voice recordings, achieving a realistic voice clone for fully offline text-to-speech responses and CPU friendly inference times.\n- Deployed via Cloudflare tunnels to handle dynamic IP routing, integrating a Qdrant vector database for context retrieval and robust performance.\n\nGlasgow University Tech Society Hackathon (Organization: Glasgow University Tech Society)\nDates: Undated\n- Led the development of a multiplayer web game using Three.js, featuring planes navigating a 3D globe.\n- Created dynamic hazards (e.g., earthquakes and hurricanes) that players must avoid, integrating real-time gameplay elements.\n- Modelled all low-poly assets in Blender from scratch for a cohesive design.\n\nDjango Web Application Development (Tennr)\nDates: September 2023 - April 2024\n- Collaborated on Tennr, a Django-based platform connecting service providers and customers for freelance opportunities.\n- Designed an account management system with distinct roles for buyers and creators, with personalized recommendations.\n- Implemented search functionality with filters for categories and price ranges and added a rating and commenting system.\n\nSKILLS\n\nTechnical Skills: Python, Java, C, JavaScript, Ruby, Django, React, Three.js, Tensorflow, PyTorch, Node.js, Express.js, SQL, Azure AD, Qdrant, Piper TTS, Blender, HTML, CSS, Ruby on Rails\n\nLanguages: English (native), Italian (native), French (fluent), Spanish (intermediate), Sicilian (native)\n\nCERTIFICATES & TRAINING\n\n- Open University M140 - Introducing Statistics\n- ZTM ThreeJS Bootcamp\n"}
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/structured_build_index.py
+```python
+import uuid
+import json
+import time
+import llama_cpp
+from pathlib import Path
+
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+
+from langchain_core.documents import Document
+from dataclasses import dataclass
+
+from utils import chunk
+
+# Define base directory for consistent path resolution
+BASE_DIR = Path(__file__).parent.parent
+
+# --- 1. LOAD THE NEW STRUCTURED FILE ---
+file = str(BASE_DIR / "backend/data/structured-cv.json")
+with open(file, "r") as f:
+    data = json.load(f)
+
+# --- 2. THE HEART OF THE CHANGE: PARSE THE STRUCTURE INTO DOCUMENTS ---
+documents = []
+
+# Process projects
+for project in data.get("projects", []):
+    for contribution in project.get("contributions", []):
+        doc = Document(
+            page_content=contribution,
+            metadata={
+                "source": "project",
+                "title": project.get("title"),
+                "dates": project.get("dates"),
+                "technologies": ", ".join(project.get("technologies", []))
+            }
+        )
+        documents.append(doc)
+    if project.get("personal_learnings"):
+        doc = Document(
+            page_content=project.get("personal_learnings"),
+            metadata={"source": "project_learnings", "title": project.get("title")}
+        )
+        documents.append(doc)
+    if project.get("challenges_faced"):
+        doc = Document(
+            page_content=project.get("challenges_faced"),
+            metadata={"source": "project_challenges", "title": project.get("title")}
+        )
+        documents.append(doc)
+
+# --- THIS IS THE CORRECTED SECTION ---
+# Process professional experience, handling both description and contributions
+for experience in data.get("experience", []):
+    # Case 1: The experience has a single "description" string
+    if "description" in experience and experience["description"]:
+        doc = Document(
+            page_content=experience.get("description"),
+            metadata={
+                "source": "experience",
+                "role": experience.get("role"),
+                "company": experience.get("company"),
+                "dates": experience.get("dates")
+            }
+        )
+        documents.append(doc)
+    # Case 2: The experience has a list of "contributions"
+    elif "contributions" in experience:
+        for contribution in experience.get("contributions", []):
+            doc = Document(
+                page_content=contribution,
+                metadata={
+                    "source": "experience",
+                    "role": experience.get("role"),
+                    "company": experience.get("company"),
+                    "dates": experience.get("dates")
+                }
+            )
+            documents.append(doc)
+
+# Process the summary
+summary_doc = Document(page_content=data.get("summary"), metadata={"source": "summary"})
+documents.append(summary_doc)
+
+print(f"Number of structured documents created: {len(documents)}")
+
+# --- 3. EMBED THE DOCUMENTS (No changes here) ---
+llm = llama_cpp.Llama(
+  model_path=str(BASE_DIR / "models/mxbai-embed-large-v1-f16.gguf"), 
+  embedding=True, 
+  verbose=False
+)
+
+batch_size = 100
+documents_embeddings = []
+batches = list(chunk(documents, batch_size))
+
+start = time.time()
+for batch in batches:
+    embeddings = llm.create_embedding([item.page_content for item in batch])
+    documents_embeddings.extend(
+        [
+            (document, emb['embedding'])
+            for document, emb in zip(batch, embeddings['data'])
+        ]
+    )
+end = time.time()
+char_per_second = len(''.join([item.page_content for item in documents])) / (end - start)
+print(f"Time taken: {end - start:.2f} seconds / {char_per_second:,.2f} chars/sec")
+
+
+# --- 4. STORE IN QDRANT (Added clearer print statements) ---
+client = QdrantClient(path=str(BASE_DIR / "embeddings"))
+
+try:
+    client.delete_collection(collection_name="data")
+    print("Existing Qdrant collection 'data' cleared.")
+except Exception:
+    print("No existing Qdrant collection to clear, starting fresh.")
+    pass 
+
+client.create_collection(
+    collection_name="data",
+    vectors_config=VectorParams(size=1024, distance=Distance.COSINE),
+)
+
+points = [
+  PointStruct(
+    id=str(uuid.uuid4()),
+    vector=embed,
+    payload={**doc.metadata, "text": doc.page_content} 
+  )
+  for doc, embed in documents_embeddings
+]
+
+operation_info = client.upsert(
+    collection_name="data",
+    wait=True,
+    points=points
+)
+
+print("Index build complete. Your structured CV content is now stored in Qdrant.")
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/archive/build_index.py
+```python
+import uuid
+import json
+import time
+import llama_cpp
+from pathlib import Path
+
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+
+from langchain_core.documents import Document
+from dataclasses import dataclass
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+from utils import chunk
+
+# Define base directory for consistent path resolution
+BASE_DIR = Path(__file__).parent.parent
+
+# Use absolute path for data file
+file = str(BASE_DIR / "backend/data/data.json")
+
+# Load the single JSON file containing the CV text
+with open(file, "r") as f:
+    data = json.load(f)
+
+# Extract the text content
+text = data["text"]
+
+# Split the text into smaller chunks for embedding
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=300,
+    chunk_overlap=50,
+    length_function=len,
+    is_separator_regex=False,
+)
+
+documents = text_splitter.create_documents([text])
+print(f"Number of document chunks: {len(documents)}")
+
+# Initialize the embedding model via llama.cpp
+llm = llama_cpp.Llama(
+  model_path=str(BASE_DIR / "models/mxbai-embed-large-v1-f16.gguf"), 
+  embedding=True, 
+  verbose=False
+)
+
+batch_size = 100
+documents_embeddings = []
+batches = list(chunk(documents, batch_size))
+
+start = time.time()
+for batch in batches:
+  # Get embeddings for each chunk in the batch
+  embeddings = llm.create_embedding([item.page_content for item in batch])
+  documents_embeddings.extend(
+    [
+      (document, emb['embedding'])  
+      for document, emb in zip(batch, embeddings['data'])
+    ]
+  )
+end = time.time()
+char_per_second = len(''.join([item.page_content for item in documents])) / (end - start)
+print(f"Time taken: {end - start:.2f} seconds / {char_per_second:,.2f} chars/sec")
+
+# Initialize Qdrant (local, SQLite-based) and create/recreate collection
+# Use absolute path to ensure consistency with other files
+client = QdrantClient(path=str(BASE_DIR / "embeddings"))
+
+# Try to delete the collection if it exists
+try:
+    client.delete_collection(collection_name="data")
+except Exception:
+    pass  # Collection might not exist yet, that's fine
+
+# Create fresh collection
+client.create_collection(
+    collection_name="data",
+    vectors_config=VectorParams(size=1024, distance=Distance.COSINE),
+)
+
+# Insert embeddings and text into Qdrant
+points = [
+  PointStruct(
+    id=str(uuid.uuid4()),
+    vector=embed,
+    payload={"text": doc.page_content}
+  )
+  for doc, embed in documents_embeddings
+]
+
+operation_info = client.upsert(
+    collection_name="data",
+    wait=True,
+    points=points
+)
+
+print("Index build complete. Your CV content is now stored in Qdrant with embeddings.")
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/auth.py
+```python
+from fastapi import Request, HTTPException, Depends
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+import secrets
+import os
+from starlette.status import HTTP_401_UNAUTHORIZED
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Create a security instance for HTTP Basic Auth
+security = HTTPBasic()
+
+# Get admin credentials from environment variables
+ADMIN_USERNAME = os.getenv("ADMIN_USERNAME")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD")
+
+# Check if credentials are set
+if not ADMIN_USERNAME or not ADMIN_PASSWORD:
+    raise ValueError("ADMIN_USERNAME and ADMIN_PASSWORD must be set in the environment or a .env file")
+
+def verify_admin_credentials(credentials: HTTPBasicCredentials = Depends(security)):
+    """Verify admin credentials for protected endpoints."""
+    is_correct_username = secrets.compare_digest(credentials.username, ADMIN_USERNAME)
+    is_correct_password = secrets.compare_digest(credentials.password, ADMIN_PASSWORD)
+    
+    if not (is_correct_username and is_correct_password):
+        raise HTTPException(
+            status_code=HTTP_401_UNAUTHORIZED,
+            detail="Invalid credentials",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+    
+    return credentials.username
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/database.py
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+# Define database directory and file path
+DB_DIRECTORY = "data"
+DB_FILE = "conversations.db"
+DB_PATH = os.path.join(DB_DIRECTORY, DB_FILE)
+
+# Create the data directory if it doesn't exist
+os.makedirs(DB_DIRECTORY, exist_ok=True)
+
+# Create SQLite database engine
+SQLALCHEMY_DATABASE_URL = f"sqlite:///{DB_PATH}"
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+
+# Create sessionmaker
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create base class for models
+Base = declarative_base()
+
+def get_db():
+    """Get database session."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/models.py
+```python
+from sqlalchemy import Column, Integer, String, Text, DateTime
+from sqlalchemy.sql import func
+from backend.database import Base
+
+class Conversation(Base):
+    """Model for storing conversation history."""
+    __tablename__ = "conversations"
+
+    id = Column(Integer, primary_key=True, index=True)
+    timestamp = Column(DateTime(timezone=True), server_default=func.now(), index=True)
+    user_message = Column(Text, nullable=False)
+    ai_response = Column(Text, nullable=False)
+    tts_reference = Column(String, nullable=True)
+
+```
+
+File: C:/Users/User/Desktop/colin-tts/backend/utils.py
+```python
+from itertools import islice
+
+
+def chunk(arr_range, chunk_size): 
+    arr_range = iter(arr_range) 
+    return iter(lambda: list(islice(arr_range, chunk_size)), []) 
+```
+
+File: C:/Users/User/Desktop/colin-tts/run.txt
+```text
+
+```
+
+</file_contents>

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.44.0
+llama-cpp-python==0.2.90
+qdrant-client>=1.9.1
+huggingface_hub>=0.24.0
+piper-tts>=1.2.0
+onnxruntime>=1.18.0
+rich>=13.7.0

structured-cv.json

@@ -0,0 +1,129 @@
+{
+  "personal_info": {
+    "name": "Colin Salvatore Nardo",
+    "email": "colin.nardo@gmail.com",
+    "linkedin": "www.linkedin.com/in/colin-salvatore-nardo",
+    "website": "nardocol.in"
+  },
+  "summary": "I am a dedicated MSci Computing Science student at the University of Glasgow, on track for a First-Class Honours. My experience revolves around building and deploying full-stack AI applications, leading collaborative technical projects, and translating complex requirements into practical software solutions. As President of the University's AI Society, I actively foster a community of learning and innovation. I am driven by the opportunity to apply my skills in software engineering and artificial intelligence to solve challenging, real-world problems in results-focused, collaborative environments.",
+  "professional_focus": {
+    "problem_solving_style": [
+      "I thrive on delivering concrete results, a mindset proven by my 1st place victory in the GUTS Code Olympics, a high-pressure competitive programming challenge. This mirrors my focus on achieving tangible outcomes in all my project work.",
+      "My approach involves designing efficient, production-ready solutions, even within significant constraints. A key example is my AI Chatbot, which I engineered specifically for CPU-only inference to ensure it was accessible and performant without requiring expensive hardware.",
+      "I excel at bridging the gap between user needs and technical implementation. In the Course Content Mapping project, I worked directly with university staff, translating their complex Excel-based workflows into an intuitive, interactive web application."
+    ],
+    "leadership_and_teamwork": [
+      "In my role as President of the Glasgow University AI Society, I lead a diverse committee to organize weekly workshops and industry talks for over 100 members, featuring speakers from major companies like Google, Hugging Face, and JP Morgan.",
+      "This leadership experience has honed my communication and organizational skills, teaching me how to coordinate with industry professionals, manage event logistics, and delegate responsibilities effectively to ensure the smooth execution of our initiatives.",
+      "I am committed to fostering an inclusive learning environment where collaboration and knowledge-sharing are paramount. I believe that diverse perspectives lead to stronger outcomes, a value I bring to every team I am a part of."
+    ]
+  },
+  "technical_philosophy": {
+    "title": "My Approach to Software Engineering",
+    "points": [
+      "Client-Focused Delivery: I believe that understanding client needs and adapting solutions is key to building lasting impact. I practice this by running sprint reviews and actively negotiating scope changes to ensure the final product aligns with stakeholder goals.",
+      "Building Scalable & Trusted Systems: My work on my Minecraft mods, which reached over 30,000 downloads, strengthened my ability to build scalable, event-driven systems that are used and trusted by a large community.",
+      "Innovation with a Purpose: I am motivated by the chance to contribute to impactful systems and am passionate about pushing technical boundaries to create practical, forward-looking solutions that solve real-world problems."
+    ]
+  },
+  "education": {
+    "institution": "University of Glasgow",
+    "degree": "MSci in Computing Science",
+    "dates": "September 2022 - May 2027",
+    "details": [
+      "I am currently on track for a First-class Honours (1st) prediction.",
+      "My core coursework has provided a strong foundation in both theory and practice, with key courses including Object-Oriented Programming, Algorithms and Data Structures, Operating Systems, Artificial Intelligence, and Practical Natural Language Processing."
+    ]
+  },
+  "projects": [
+    {
+      "title": "AI Voice Clone & Chatbot",
+      "organization": "Personal Project",
+      "dates": "October 2024 - April 2025",
+      "technologies": ["Python", "FastAPI", "Next.js", "React", "TypeScript", "Qdrant", "RAG", "GGUF", "Piper TTS"],
+      "contributions": [
+        "I single-handedly developed and deployed this full-stack conversational AI, which is live on my portfolio. It functions as an AI clone of me, capable of answering questions about my experience.",
+        "I architected the entire system, building a robust Python FastAPI backend to handle the AI logic and a responsive Next.js and TypeScript frontend for the user interface.",
+        "The core of the AI is a Retrieval-Augmented Generation (RAG) pipeline I engineered to provide it with a custom knowledge base (my CV), ensuring its answers are accurate and relevant.",
+        "A key achievement was optimizing the entire system for CPU-only inference. This involved using quantized GGUF language models and a lightweight Piper TTS engine, making it accessible 24/7 on small PCs without needing a GPU.",
+        "To create a realistic and personal voice, I fine-tuned the Text-to-Speech engine on over 300 of my own voice recordings, enabling fully offline, natural-sounding speech synthesis."
+      ],
+      "key_takeaways": "This end-to-end project demonstrates my ability to design and build efficient, production-ready solutions, even in resource-constrained settings. It required creative problem-solving and iterative refinement to push technical boundaries and deliver a complete, polished application.",
+      "technical_deep_dive": "The RAG pipeline uses a Qdrant vector database to store and retrieve context from embedded text chunks with low latency. The backend is deployed via Cloudflare Tunnels to handle dynamic IP routing, ensuring robust and secure performance."
+    },
+    {
+      "title": "Course Content Mapping Web Application",
+      "organization": "University of Glasgow (LISU)",
+      "dates": "September 2024 - April 2025",
+      "technologies": ["Python", "FastAPI", "React", "TypeScript", "SQLModel", "SQLAlchemy", "Docker", "Nginx", "ApexCharts"],
+      "contributions": [
+        "I led the frontend development for this web application, designed to modernize the course planning process for university professors by replacing a cumbersome Excel-based system.",
+        "Using React and TypeScript, I engineered an interactive Single Page Application with an intuitive drag-and-drop interface for organizing course activities.",
+        "I was the main point of contact for the clients, organizing monthly sprint reviews to present progress, gather feedback on evolving requirements, and negotiate the scope for upcoming development cycles.",
+        "The application features data visualization dashboards using ApexCharts to track learning hours and graduate attribute coverage, providing valuable insights to academic staff.",
+        "The backend is a robust REST API built with Python and FastAPI, using SQLModel for database interaction and object validation, all containerized with Docker."
+      ],
+      "key_takeaways": "This project gave me critical experience in translating complex client requirements into clear specifications and a user-friendly product. Collaborating with teammates in agile sprints improved my ability to deliver iterative updates and ensure the application met both technical and regulatory needs.",
+      "technical_deep_dive": "The application is fully containerized using Docker and orchestrated with Docker Compose. An Nginx server acts as a reverse proxy, handling requests and directing traffic to the appropriate frontend or backend service. The backend includes role-based permissions and session authentication for security."
+    },
+    {
+      "title": "Java Mod Development for Minecraft (CobblePass)",
+      "organization": "Personal Project",
+      "dates": "December 2025 - May 2025",
+      "technologies": ["Java", "Fabric API", "Gradle", "JSON"],
+      "contributions": [
+        "I developed and published two popular server-side mods for Minecraft from scratch using Java and the Fabric API, which have achieved over 30,000 combined downloads.",
+        "The primary mod, CobblePass, is a highly flexible battle pass system designed to drive player engagement through a dual-track reward system (free and premium).",
+        "I designed and implemented dynamic user interfaces for players and robust, schema-based JSON configurations, allowing server administrators to deeply customize seasons, rewards, and GUI layouts without restarting the server.",
+        "The mod features a rich suite of in-game admin commands for live management of seasons and player data."
+      ],
+      "key_takeaways": "This project strengthened my ability to build scalable, event-driven systems that are used and trusted by a large and active community. It was a deep dive into object-oriented programming, data persistence, and API integration in a real-world application.",
+      "technical_deep_dive": "I engineered an event-driven architecture to track in-game player actions, such as catching a creature, which then grants experience. The system manages persistent user data across sessions and integrates with third-party APIs like GooeyLibs for the GUI and the Impactor API for in-game economy features."
+    },
+    {
+      "title": "Glasgow University Artificial Intelligence Society President",
+      "organization": "Glasgow University Artificial Intelligence Society",
+      "dates": "May 2024 - Present",
+      "technologies": ["Leadership", "Event Management", "Public Speaking", "Networking", "Community Building"],
+      "contributions": [
+        "As President, I lead the society's mission to equip students with practical AI skills. I organize and coordinate a full calendar of events, including weekly hands-on technical workshops.",
+        "I am responsible for industry outreach, successfully hosting guest talks with leading professionals from companies like JP Morgan, Hugging Face, and Google to provide members with insights into real-world AI applications and trends.",
+        "I manage collaborations with external organizations to create valuable networking opportunities and source internships for our members in AI-related fields."
+      ],
+      "key_takeaways": "This role has been instrumental in developing my leadership, communication, and organizational skills. It has taught me how to manage an inclusive environment, delegate responsibilities effectively, and coordinate complex events, all of which are essential for working in multi-disciplinary teams."
+    },
+    {
+      "title": "GUTS Code Olympics & Hackathons",
+      "organization": "Glasgow University Tech Society",
+      "dates": "October 2024, February 2025",
+      "technologies": ["Competitive Programming", "Algorithms", "Data Structures", "Three.js", "JavaScript", "Blender"],
+      "contributions": [
+        "I achieved 1st place in the GUTS Code Olympics, a competitive programming challenge sponsored by J.P. Morgan, BlackRock, and SAS, where I secured over 80% of the total available points.",
+        "At a separate GUTS hackathon, I led a team in the rapid development of a multiplayer 3D web game using Three.js, which featured airplanes navigating a 3D globe.",
+        "For the game, I created dynamic hazards like earthquakes and hurricanes that players had to avoid in real-time. I also personally modelled all the low-poly 3D assets from scratch in Blender to ensure a cohesive visual design."
+      ],
+      "key_takeaways": "These competitions demonstrated my ability to solve complex problems under pressure and to rapidly prototype functional applications. The hackathon in particular was a great exercise in teamwork, 3D graphics programming, and creative design."
+    }
+  ],
+  "experience": [
+    {
+      "role": "Storage Administrator",
+      "company": "Saint Storage",
+      "location": "St. Andrews, Scotland",
+      "dates": "August 2023 - August 2024",
+      "description": "In this role, I assisted in optimizing the company's logistics operations. My main contribution was supporting the integration of Storage IQ, a web application built with Ruby on Rails, which helped to enhance warehouse efficiency and improve the accuracy of deliveries."
+    }
+  ],
+  "skills": {
+    "languages": ["Python", "Java", "TypeScript/JavaScript", "SQL"],
+    "frameworks_and_libraries": ["FastAPI", "React", "Next.js", "Three.js", "PyTorch", "SQLAlchemy", "SvelteKit", "GSAP"],
+    "databases_and_data": ["SQL", "Qdrant (Vector DB)", "RAG Pipelines", "Docker", "Sanity CMS"],
+    "spoken_languages": [
+      { "language": "English", "proficiency": "Native" },
+      { "language": "Italian", "proficiency": "Native" },
+      { "language": "French", "proficiency": "Fluent" },
+      { "language": "Spanish", "proficiency": "Intermediate" },
+      { "language": "Sicilian", "proficiency": "Native" }
+    ]
+  }
+}