Update app.py

app.py

@@ -1,171 +1,35 @@
-import json
+import gradio as gr
 import smolagents
+import json
 import pandas as pd
 import numpy as np
 from huggingface_hub import login, HfApi
 from datasets import Dataset, DatasetDict, load_dataset
 import difflib
 import openai
-from typing import List
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
 
 
-# Setup
+# Re-define all necessary components that the agent relies on
+# This includes data loading, utility functions, and the agent itself
 
-import os
-token_public = os.getenv("token_public")
-
-login(token_public)
-
-OPENAI_API = os.getenv("OPENAI_API")
+# Setup (copied from qRq0g01h3ZvP)
+hf_token_public = os.getenv("token_public")
+# login(hf_token_public) # Login is not needed in app.py if HF_TOKEN is set as secret
 
 REPO_ID_TECHSPARK_STAFF = "aslan-ng/CMU_TechSpark_Staff"
 REPO_ID_TECHSPARK_COURSES = "aslan-ng/CMU_TechSpark_Courses"
 REPO_ID_TECHSPARK_TOOLS = "aslan-ng/CMU_TechSpark_Tools"
 
+SHEET_ID_TECHSPARK = "1cdL_jDglKa-NxZF3j5s2z9ncSFbJSMGC2d-GsKubV-I"
 
-token_public = os.getenv("TOKEN_PUBLIC") 
-# LLM model initialization
-model = smolagents.OpenAIServerModel(
-    model_id="gpt-4.1-mini",   # or another fast model
-    api_key=OPENAI_API,
-    # optionally: base_url="https://api.groq.com/openai/v1" for Groq, etc.
-)
+# OPENAI_API = "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" # Use environment variable for API key
+import os
+OPENAI_API = os.getenv("OPENAI_API")
 
-# Numeric profile of skills for each entry
+# Data (copied from rGAiTp0PYvEk, adjusted to load from HF directly)
 NUMERIC_PROFILE = ["Laser Cutting",	"Wood Working",	"Wood CNC",	"Metal Machining",	"Metal CNC",	"3D Printer",	"Welding",	"Electronics"]
 
