Update app.py

app.py

@@ -1,256 +1,354 @@
-import json
-import smolagents
-import llama_cpp
-import pandas as pd
-import numpy as np
-import gradio as gr
-
-# 1. LLM Model Definition
-MODEL_REPO = "bartowski/Qwen_Qwen3-4B-Instruct-2507-GGUF"
-MODEL_FILE = "Qwen_Qwen3-4B-Instruct-2507-Q4_K_M.gguf"
-
-llm = llama_cpp.Llama.from_pretrained(
-    repo_id=MODEL_REPO,
-    filename=MODEL_FILE,
-    n_ctx=4096*4,
-    n_threads=8,
-    n_layers=-1,
-    verbose=False
-)
-
-# 2. Data Loading and Processing
-SHEET_ID = '1h6gl0reY5iT2Q3_hb8pemP5Hi4OMDYcE'
-BASE_URL = f'https://docs.google.com/spreadsheets/d/{SHEET_ID}/gviz/tq?tqx=out:csv&gid='
+# --- TechSpark Courses Q&A: lightweight Gradio chat with a tiny LLM ---
+# Works in Google Colab. Hard-coded course data, no uploads required.
 
-COURSES_GID = 1645090689 # GID for the 'Courses' tab
-TOOLS_GID = 2123942435 # GID for the 'Tools' tab
+!pip -q install gradio==4.44.0 transformers==4.44.2 rapidfuzz==3.9.6
 