-# Map common task keywords to candidate machine names.
-KEYWORD_TO_MACHINES = {
-    "mill": ["Mill"],
-    "shear": ["Shear"],
-    "vertical band saw": ["Vertical Band Saw"],
-    "horizontal band saw": ["Horizontal Band Saw"],
-    "band saw": ["Band Saw"],
-    "drill press": ["Drill press", "Drill Press", "Mini Drill Press"],
-    "lathe": ["Lathe"],
-    "cnc": ["Metal CNC", "Wood CNC"],
-    "weld": ["MIG Welder", "TIG Welder"],
-    "plasma": ["Hand-held Plasma Cutter"],
-    "waterjet": ["Waterjet"],
-    "torch": ["Acetylene Torch"],
-    "furnace": ["Furnace"],
-    "kiln": ["Kiln"],
-    "cast": ["Centrifugal Caster", "Vacuum Caster", "Vacuum Former", "Pressure Pots", "Vacuum Chambers"],
-    "tumble": ["Rotary Tumbler"],
-    "buff": ["Buffing Wheel"],
-    "solder": ["Soldering stations"],
-    "electronics": ["Soldering stations", "DC power supplies", "Multimeters", "Oscilloscopes"],
-    "jig saw": ["Jig Saws"],
-    "jigsaw": ["Jig Saws"],
-    "router": ["Table Router"],
-    "panel saw": ["Panel Saw"],
-    "table saw": ["Table Saw"],
-    "miter": ["Miter Saw"],
-    "sand": ["Belt/Disc/Spindle Sanders"],
-    "3d print": ["3D Printers"],
-    "3d printer": ["3D Printers"],
-    "printer": ["3D Printers"],
-    "laser": ["Laser Cutters"],
-    "paint": ["Paint"],
-}
-
-MACHINE_NOTES = {
-    "Laser Cutters": "2D cutting/engraving of sheet materials (e.g., acrylic, plywood, cardboard).",
-    "3D Printers": "Additive manufacturing of small plastic parts.",
-    "MIG Welder": "Fast welding of steel/aluminium with filler wire.",
-    "TIG Welder": "Precise welding of thin metals.",
-    "Waterjet": "High-precision cutting of almost any material with water/abrasive.",
-    "Hand-held Plasma Cutter": "Rough cutting of steel plate.",
-    "Centrifugal Caster": "Casting small metal components using centrifugal force.",
-    "Vacuum Caster": "Degassing and casting for small parts using vacuum.",
-    "Vacuum Former": "Forming heated plastic sheets over molds.",
-    "Pressure Pots": "Pressure-curing of cast parts to remove bubbles.",
-    "Vacuum Chambers": "Degassing silicone and resins before casting.",
-    "Soldering stations": "Assembly and rework of PCBs and wired electronics.",
-    "Table Saw": "Straight cuts in sheet/board stock (wood).",
-    "Panel Saw": "Breaking down large sheet goods (plywood, MDF).",
-    "Band Saw": "Curved cuts in wood.",
-    "Belt/Disc/Spindle Sanders": "Shaping and smoothing wood components.",
-    "Paint": "Finishing parts with spray paint in a ventilated booth.",
-}
-
-def load_data_from_sheet():
-    """
-    Load the data from Google Sheets.
-    """
-    from google.colab import auth
-    from google.auth import default
-    import gspread
-
-    auth.authenticate_user()
-
-    SHEET_SCHEMA = [
-        {"Staff": ["Name",	"Role",	"Overview of Responsibilities",	*NUMERIC_PROFILE]},
-        {"Courses": ["Name",	"Code",	"Description",	"Units",	"Length (Weeks)",	*NUMERIC_PROFILE]},
-        {"Tools": ["Name",	"Location",	"Accessible by Students", "Required Course"]},
-    ]
-    SHEET_NAMES = [list(d.keys())[0] for d in SHEET_SCHEMA]
-    #print(SHEET_NAMES)
-    def get_sheet_columns(sheet_name):
-        for entry in SHEET_SCHEMA:
-            if sheet_name in entry:
-                return entry[sheet_name]
-        return None
-    #print(get_sheet_columns(SHEET_NAMES[0]))
-
-    sh = gspread.authorize(default()[0]).open_by_key(SHEET_ID_TECHSPARK)
-
-    dfs = {}
-    for sheet_name in SHEET_NAMES:
-        ws = sh.worksheet(sheet_name)        # tab with that name
-        records = ws.get_all_records()       # list of dicts (rows)
-        df = pd.DataFrame(records)
-
-        # Ensure correct column order (and drop extras if any)
-        cols = get_sheet_columns(sheet_name)
-        if cols is not None:
-            df = df.reindex(columns=cols)
-
-        dfs[sheet_name] = df
-
-    # 5. Return them in a fixed order
-    staff_df  = dfs["Staff"]
-    courses_df = dfs["Courses"]
-    tools_df   = dfs["Tools"]
-
-    # Clean "Accessible by Students" if it comes as strings "TRUE"/"FALSE"
-    if tools_df["Accessible by Students"].dtype == object:
-        tools_df["Accessible by Students"] = tools_df["Accessible by Students"].map(
-            {"TRUE": True, "FALSE": False}
-        )
-
-    # Clean "Required Course": make it string with missing values
-    tools_df["Required Course"] = (
-        tools_df["Required Course"]
-        .replace("", pd.NA)     # empty ➔ missing
-        .astype("string")       # keep as string type
-    )
-
-    return staff_df, courses_df, tools_df
-
-def save_data_to_huggingface(staff_df, courses_df, tools_df):
-    """
-    Save data to HuggingFace.
-    """
-    hf_ds_staff = Dataset.from_pandas(staff_df, preserve_index=False)
-    hf_ds_staff.push_to_hub(REPO_ID_TECHSPARK_STAFF)
-    hf_ds_courses = Dataset.from_pandas(courses_df, preserve_index=False)
-    hf_ds_courses.push_to_hub(REPO_ID_TECHSPARK_COURSES)
-    hf_ds_tools = Dataset.from_pandas(tools_df, preserve_index=False)
-    hf_ds_tools.push_to_hub(REPO_ID_TECHSPARK_TOOLS)
-
-def refresh_hugginface_repo():
-    """
-    Loads data from Google Sheets and pushes it to HuggingFace.
-    """
-    staff_df, courses_df, tools_df = load_data_from_sheet()
-    save_data_to_huggingface(staff_df, courses_df, tools_df)
-
 def load_data_from_huggingface():
     """
     Loads data from HuggingFace.
@@ -183,9 +47,18 @@ def load_data_from_huggingface():
     tools_df = ds_tools["train"].to_pandas()
     return staff_df, courses_df, tools_df
 
+staff_df, courses_df, tools_df = load_data_from_huggingface()
+
+# LLM (copied from NPPbWry0qUIE)
+model = smolagents.OpenAIServerModel(
+    model_id="gpt-4.1-mini",
+    api_key=OPENAI_API,
+)
+
+# General Functions (copied from BwfI-EsvtvVx)
 def vector_1st_distance(x: list, y: list):
     """
-    Calculate the 1st distance between two vectors.
+    Calculate the average 1st distance between two vectors.
     """
     if len(x) != len(y):
       raise ValueError
@@ -233,18 +106,42 @@ def skill_score(
         y.append(electronics)
     return vector_1st_distance(x, y)
 
+# Staff Tools (copied from Q47nRn9_Zz1P)
 def all_staff():
     """
     Return a list of all staff.
     """
     return staff_df["Name"].dropna().tolist()
 
-def get_staff_full_profile(name: str):
+def match_staff_name(name: str):
     """
-    Get the staff full profile (including description and skill).
+    Match the staff name to the closest match in the staff list.
     """
     matches = difflib.get_close_matches(name, all_staff(), n=1, cutoff=0.2)
-    name = matches[0] if matches else None
+    return matches[0] if matches else None
+
+def all_available_staff(exclude: list):
+    """
+    Return a list of all staff with exclusion.
+    """
+    try:
+      exclude = list(exclude)
+    except:
+      pass
+    if exclude is None or len(exclude) == 0:
+        return all_staff()
+    excluded_names = []
+    for raw_name in exclude:
+        excluded_name = match_staff_name(raw_name)
+        if excluded_name:
+            excluded_names.append(excluded_name)
+    return [name for name in all_staff() if name not in excluded_names]
+
+def get_staff_full_profile(name: str):
+    """
+    Get the staff full profile given its name (including description and skill).
+    """
+    name = match_staff_name(name)
     if name:
         full_profile = staff_df[staff_df["Name"] == name].iloc[0].to_dict()
         return full_profile
@@ -273,8 +170,9 @@ def search_staff_by_skills(
     three_d_printer: float = None,
     welding: float = None,
     electronics: float = None,
+    exclude: list = None,
 ):
-    names = all_staff()
+    names = all_available_staff(exclude)
     best_name = None
     best_score = float("inf")
     for name in names:
@@ -296,140 +194,198 @@ def search_staff_by_skills(
             best_name = name
     return best_name
 
+class SearchStaffInformation(smolagents.tools.Tool):
+    name = "search_staff_information"
+    description = (
+        "Search the staff information by its name."
+    )
+    inputs = {
+        "name": {"type": "string", "description": "Name of the staff member."},
+    }
+    output_type = "object"
+
+    def forward(self, name: str) -> str:
+        return json.dumps(get_staff_profile(name))
+
+class FindSuitableStaff(smolagents.tools.Tool):
+    name = "find_suitable_staff"
+    description = (
+        "Find the most suitable staff member for the task based on required skills."
+    )
+    inputs = {
+        "laser_cutting": {"type": "number", "nullable": True, "description": "Laser cutting skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "wood_working": {"type": "number", "nullable": True, "description": "Wood working skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "wood_cnc": {"type": "number", "nullable": True, "description": "Wood CNC skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "metal_machining": {"type": "number", "nullable": True, "description": "Metal machining skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "metal_cnc": {"type": "number", "nullable": True, "description": "Metal CNC skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "three_d_printer": {"type": "number", "nullable": True, "description": "3D printer skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "welding": {"type": "number", "nullable": True, "description": "Welding skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "electronics": {"type": "number", "nullable": True, "description": "Electronics skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "exclude": {"type": "number", "nullable": True, "description": "A list of names that we want to exclude from searching. Default is None or an empty list."}
+    }
+    output_type = "object"
+
+    def forward(self,
+        laser_cutting: float = None,
+        wood_working: float = None,
+        wood_cnc: float = None,
+        metal_machining: float = None,
+        metal_cnc: float = None,
+        three_d_printer: float = None,
+        welding: float = None,
+        electronics: float = None,
+        exclude: list = None,
+    ) -> str:
+        name = search_staff_by_skills(
+            laser_cutting = laser_cutting,
+            wood_working = wood_working,
+            wood_cnc = wood_cnc,
+            metal_machining = metal_machining,
+            metal_cnc = metal_cnc,
+            three_d_printer = three_d_printer,
+            welding = welding,
+            electronics = electronics,
+            exclude = exclude,
+        )
+        return json.dumps(get_staff_profile(name))
+
+# Course Functions (copied from _P8TTwcOaUkN)
 def all_courses_code():
     """
     Return a list of all course codes.
     """
     return courses_df["Code"].dropna().astype(str).tolist()
 
-def get_course_info(code: str):
+def all_courses_name():
+    """
+    Return a list of all course names.
+    """
+    return courses_df["Name"].dropna().tolist()
+
+def course_name_to_code(course_name):
+    """
+    Convert the course name to course code.
+    """
+    return str(courses_df[courses_df["Name"] == course_name]["Code"].iloc[0])
+
+def course_code_to_name(course_code):
+    """
+    Convert the course code to course name.
+    """
+    return str(courses_df[courses_df["Code"].astype(str) == str(course_code)]["Name"].iloc[0])
+
+def match_course_name_code(input):
+    """
+    Match the course to the closest match in the course list and return their codes.
+    """
+    input = str(input)
+    matches = None
+    code_matches = difflib.get_close_matches(input, all_courses_code(), n=3, cutoff=0.2)
+    name_matches_code = difflib.get_close_matches(input, all_courses_name(), n=2, cutoff=0.3)
+    if name_matches_code:
+        name_matches = [course_name_to_code(name) for name in name_matches_code]
+    else:
+        name_matches = None
+    if code_matches and name_matches:
+        matches = code_matches + name_matches
+    elif code_matches and not name_matches:
+        matches = code_matches
+    elif name_matches and not code_matches:
+        matches = name_matches
+    return matches
+
+def get_course_full_profile(course):
     """