-courses_url = f'{BASE_URL}{COURSES_GID}'
-tools_url = f'{BASE_URL}{TOOLS_GID}'
-
-courses_df = pd.read_csv(courses_url)
-tools_df = pd.read_csv(tools_url)
-
-course_info = {
-    str(row["Code"]): {
-        "name": row["Name"],
-        "description": row["Description"]
-    }
-    for _, row in courses_df.iterrows()
+import gradio as gr
+from rapidfuzz import process, fuzz
+
+# Optional tiny LLM (fast): FLAN-T5-small
+# If it fails to load (e.g., offline), we’ll just return the raw answer.
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+
+def load_llm():
+    try:
+        tok = AutoTokenizer.from_pretrained("google/flan-t5-small")
+        mdl = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
+        return tok, mdl
+    except Exception:
+        return None, None
+
+TOK, MDL = load_llm()
+
+def llm_paraphrase(text: str) -> str:
+    if not (TOK and MDL):
+        return text
+    prompt = f"Paraphrase clearly and concisely:\n{text}"
+    inputs = TOK(prompt, return_tensors="pt")
+    out_ids = MDL.generate(**inputs, max_new_tokens=128)
+    return TOK.decode(out_ids[0], skip_special_tokens=True)
+
+# ------------------------
+# HARD-CODED COURSE DATA
+# (Copied from your CSV: /mnt/data/TechSpark.xlsx - Courses.csv)
+# Columns: Name, Code, Description, Units, Length (Weeks),
+# Laser Cutting, Wood Working, Wood CNC, Metal Machining, Metal CNC,
+# 3D Printer, Welding, Electronics
+# Note: Some descriptions were truncated with "..." in the source CSV; left as-is.
+# ------------------------
+
+COURSES = [
+  {
+    "Name": "Modern Making",
+    "Code": 24104,
+    "Description": "This course teaches the fundamental skills needed to plan, devel...bricating with 3D printers, and physical computing with Arduino.",
+    "Units": 3,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 3,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 0,
+    "Metal CNC": 0,
+    "3D Printer": 3,
+    "Welding": 0,
+    "Electronics": 3
+  },
+  {
+    "Name": "Laser Machine Training",
+    "Code": 24105,
+    "Description": "This is a course that allows students to work at their own pace....ed to use the laser cutting and engraving machines at TechSpark.",
+    "Units": 0,
+    "Length (Weeks)": 2,
+    "Laser Cutting": 2,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 0,
+    "Metal CNC": 0,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  },
+  {
+    "Name": "Intro to Manual Machining",
+    "Code": 24200,
+    "Description": "This course teaches safe operation of manual machining equipment...gn projects, research equipment, and extracurricular activities.",
+    "Units": 1,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 0,
+    "Metal CNC": 0,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  },
+  {
+    "Name": "Project Fabrication and Assembly",
+    "Code": 24201,
+    "Description": "This course teaches the fundamental skills of fabrication and as...asses and is a portal (prerequisite) to other TechSpark courses.",
+    "Units": 1,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 2,
+    "Wood Working": 1,
+    "Wood CNC": 0,
+    "Metal Machining": 0,
+    "Metal CNC": 0,
+    "3D Printer": 3,
+    "Welding": 0,
+    "Electronics": 3
+  },
+  {
+    "Name": "Machine Shop Principles",
+    "Code": 24203,
+    "Description": "This course teaches the safe operation of manual machining equip...course is required to use the student machine shop at TechSpark.",
+    "Units": 3,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 3,
+    "Metal CNC": 0,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  },
+  {
+    "Name": "Metal Jewelry",
+    "Code": 24204,
+    "Description": "This course teaches introductory-level metal jewelry fabrication...This course is required to use the hot metals room at TechSpark.",
+    "Units": 2,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 1,
+    "Metal CNC": 1,
+    "3D Printer": 0,
+    "Welding": 2,
+    "Electronics": 0
+  },
+  {
+    "Name": "Welding",
+    "Code": 24205,
+    "Description": "This course teaches the safe operation of welding equipment thro...is course is required to use the welding equipment at TechSpark.",
+    "Units": 2,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 0,
+    "Wood CNC": 0,
+    "Metal Machining": 1,
+    "Metal CNC": 1,
+    "3D Printer": 0,
+    "Welding": 3,
+    "Electronics": 0
+  },
+  {
+    "Name": "Wood Shop Principles",
+    "Code": 24206,
+    "Description": "This course teaches the safe operation of wood working equipment...is course is required to use the student wood shop at TechSpark.",
+    "Units": 3,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 3,
+    "Wood CNC": 0,
+    "Metal Machining": 0,
+    "Metal CNC": 0,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  },
+  {
+    "Name": "Wood Shop CNC Router",
+    "Code": 24207,
+    "Description": "This course builds upon previous skills taught in TechSpark's wo...o use the CNC wood router in the student wood shop at TechSpark.",
+    "Units": 3,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 2,
+    "Wood CNC": 3,
+    "Metal Machining": 0,
+    "Metal CNC": 1,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  },
+  {
+    "Name": "Machine Shop CNC Milling",
+    "Code": 24300,
+    "Description": "This course builds upon previous skills taught in TechSpark's ma...e CNC milling machines in the student machine shop at TechSpark.",
+    "Units": 2,
+    "Length (Weeks)": 7,
+    "Laser Cutting": 0,
+    "Wood Working": 0,
+    "Wood CNC": 1,
+    "Metal Machining": 0,
+    "Metal CNC": 3,
+    "3D Printer": 0,
+    "Welding": 0,
+    "Electronics": 0
+  }
+]
+
+
+# ------------------------
+# Simple retrieval helpers
+# ------------------------
+
+FIELD_ALIASES = {
+    "units": "Units",
+    "weeks": "Length (Weeks)",
+    "length": "Length (Weeks)",
+    "description": "Description",
+    "laser": "Laser Cutting",
+    "laser cutting": "Laser Cutting",
+    "wood": "Wood Working",
+    "woodworking": "Wood Working",
+    "wood cnc": "Wood CNC",
+    "metal": "Metal Machining",
+    "metal machining": "Metal Machining",
+    "metal cnc": "Metal CNC",
+    "3d": "3D Printer",
+    "3d printing": "3D Printer",
+    "printer": "3D Printer",
+    "weld": "Welding",
+    "welding": "Welding",
+    "electronics": "Electronics",
+    "code": "Code",
+    "name": "Name"
 }
 
-machine_to_course = {}
-for _, row in tools_df.iterrows():
-    machine_name = row["Name"]
-    required_course = row["Required Course"]
-
-    if pd.isna(required_course):
-        machine_to_course[machine_name] = "No_Training_Required"
-    else:
-        machine_to_course[machine_name] = str(int(required_course))
-
-# 3. LlamaCppModel and MachineTrainingTool Class Definitions
-class LlamaCppModel(smolagents.Model):
-    """
-    Thin wrapper for a llama.cpp OpenAI-compatible client.
-    Pass in an object exposing `create_chat_completion(...)` (e.g., from llama_cpp).
-    """
-
-    def __init__(self, llm, model_id: str = "llama", **gen_defaults):
-        super().__init__()
-        self.llm = llm
-        self.model_id = model_id
-        self.gen_defaults = {"max_tokens": 4096, "temperature": 0.2}
-        self.gen_defaults.update(gen_defaults)
-
-    @staticmethod
-    def _content_to_str(content) -> str:
-        if content is None:
-            return ""
-        if isinstance(content, str):
-            return content
-
-        if isinstance(content, list):
-            parts = []
-            for p in content:
-                if isinstance(p, str):
-                    parts.append(p)
-                elif isinstance(p, dict):
-                    if p.get("type") == "text" and "text" in p:
-                        parts.append(str(p["text"]))
-                    elif "text" in p:
-                        parts.append(str(p["text"]))
-                    else:
-                        parts.append(json.dumps(p, ensure_ascii=False))
-                else:
-                    parts.append(str(p))
-            return "\n".join([s for s in parts if s])
-
-        if isinstance(content, dict):
-            if content.get("type") == "text" and "text" in content:
-                return str(content["text"])
-            if "content" in content and isinstance(content["content"], str):
-                return content["content"]
-            return json.dumps(content, ensure_ascii=False)
-
-        return str(content)
-
-    @staticmethod
-    def _safe_get(obj, *keys, default=None):
-        if isinstance(obj, dict):
-            for k in keys:
-                if k in obj:
-                    return obj[k]
-            return default
-        for k in keys:
-            if hasattr(obj, k):
-                return getattr(obj, k)
-        return default
-
-    def _to_openai_messages(self, messages: list[smolagents.ChatMessage]) -> list[dict]:
-        oa = []
-        for m in messages:
-            role = getattr(m, "role", None) or (m.get("role") if isinstance(m, dict) else None) or "user"
-            content = getattr(m, "content", None) or (m.get("content") if isinstance(m, dict) else None)
-            text = self._content_to_str(content)
-
-            images = getattr(m, "images", None) or (m.get("images") if isinstance(m, dict) else None)
-            if images:
-                text = (text + f"\n[Note: {len(images)} image(s) omitted]").strip()
-
-            oa.append({"role": role, "content": text})
-        return oa
-
-    def _from_openai_message(self, msg) -> smolagents.ChatMessage:
-        role = self._safe_get(msg, "role", default="assistant")
-        content = self._safe_get(msg, "content", default="")
-        return smolagents.ChatMessage(role=role, content=content)
-
-    def generate(
-        self,
-        messages: list[smolagents.ChatMessage],
-        stop_sequences: list[str] | None = None,
-        response_format: dict[str, str] | None = None,
-        tools_to_call_from: list[smolagents.Tool] | None = None,
-        **kwargs,
-    ) -> smolagents.ChatMessage:
-        oa_msgs = self._to_openai_messages(messages)
-
-        params = dict(self.gen_defaults)
-        params.update(kwargs)
-        if stop_sequences:
-            params["stop"] = stop_sequences
-        if response_format:
-            params["response_format"] = response_format
-
-        resp = self.llm.create_chat_completion(
-            model=self.model_id,
-            messages=oa_msgs,
-            **params,
-        )
-
-        choices = self._safe_get(resp, "choices", default=[])
-        if not choices:
-            text = self._safe_get(resp, "content", default=str(resp))
-            return smolagents.ChatMessage(role="assistant", content=text)
-
-        first = choices[0]
-        message = self._safe_get(first, "message", default={})
-        return self._from_openai_message(message)
-
-class MachineTrainingTool(smolagents.tools.Tool):
-    name = "get_machine_training_info"
-    description = (
-        "Retrieves training information for a specific machine. The `machine_name` argument should exactly match the machine's name as listed in the system (e.g., 'Laser Cutters', '3D Printers')."
+COURSE_NAMES = [c["Name"] for c in COURSES]
+COURSE_CODES = [str(c["Code"]) for c in COURSES]
+
+def find_course(query: str):
+    # Try to match by name (fuzzy) or code (exact substring)
+    best_name = process.extractOne(query, COURSE_NAMES, scorer=fuzz.WRatio)
+    code_hits = [c for c in COURSES if str(c["Code"]) in query.replace(" ", "")]
+    if best_name and best_name[1] >= 70:
+        for c in COURSES:
+            if c["Name"] == best_name[0]:
+                return c
+    if code_hits:
+        return code_hits[0]
+    return None
+
+def filter_by_skill(query: str):
+    # Return courses that have >0 level for any skill mentioned
+    hits = []
+    for key, field in FIELD_ALIASES.items():
+        if field in ["Units", "Length (Weeks)", "Description", "Code", "Name"]:
+            continue
+        if key in query.lower():
+            for c in COURSES:
+                try:
+                    if c.get(field, 0) and int(c.get(field, 0)) > 0:
+                        hits.append((field, c))
+                except Exception:
+                    pass
+    return hits
+
+def reply_for_course(c: dict, query: str) -> str:
+    # If user asked a specific field, show that; else show a compact summary
+    lower = query.lower()
+    # Check if they asked for a specific attribute
+    for key, field in FIELD_ALIASES.items():
+        if key in lower and field in c:
+            return f"{c['Name']} — {field}: {c[field]}"
+    # Default compact card
+    skills = ["Laser Cutting","Wood Working","Wood CNC","Metal Machining","Metal CNC","3D Printer","Welding","Electronics"]
+    taught = [s for s in skills if int(c.get(s,0))>0]
+    taught_str = ", ".join(taught) if taught else "General skills"
+    return (
+        f"{c['Name']} (Code {c['Code']})\n"
+        f"Units: {c['Units']} | Length: {c['Length (Weeks)']} weeks\n"
+        f"Focus: {taught_str}\n"
+        f"Description: {c['Description']}"
     )
-    inputs = {
-        "machine_name": {"type": "string", "description": "Name of the machine for which to retrieve training information"},
-    }
-    output_type = "string"
-
-    def forward(self, machine_name: str) -> str:
-      if machine_name in machine_to_course:
-          course_code = machine_to_course[machine_name]
-          if course_code in course_info:
-              course_name = course_info[course_code]['name']
-              return f"For {machine_name}, the required training is: '{course_name}' (Course Code: {course_code})."
-          else:
-              return f"No detailed course information found for course code '{course_code}' associated with {machine_name}."
-      else:
-          return f"No specific training information available for machine: {machine_name}."
-
-# 4. Agent Instantiation
-machine_training_tool_instance = MachineTrainingTool()
-
-llama_cpp_model_instance = LlamaCppModel(llm)
-llama_cpp_model_instance.gen_defaults['response_format'] = {'type': 'json_object'}
 
-from smolagents.agents import ToolCallingAgent
-
-machine_agent = ToolCallingAgent(
-    model=llama_cpp_model_instance,
-    name="MachineAgent",
-    instructions=(
-        "Your ONLY purpose is to call the 'get_machine_training_info' tool ONCE per user query. "
-        "You MUST then output the EXACT string provided by the tool's observation. "
-        "You MUST NOT add any text before or after the tool's observation. "
-        "You MUST NOT summarize, paraphrase, or change the tool's output in any way. "
-        "You MUST NOT call any other tool, especially 'final_answer'. "
-        "The 'machine_name' argument MUST be an exact match from the available machine list."
-    ),
-    tools=[machine_training_tool_instance],
-    verbosity_level=2
+def list_all_courses():
+    return "Courses:\n" + "\n".join([f"- {c['Name']} (Code {c['Code']})" for c in COURSES])
+
+def list_by_skill(hits):
+    if not hits:
+        return None
+    # Group by skill field
+    by = {}
+    for field, c in hits:
+        by.setdefault(field, []).append(c)
+    lines = []
+    for field, cs in by.items():
+        lines.append(f"{field} courses:")
+        for c in cs:
+            lines.append(f"- {c['Name']} (Code {c['Code']})")
+    return "\n".join(lines)
+
+# ------------------------
+# Chat handler
+# ------------------------
+
+HELP_TEXT = (
+    "You can ask:\n"
+    "• “List all courses”\n"
+    "• “What are the units for Modern Making?”\n"
+    "• “Which classes teach welding?”\n"
+    "• “What is Code 24205?” or “Tell me about Intro to CNC Machining”\n"
+    "• “Which courses cover laser cutting or 3D printing?”\n"
 )
 
-# 5. Gradio Interface Code
-with gr.Blocks(title="Techspark Machine Training Agent") as demo:
-    gr.Markdown("## Techspark Machine Training Agent — Custom Tool Selection (smolagents + llama.cpp)")
-    chat = gr.Chatbot(height=420)
-    inp = gr.Textbox(
-        placeholder="Ask about machine training (e.g., 'What training do I need for the Laser Cutters?').",
-        label="Your question"
-    )
-
-    def respond(message, history):
-        try:
-            result_object = machine_agent.run(message, return_full_result=True)
-            tool_observation = None
-
-            if isinstance(result_object, smolagents.RunResult):
-                for step_dict in result_object.steps:
-                    if isinstance(step_dict, dict):
-                        if 'tool_calls' in step_dict and step_dict['tool_calls']:
-                            for tool_call_info in step_dict['tool_calls']:
-                                if tool_call_info.get('function') and tool_call_info['function'].get('name') == 'get_machine_training_info':
-                                    if 'observations' in step_dict:
-                                        tool_observation = step_dict['observations']
-                                        break
-                            if tool_observation:
-                                break
-
-            if tool_observation:
-                out = tool_observation
-            else:
-                out = result_object.text if hasattr(result_object, 'text') else str(result_object)
-
-        except Exception as e:
-            out = f"[Error] {e}"
-
-        history = (history or []) + [(message, out)]
-        return "", history
+def answer_fn(message, history):
+    q = (message or "").strip()
+    if not q:
+        return HELP_TEXT
+
+    # Quick intents
+    if "list" in q.lower() and "course" in q.lower():
+        ans = list_all_courses()
+        return llm_paraphrase(ans)
+
+    # Skill-filter intent
+    skill_hits = filter_by_skill(q)
+    skill_resp = list_by_skill(skill_hits)
+    if skill_resp:
+        return llm_paraphrase(skill_resp)
+
+    # Single-course intent
+    c = find_course(q)
+    if c:
+        ans = reply_for_course(c, q)
+        return llm_paraphrase(ans)
+
+    # Fallback: nearest name suggestion
+    best = process.extractOne(q, COURSE_NAMES, scorer=fuzz.WRatio)
+    if best and best[1] >= 55:
+        suggestion = best[0]
+        return llm_paraphrase(
+            f"I couldn't find an exact match. Did you mean “{suggestion}”? "
+            f"Try asking: ‘Tell me about {suggestion}’ or ‘What are the units for {suggestion}?’\n\n{HELP_TEXT}"
+        )
 
-    gr.Examples(
-        fn=respond,
-        examples=[
-            "What training do I need for the Laser Cutters?",
-            "What are the training requirements for the 3D Printer?",
-            "Can you tell me about training for Metal CNC?"
-        ],
-        inputs=[inp],
-        outputs=[chat]
+    # Final fallback
+    return llm_paraphrase(
+        "I couldn't match that to a TechSpark course. "
+        "Try mentioning a course name or code, or a skill like welding, laser cutting, or 3D printing.\n\n" + HELP_TEXT
     )
 
-    inp.submit(respond, [inp, chat], [inp, chat])
+# ------------------------
+# Gradio UI
+# ------------------------
+
+demo = gr.ChatInterface(
+    answer_fn,
+    title="TechSpark Courses Assistant",
+    description="Ask about TechSpark courses by name, code, or skill. (Tiny LLM paraphrase enabled for clarity.)",
+    examples=[
+        "List all courses",
+        "What are the units for Modern Making?",
+        "Which courses teach welding?",
+        "Tell me about Intro to CNC Machining",
+        "What is Code 24301?",
+        "Which courses include laser cutting?"
+    ],
+)
 
-# 6. Modified demo.launch() for Hugging Face Spaces
-demo.launch(server_name="0.0.0.0", server_port=7860, debug=False)
+demo.launch()