-    Get the course information given its code.
+    Get the course full profile given its code (including description and skill).
     """
     # Ensure the input code is a string for comparison
-    code_str = str(code)
-    matches = difflib.get_close_matches(code_str, all_courses_code(), n=1, cutoff=0.2)
+    matches = match_course_name_code(course)
     code = matches[0] if matches else None
     if code:
         full_profile = courses_df[courses_df["Code"].astype(str) == code].iloc[0].to_dict()
         return full_profile
     return None
 
-def all_tools():
+def get_course_skills_profile(course_code):
     """
-    Return a list of all tool names.
+    Get the course skills profile given its code.
     """
-    return tools_df["Name"].dropna().tolist()
+    full_profile = get_course_full_profile(course_code)
+    return {k: full_profile[k] for k in NUMERIC_PROFILE}
 
-def get_tool_full_profile(name: str):
+def get_course_profile(course_code):
     """
-    Get the tool's full profile.
+    Get the course profile without skill part.
     """
-    # Increased cutoff to make matching more strict, avoiding false positives for non-existent machines
-    matches = difflib.get_close_matches(name, all_tools(), n=1, cutoff=0.6)
-    name = matches[0] if matches else None
-    if name:
-        full_profile = tools_df[tools_df["Name"] == name].iloc[0].to_dict()
-        return full_profile
-    return None
+    full_profile = get_course_full_profile(course_code)
+    return {k: v for k, v in full_profile.items() if k not in NUMERIC_PROFILE}
 
-def find_candidates(task: str):
-    """Return a DataFrame of candidate machines for the given task description."""
-    global tools_df
-    df = tools_df
-    task_lc = task.lower()
-    if df is None or df.empty:
-        return df.iloc[0:0]  # empty with same columns
-
-    # 1) Matches from keyword mapping
-    names_from_keywords = set()
-    for kw, machine_names in KEYWORD_TO_MACHINES.items():
-        if kw in task_lc:
-            names_from_keywords.update(machine_names)
-
-    # 2) Direct substring matches on machine names
-    names_from_substring = set()
-    for name in df["Name"]:
-        if name.lower() in task_lc:
-            names_from_substring.add(name)
-
-    all_names = sorted(names_from_keywords.union(names_from_substring))
-
-    # 3) Fallback: token-based substring search
-    if not all_names:
-        # Add 'name_lower' column if it doesn't exist for substring search
-        if 'name_lower' not in df.columns:
-            df['name_lower'] = df['Name'].str.lower()
-        tokens = [t for t in task_lc.replace(",", " ").split() if len(t) > 3]
-        for token in tokens:
-            subset = df[df["name_lower"].str.contains(token)]
-            if not subset.empty:
-                all_names.extend(subset["Name"].tolist())
-        all_names = sorted(set(all_names))
-
-    return df[df["Name"].isin(all_names)]
-
-def make_location_plan(task: str):
-    """Print a short, human-readable location plan for a TechSpark task."""
-    global tools_df
-    df = tools_df
-    if df is None:
-        print("❌ Machine table not loaded yet.")
-        return
-
-    candidates = find_candidates(task)
-    print(f"Task: {task}\n")
-
-    if candidates.empty:
-        print("I couldn't find a clear machine match in the current table.")
-        print("Try rephrasing with the machine name you expect (e.g., 'laser cutter', '3D printer', 'MIG welder').")
-        return
-
-    print("Suggested machines and locations:\n")
-    for _, row in candidates.iterrows():
-        name = row["Name"]
-        loc = row["Location"]
-        print(f"- **{name}** → **{loc}**")
-        if name in MACHINE_NOTES:
-            print(f"  - Why here: {MACHINE_NOTES[name]}")
-        print()
-
-    locations = ", ".join(sorted(candidates["Location"].unique()))
-    print("Next steps inside TechSpark:")
-    print(f"1. Walk to: {locations}.")
-    print("2. Check posted safety/training requirements for the machine you choose.")
-    print("3. If you're unsure which specific machine is best, ask the staff in that area.")
-    print("4. Imagine how this module could plug into a larger agent that also plans the full fabrication process and checks training.")
-
-# Define the agent with all of these tools.
-
-class SearchStaffInformationTool(smolagents.tools.Tool):
-    name = "search_staff_information"
+def search_course_by_skills(
+    laser_cutting: float = None,
+    wood_working: float = None,
+    wood_cnc: float = None,
+    metal_machining: float = None,
+    metal_cnc: float = None,
+    three_d_printer: float = None,
+    welding: float = None,
+    electronics: float = None,
+    n_results: int = 1,
+):
+    names = all_courses_code()
+    scored_courses = []
+
+    for name in names:
+        skills_profile = get_course_skills_profile(name)
+
+        score = skill_score(
+            skill_profile=skills_profile,
+            laser_cutting=laser_cutting,
+            wood_working=wood_working,
+            wood_cnc=wood_cnc,
+            metal_machining=metal_machining,
+            metal_cnc=metal_cnc,
+            three_d_printer=three_d_printer,
+            welding=welding,
+            electronics=electronics,
+        )
+
+        if score is not None:
+            scored_courses.append((abs(score), name))
+            # store (absolute_score, course_name)
+
+    # Sort by closeness to zero
+    scored_courses.sort(key=lambda x: x[0])
+
+    # Return only the names of top N matches
+    return [name for _, name in scored_courses[:n_results]]
+
+class SearchCourseInformation(smolagents.tools.Tool):
+    name = "search_course_information"
     description = (
-        "Search the staff information by its name."
+        "Search the course information by the course name or course number (code)."
     )
     inputs = {
-        "name": {"type": "string", "description": "Name of the staff member."},
+        "name": {"type": "string", "description": "Course name or course number (code)."},
     }
     output_type = "object"
 
-    def forward(self, name: str) -> dict:
-        return get_staff_profile(name)
+    def forward(self, name: str) -> str:
+        return json.dumps(get_course_profile(name))
 
-class FindSuitableStaffTool(smolagents.tools.Tool):
-    name = "find_suitable_staff"
+class FindSuitableCourses(smolagents.tools.Tool):
+    name = "find_suitable_courses"
     description = (
-        "Find the most suitable staff member for the task based on required skills."
+        "Find the top 3 most suitable courses for the task based on required skills. The first element is the best match."
     )
     inputs = {
-        "laser_cutting": {"type": "number", "description": "Laser cutting skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "wood_working": {"type": "number", "description": "Wood working skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "wood_cnc": {"type": "number", "description": "Wood CNC skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "metal_machining": {"type": "number", "description": "Metal machining skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "metal_cnc": {"type": "number", "description": "Metal CNC skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "three_d_printer": {"type": "number", "description": "3D printer skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "welding": {"type": "number", "description": "Welding skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
-        "electronics": {"type": "number", "description": "Electronics skill required for the task. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)", "nullable": True},
+        "laser_cutting": {"type": "number", "nullable": True, "description": "Laser cutting skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "wood_working": {"type": "number", "nullable": True, "description": "Wood working skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "wood_cnc": {"type": "number", "nullable": True, "description": "Wood CNC skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "metal_machining": {"type": "number", "nullable": True, "description": "Metal machining skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "metal_cnc": {"type": "number", "nullable": True, "description": "Metal CNC skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "three_d_printer": {"type": "number", "nullable": True, "description": "3D printer skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "welding": {"type": "number", "nullable": True, "description": "Welding skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
+        "electronics": {"type": "number", "nullable": True, "description": "Electronics skill being taught during the course. It is a number between 0 (no expertise required) to 3 (high expertise expertise). Default is None. If left None, it will be ignored. (Optional)"},
     }
     output_type = "object"
 
@@ -442,8 +398,8 @@ class FindSuitableStaffTool(smolagents.tools.Tool):
         three_d_printer: float = None,
         welding: float = None,
         electronics: float = None,
-    ) -> dict:
-        name = search_staff_by_skills(
+    ) -> str:
+        matches = search_course_by_skills(
             laser_cutting = laser_cutting,
             wood_working = wood_working,
             wood_cnc = wood_cnc,
@@ -452,85 +408,162 @@ class FindSuitableStaffTool(smolagents.tools.Tool):
             three_d_printer = three_d_printer,
             welding = welding,
             electronics = electronics,
+            n_results = 3,
         )
-        return get_staff_profile(name)
+        options = [get_course_profile(course) for course in matches]
+        return json.dumps(options)
 
-class MachineTrainingTool(smolagents.tools.Tool):
-    name = "get_machine_training_info"
+# Machine Functions (copied from OKKlHB88tt1r)
+def all_tools():
+    """
+    Return a list of all tools and machines.
+    """
+    return tools_df["Name"].dropna().astype(str).tolist()
+
+def match_tool_name(input):
+    """
+    Match the course to the closest match in the course list and return their codes.
+    """
+    input = str(input)
+    matches = difflib.get_close_matches(input, all_tools(), n=1, cutoff=0.2)
+    return matches[0] if matches else None
+
+def get_tool_location(name: str):
+    """
+    Get the tool location given its name.
+    """
+    tool_name = match_tool_name(name)
+    if tool_name is not None:
+      return tools_df[tools_df["Name"] == tool_name].iloc[0]["Location"]
+    else:
+      raise ValueError("Not found.")
+
+def is_tool_accessible(name):
+    """
+    Check if the machine is accessible to students, and if they require taking mandatory courses.
+    """
+    result = None
+    tool_name = match_tool_name(name)
+    if tool_name is not None:
+        accessible = tools_df[tools_df["Name"] == tool_name].iloc[0]["Accessible by Students"]
+        accessible = bool(accessible)
+        course_code = tools_df[tools_df["Name"] == tool_name].iloc[0]["Required Course"]
+    else:
+        raise ValueError("Not found.")
+
+    if accessible:
+        if course_code:
+            # Accessible but conditional (only by passing the course)
+            result_short = "Conditional"
+            result_description = f"Student can access it only if they take the {course_code}: {course_code_to_name(course_code)}."
+        else:
+            # Accessible
+            result_short = "Yes"
+            result_description = "Student can access it."
+    else:
+        # Not accessible by students. Need staff members!
+        result_short = "No"
+        result_description = "Student cannot access it. Only available to staff memebers. Ask them to do your task for you."
+    result = {
+        "short answer": result_short,
+        "description": result_description
+    }
+    return json.dumps(result)
+
+class SearchMachineLocation(smolagents.tools.Tool):
+    name = "search_machine_location"
     description = (
-        "Retrieves training information for a specific machine and checks its accessibility. The `machine_name` argument should exactly match the machine's name as listed in the system."
+        "Search the machine or tool location in the TechSpark."
     )
     inputs = {
-        "machine_name": {"type": "string", "description": "Name of the machine for which to retrieve training information"},
+        "name": {"type": "string", "description": "Tool or machine name."},
     }
-    output_type = "string"
+    output_type = "object"
 
-    def forward(self, machine_name: str) -> str:
-        tool_info = get_tool_full_profile(machine_name)
-        if tool_info:
-            accessible = tool_info.get("Accessible by Students")
-            required_course_code = tool_info.get("Required Course")
-
-            if accessible is False:
-                # Specific message for not accessible machines, as requested
-                return f"The {machine_name} is NOT accessible by students. Please ask staff for assistance."
-            else: # accessible is True
-                response_parts = [f"The {machine_name} is accessible by students."]
-                if pd.isna(required_course_code):
-                    response_parts.append(f"No specific course is required for the {machine_name}.")
-                else:
-                    course_details = get_course_info(required_course_code)
-                    if course_details:
-                        course_name = course_details.get('Name', 'Unknown Course')
-                        response_parts.append(f"The required training for {machine_name} is '{course_name}' (Course Code: {required_course_code}).")
-                    else:
-                        response_parts.append(f"A course with code '{required_course_code}' is required for {machine_name}, but its details are not found.")
-                return " ".join(response_parts)
-        else:
-            # Message for non-existent machine, as requested
-            return f"Machine '{machine_name}' does not exist."
+    def forward(self, name: str) -> str:
+        return json.dumps(get_tool_location(name))
 
-#refresh_hugginface_repo()  # Only run to refresh the repo
-staff_df, courses_df, tools_df = load_data_from_huggingface()
+class CheckMachineAccessibility(smolagents.tools.Tool):
+    name = "check_machine_accessibility"
+    description = (
+        "Check whether machine or tool is accessible to students. Some are accessible, some need to take a course to become accessible, and some are only available to staff members."
+    )
+    inputs = {
+        "name": {"type": "string", "description": "Tool or machine name."},
+    }
+    output_type = "object"
+
+    def forward(self, name: str) -> str:
+        return json.dumps(is_tool_accessible(name))
+
+# Wikipedia Search (copied from 6AHceBzBXISE)
+class WikipediaSearch(smolagents.Tool):
+    """
+    Create tool for searching Wikipedia
+    """
+    name = "wikipedia_search"
+    description = "Search Wikipedia, the free encyclopedia."
+    inputs = {
+        "query": {"type": "string", "nullable": True, "description": "The search terms"},
+    }
+    output_type = "string"
+
+    def forward(self, query: str | None = None) -> str:
+        if not query:
+            return "Error: 'query' is required."
+        wikipedia_api = WikipediaAPIWrapper(top_k_results=1)
+        answer = wikipedia_api.run(query)
+        return answer
+
+# Agent (copied from 9iwR_e424jfJ)
+techspark_definition = """
+TechSpark is the largest makerspace at CMU (Carnegie Mellon University), located in the College of Engineering.  
+Its mission is to promote a vibrant, student-centric making culture to enhance educational, extracurricular, and research activities across the entire campus community.
+"""
+
+instruction = """
+You are a helpful assistant for the CMU TechSpark facility. Your purpose is to assist users with inquiries related to staff, courses, and tools.
+Use the available tools to find information about staff members, suggest suitable staff based on skills, or provide training information for machines.
+Respond concisely and directly with the information requested by the user, utilizing the output from the tools.
+Which machines to use for a task, and where to find them.
+When you were in doubt, try searching wikipedia to gain more knowledge.
+
+Safety is important. So:
+- When talking about any machines, check whether it is accessbile to students or not.
+- Try to match them to correct staff member specially when you are not sure about your answer or the student work might be dangerous.
+"""
+
+system_prompt = f"""
+{techspark_definition}
+{instruction}
+"""
 
 agent = smolagents.CodeAgent(
     tools=[
-        SearchStaffInformationTool(),
-        FindSuitableStaffTool(),
-        MachineTrainingTool(), # MachineTrainingTool is now defined elsewhere
+        smolagents.FinalAnswerTool(),
+        SearchStaffInformation(),
+        FindSuitableStaff(),
+        SearchCourseInformation(),
+        FindSuitableCourses(),
+        SearchMachineLocation(),
+        CheckMachineAccessibility(),
+        WikipediaSearch(),
     ],
-
-    instructions=(
-        "You are a helpful assistant for the CMU TechSpark facility. Your purpose is to assist users with inquiries related to staff, courses, and tools. "
-        "Use the available tools to find information about staff members, suggest suitable staff based on skills, or provide training information for machines. "
-        "Respond concisely and directly with the information requested by the user, utilizing the output from the tools."
-    ),
-
+    instructions=system_prompt,
     model=model,
-    #name="TechSpark Agent",
     add_base_tools=False,
-    max_steps=12,
-    verbosity_level=2,  # show steps in logs for class demo
+    max_steps=10,
+    verbosity_level=0, # Changed to 0 for deployment
 )
 
 
-
-# --- Page config ---
-st.set_page_config(page_title="TechSpark AI Assistant", layout="wide")
-
-import gradio as gr
-
+# UI (copied from w0g2EzpD7fUy, adjusted for app.py)
 # Minimal Gradio chat
-with gr.Blocks(title="TechSpark Agent",theme= gr.themes.Soft() ) as demo:
-    
-   gr.Markdown(
-        """
-        # 🤖 TechSpark AI Assistant
+with gr.Blocks(title="TechSpark Agent", theme = gr.themes.Soft()) as demo:
+    gr.Markdown("""## 🤖 TechSpark AI Assistant
         Welcome to the TechSpark AI Assistant!  
-
         Ask anything about **TechSpark staff, tools, courses or location of tools**  
-        This assistant is powered by **OpenAI's GPT model** via `smolagents`, accessing accurate information from our curated dataset verified by techspark staff! """
-    )
+        This assistant is powered by **OpenAI's GPT model** via `smolagents`, accessing accurate information from our curated dataset verified by techspark staff!""")
     chat = gr.Chatbot(height=420)
     inp = gr.Textbox(placeholder="Ask your question in natural language.", label="Your question")
 
@@ -547,19 +580,17 @@ with gr.Blocks(title="TechSpark Agent",theme= gr.themes.Soft() ) as demo:
         return "", history
 
     gr.Examples(
-        fn=respond,
         examples=[
             "Who is Ed?",
             "Who to talk to to create a wooden table?",
             "how to access laser cutter"
         ],
-        inputs=[inp]
+        inputs=[inp],
+        outputs=[inp, chat],
+        fn=respond,
+        cache_examples=False, # Set to False for dynamic content or to avoid caching issues
     )
 
     inp.submit(respond, [inp, chat], [inp, chat])
 
-# Launch the demo
-demo.launch()
-
-
-
+demo.launch(share=True)