Initial Commit

.gitignore

@@ -0,0 +1,5 @@
+.env
+venv/
+.venv/
+tests/
+__pycache__/

Dockerfile

@@ -0,0 +1,28 @@
+# Base image
+FROM python:3.11-slim
+
+# Environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirement file and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source code
+COPY . .
+
+# Expose port for FastMCP
+EXPOSE 7860
+
+# Start the FastMCP server
+CMD ["python", "app.py"]

TRAINING DATA/students/Ahmed/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024006",
+  "name": "Ahmed Hassan",
+  "email": "ahmed.hassan@university.edu",
+  "department": "Urban Planning & Computer Science",
+  "project_title": "AI-Optimized Traffic Flow Management System",
+  "submission_date": "2024-01-28",
+  "academic_year": "Third Year",
+  "supervisor": "Dr. Lisa Wang",
+  "keywords": ["smart cities", "traffic optimization", "urban planning", "AI"],
+  "grade": "A-",
+  "word_count": 2350
+}

TRAINING DATA/students/Ahmed/summary.txt

@@ -0,0 +1,4 @@
+AI system reduces urban traffic congestion by 32% in simulations.
+Uses real-time traffic camera data and historical patterns.
+Dynamic traffic light timing optimization algorithm.
+Scalable solution for municipalities with existing camera infrastructure.

TRAINING DATA/students/Aisha/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024001",
+  "name": "Aisha Khan",
+  "email": "aisha.khan@university.edu",
+  "department": "Computer Science & Medicine",
+  "project_title": "AI-Powered Early Detection of Diabetic Retinopathy",
+  "submission_date": "2024-01-15",
+  "academic_year": "Final Year",
+  "supervisor": "Dr. Sarah Chen",
+  "keywords": ["medical AI", "computer vision", "healthcare", "deep learning"],
+  "grade": "A",
+  "word_count": 2450
+}

TRAINING DATA/students/Aisha/summary.txt

@@ -0,0 +1,5 @@
+Project develops CNN model for early diabetic retinopathy detection 
+using retinal fundus images. Achieved 94.3% accuracy on test dataset.
+Implements real-time screening system with 2-second processing time.
+Potential impact: Early intervention for diabetic patients.
+Technology: Python, TensorFlow, OpenCV, Medical Imaging Dataset.

TRAINING DATA/students/David/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024008",
+  "name": "David Miller",
+  "email": "david.miller@university.edu",
+  "department": "Environmental Science",
+  "project_title": "Real-time Air Quality Monitoring Network with Predictive Analytics",
+  "submission_date": "2024-02-05",
+  "academic_year": "Third Year",
+  "supervisor": "Dr. Patricia Brown",
+  "keywords": ["environmental monitoring", "air quality", "IoT", "predictive analytics"],
+  "grade": "B+",
+  "word_count": 2100
+}

TRAINING DATA/students/David/summary.txt

@@ -0,0 +1,4 @@
+Deployed network of 15 low-cost air quality sensors across city.
+Real-time pollution mapping and 24-hour prediction accuracy of 89%.
+Public dashboard with health recommendations.
+Early warning system for schools and hospitals during poor air quality.

TRAINING DATA/students/Kenji/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024004",
+  "name": "Kenji Tanaka",
+  "email": "kenji.tanaka@university.edu",
+  "department": "Robotics Engineering",
+  "project_title": "Autonomous Delivery Robot with Obstacle Avoidance",
+  "submission_date": "2024-01-22",
+  "academic_year": "Second Year",
+  "supervisor": "Dr. Emily Zhang",
+  "keywords": ["robotics", "autonomous systems", "computer vision", "path planning"],
+  "grade": "B+",
+  "word_count": 1950
+}

TRAINING DATA/students/Kenji/summary.txt

@@ -0,0 +1,4 @@
+Developed autonomous robot for campus package delivery.
+Uses LIDAR and camera fusion for obstacle detection and avoidance.
+Successfully completed 50 test deliveries across campus.
+Maximum payload: 5kg, Battery life: 6 hours continuous operation.

TRAINING DATA/students/Lisa/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024007",
+  "name": "Lisa Johnson",
+  "email": "lisa.johnson@university.edu",
+  "department": "Education Technology",
+  "project_title": "Personalized Learning Platform Using Adaptive Algorithms",
+  "submission_date": "2024-02-01",
+  "academic_year": "Final Year",
+  "supervisor": "Dr. David Lee",
+  "keywords": ["edtech", "adaptive learning", "personalization", "education"],
+  "grade": "A",
+  "word_count": 2700
+}

TRAINING DATA/students/Lisa/summary.txt

@@ -0,0 +1,4 @@
+Adaptive learning platform personalizes content based on student performance.
+Tested with 200 students showing 45% improvement in learning outcomes.
+Real-time assessment and content recommendation engine.
+Mobile-first design with offline capability for remote areas.

TRAINING DATA/students/Maria/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024003",
+  "name": "Maria Gonzalez",
+  "email": "maria.gonzalez@university.edu",
+  "department": "Renewable Energy Engineering",
+  "project_title": "Machine Learning Optimization of Solar Panel Efficiency",
+  "submission_date": "2024-01-20",
+  "academic_year": "Final Year",
+  "supervisor": "Dr. James Wilson",
+  "keywords": ["solar energy", "machine learning", "optimization", "clean tech"],
+  "grade": "A",
+  "word_count": 2800
+}

TRAINING DATA/students/Maria/summary.txt

@@ -0,0 +1,4 @@
+ML model predicts optimal solar panel angles based on weather patterns.
+Increases energy generation by 18% compared to fixed-angle systems.
+Real-time adjustment system using servo motors and weather API.
+Cost-effective solution for residential solar installations.

TRAINING DATA/students/Mark/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024010",
+  "name": "Mark Thompson",
+  "email": "mark.thompson@university.edu",
+  "department": "Supply Chain Management",
+  "project_title": "Blockchain-based Supply Chain Transparency System",
+  "submission_date": "2024-02-12",
+  "academic_year": "Third Year",
+  "supervisor": "Dr. Nancy Chen",
+  "keywords": ["blockchain", "supply chain", "transparency", "logistics"],
+  "grade": "A-",
+  "word_count": 2300
+}

TRAINING DATA/students/Mark/summary.txt

@@ -0,0 +1,4 @@
+Blockchain system provides end-to-end supply chain visibility.
+Reduces counterfeit products by tracking authentic product journey.
+Implemented for agricultural supply chain with 50+ participants.
+Real-time tracking and automated smart contracts for payments.

TRAINING DATA/students/Priya/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024009",
+  "name": "Priya Patel",
+  "email": "priya.patel@university.edu",
+  "department": "Biomedical Engineering",
+  "project_title": "Wearable ECG Monitor with Real-time Arrhythmia Detection",
+  "submission_date": "2024-02-08",
+  "academic_year": "Final Year",
+  "supervisor": "Dr. Andrew Taylor",
+  "keywords": ["wearable tech", "health monitoring", "ECG", "medical devices"],
+  "grade": "A",
+  "word_count": 2550
+}

TRAINING DATA/students/Priya/summary.txt

@@ -0,0 +1,4 @@
+Low-cost wearable ECG monitor detects arrhythmias in real-time.
+96% accuracy compared to clinical-grade equipment.
+Continuous monitoring with emergency alert system to caregivers.
+Battery life: 72 hours, Water-resistant design for daily use.

TRAINING DATA/students/Rahul/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024002",
+  "name": "Rahul Sharma",
+  "email": "rahul.sharma@university.edu",
+  "department": "Agricultural Engineering",
+  "project_title": "IoT-Based Smart Irrigation System with Crop Health Monitoring",
+  "submission_date": "2024-01-18",
+  "academic_year": "Third Year",
+  "supervisor": "Dr. Michael Brown",
+  "keywords": ["IoT", "precision agriculture", "sensors", "water conservation"],
+  "grade": "A-",
+  "word_count": 2200
+}

TRAINING DATA/students/Rahul/summary.txt

@@ -0,0 +1,4 @@
+IoT system monitors soil moisture, temperature, and crop health.
+Automated irrigation reduces water usage by 40% compared to traditional methods.
+Real-time alerts for farmers via mobile application.
+Deployed prototype on 5-acre test farm with successful results.

TRAINING DATA/students/Sofia/metadata.json

@@ -0,0 +1,13 @@
+{
+  "student_id": "STU2024005",
+  "name": "Sofia Rodriguez",
+  "email": "sofia.rodriguez@university.edu",
+  "department": "Computational Finance",
+  "project_title": "Predictive Analytics for Stock Market Trends Using Sentiment Analysis",
+  "submission_date": "2024-01-25",
+  "academic_year": "Final Year",
+  "supervisor": "Dr. Robert Kim",
+  "keywords": ["financial analytics", "sentiment analysis", "trading", "NLP"],
+  "grade": "A",
+  "word_count": 2600
+}

TRAINING DATA/students/Sofia/summary.txt

@@ -0,0 +1,4 @@
+Combines news sentiment analysis with technical indicators for stock prediction.
+Achieved 67% accuracy in predicting 5-day price movements.
+Real-time dashboard for investment decision support.
+Backtested on S&P 500 data from 2018-2023 showing consistent performance.

app.py

@@ -0,0 +1,265 @@
+import os
+import json
+import uuid
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from dotenv import load_dotenv
+load_dotenv()
+
+from fastmcp import FastMCP
+
+# -------- Config: data root resolution (robust, works locally & on HF) --------
+def resolve_data_root() -> Path:
+    # 1) Env var wins if set
+    env = os.getenv("DATA_ROOT")
+    if env:
+        p = Path(env).expanduser().resolve()
+        if p.exists():
+            return p
+
+    # 2) Try common repo-relative locations (first that exists wins)
+    candidates = [
+        Path.cwd() / "TRAINING DATA",   # your exact folder with space
+        Path.cwd() / "training_data",
+        Path.cwd() / "data",
+    ]
+    for c in candidates:
+        if c.exists():
+            return c.resolve()
+
+    # 3) Last resort: create ./TRAINING DATA to avoid crashes
+    fallback = Path.cwd() / "TRAINING DATA"
+    fallback.mkdir(parents=True, exist_ok=True)
+    return fallback.resolve()
+
+DATA_ROOT: Path = resolve_data_root()
+STUDENTS_DIR: Path = DATA_ROOT / "students"
+
+# -------- Small utilities --------
+def _receipt() -> Dict[str, Any]:
+    return {
+        "tool_used": True,
+        "server_time": datetime.now(timezone.utc).isoformat(),
+        "request_id": str(uuid.uuid4()),
+        "data_root": str(DATA_ROOT),
+    }
+
+def _norm(s: Optional[str]) -> str:
+    return (s or "").strip()
+
+def _ci_contains(hay: Optional[str], needle: Optional[str]) -> bool:
+    return _norm(needle).lower() in _norm(hay).lower()
+
+# -------- Load metadata (from DATA_ROOT/students/*/metadata.json and/or DATA_ROOT/metadata.json) --------
+# In-memory index: { student_name_lower: {"name":..., "email":..., ...} }
+_METADATA_BY_STUDENT: Dict[str, Dict[str, Any]] = {}
+
+def _load_all_metadata() -> None:
+    global _METADATA_BY_STUDENT
+    _METADATA_BY_STUDENT = {}
+
+    # A) Per-student folders
+    if STUDENTS_DIR.exists():
+        for student_dir in sorted(STUDENTS_DIR.iterdir()):
+            if not student_dir.is_dir():
+                continue
+            meta_file = student_dir / "metadata.json"
+            if meta_file.exists():
+                try:
+                    data = json.loads(meta_file.read_text(encoding="utf-8"))
+                except Exception:
+                    continue
+                # Ensure a 'name' field; default to directory name
+                name = data.get("name") or student_dir.name
+                data["name"] = name
+                data["__path"] = str(meta_file)
+                _METADATA_BY_STUDENT[_norm(name).lower()] = data
+
+    # B) Optional top-level metadata.json (may contain a list or a dict of students)
+    top_meta = DATA_ROOT / "metadata.json"
+    if top_meta.exists():
+        try:
+            blob = json.loads(top_meta.read_text(encoding="utf-8"))
+            # Accept either:
+            #  - {"students":[{...},{...}]}
+            #  - [{"name":..., ...}, ...]
+            #  - {"<name>": {...}, ...}
+            candidates: List[Dict[str, Any]] = []
+            if isinstance(blob, dict) and "students" in blob and isinstance(blob["students"], list):
+                candidates = blob["students"]
+            elif isinstance(blob, list):
+                candidates = blob
+            elif isinstance(blob, dict):
+                for k, v in blob.items():
+                    if isinstance(v, dict):
+                        v.setdefault("name", k)
+                        candidates.append(v)
+
+            for data in candidates:
+                name = data.get("name")
+                if not name:
+                    continue
+                data["__path"] = str(top_meta)
+                _METADATA_BY_STUDENT[_norm(name).lower()] = data
+        except Exception:
+            pass
+
+# Initial load
+_load_all_metadata()
+
+# -------- OpenAI embeddings (for Pinecone RAG) --------
+from openai import OpenAI
+_openai_client: Optional[OpenAI] = None
+_EMBED_MODEL = os.getenv("OPENAI_EMBEDDING_MODEL", "text-embedding-3-small")
+def _embed(texts: List[str]) -> List[List[float]]:
+    """
+    Embed a batch of strings using OpenAI embeddings.
+    """
+    global _openai_client
+    if _openai_client is None:
+        _openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    # OpenAI Python SDK v1 returns .data with embeddings in order
+    resp = _openai_client.embeddings.create(model=_EMBED_MODEL, input=texts)
+    return [d.embedding for d in resp.data]
+
+# -------- Pinecone client --------
+from pinecone import Pinecone as _Pinecone
+
+_pine: Optional[_Pinecone] = None
+def _pc() -> _Pinecone:
+    global _pine
+    if _pine is None:
+        api_key = os.getenv("PINECONE_API_KEY")
+        if not api_key:
+            raise RuntimeError("PINECONE_API_KEY not set")
+        _pine = _Pinecone(api_key=api_key)
+    return _pine
+
+def _pine_index():
+    pc = _pc()
+    index_name = os.getenv("PINECONE_INDEX_NAME")
+    if not index_name:
+        raise RuntimeError("PINECONE_INDEX_NAME not set")
+    return pc.Index(index_name)
+
+# -------- MCP server --------
+mcp = FastMCP("ProjectRAGServer")
+
+@mcp.tool
+def add(a: int, b: int) -> Dict[str, Any]:
+    """Add two numbers."""
+    return {"result": int(a) + int(b), "_receipt": _receipt()}
+
+@mcp.tool
+def list_students() -> Dict[str, Any]:
+    """Return all known student names."""
+    names = sorted(v.get("name") for v in _METADATA_BY_STUDENT.values() if v.get("name"))
+    return {"students": names, "count": len(names), "_receipt": _receipt()}
+
+@mcp.tool
+def get_student_metadata(name: str) -> Dict[str, Any]:
+    """Return full metadata for a student by name (case-insensitive)."""
+    key = _norm(name).lower()
+    data = _METADATA_BY_STUDENT.get(key)
+    if not data:
+        return {"error": f"Student '{name}' not found.", "_receipt": _receipt()}
+    return {"metadata": data, "_receipt": _receipt()}
+
+@mcp.tool
+def get_student_email(name: str) -> Dict[str, Any]:
+    """Return the email address for a student by name."""
+    key = _norm(name).lower()
+    data = _METADATA_BY_STUDENT.get(key)
+    if not data:
+        return {"error": f"Student '{name}' not found.", "_receipt": _receipt()}
+    email = data.get("email")
+    if not email:
+        return {"error": f"No email in metadata for '{data.get('name')}'.", "_receipt": _receipt()}
+    return {"name": data.get("name"), "email": email, "_receipt": _receipt()}
+
+@mcp.tool
+def search_student_by_field(field: str, value: str) -> Dict[str, Any]:
+    """
+    Case-insensitive contains() search across any metadata field.
+    Example: field='department', value='Computer'
+    """
+    f = _norm(field)
+    val = _norm(value)
+    if not f:
+        return {"error": "Field must be provided.", "_receipt": _receipt()}
+    matches: List[Dict[str, Any]] = []
+    for meta in _METADATA_BY_STUDENT.values():
+        if f not in meta:
+            continue
+        v = meta.get(f)
+        # Allow both strings and list-of-strings
+        if isinstance(v, str) and _ci_contains(v, val):
+            matches.append({"name": meta.get("name"), "match_value": v, "metadata": meta})
+        elif isinstance(v, list) and any(_ci_contains(x, val) for x in v if isinstance(x, str)):
+            matches.append({"name": meta.get("name"), "match_value": v, "metadata": meta})
+    return {"matches": matches, "count": len(matches), "_receipt": _receipt()}
+
+@mcp.tool
+def reload_metadata() -> Dict[str, Any]:
+    """Reload metadata from disk (useful after updating files)."""
+    t0 = time.time()
+    _load_all_metadata()
+    dt = round((time.time() - t0) * 1000.0, 2)
+    return {"ok": True, "students": len(_METADATA_BY_STUDENT), "ms": dt, "_receipt": _receipt()}
+
+@mcp.tool
+def search_rag(query: str, top_k: int = 3, namespace: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Semantic search over your Pinecone index using OpenAI embeddings.
+    Returns top_k matches with metadata.
+    Env required: OPENAI_API_KEY, PINECONE_API_KEY, PINECONE_INDEX_NAME
+    Optional: OPENAI_EMBEDDING_MODEL (default: text-embedding-3-small)
+    """
+    q = _norm(query)
+    if not q:
+        return {"error": "Query must not be empty.", "_receipt": _receipt()}
+
+    try:
+        vec = _embed([q])[0]
+    except Exception as e:
+        return {"error": f"Embedding failed: {e}", "_receipt": _receipt()}
+
+    try:
+        idx = _pine_index()
+    except Exception as e:
+        return {"error": f"Pinecone init failed: {e}", "_receipt": _receipt()}
+
+    try:
+        resp = idx.query(
+            vector=vec,
+            top_k=max(1, min(int(top_k), 50)),
+            include_metadata=True,
+            namespace=namespace or None,
+        )
+    except Exception as e:
+        return {"error": f"Pinecone query failed: {e}", "_receipt": _receipt()}
+
+    results = []
+    for m in getattr(resp, "matches", []) or []:
+        results.append({
+            "id": getattr(m, "id", None),
+            "score": getattr(m, "score", None),
+            "metadata": getattr(m, "metadata", None),
+        })
+
+    return {
+        "query": q,
+        "model": _EMBED_MODEL,
+        "top_k": top_k,
+        "results": results,
+        "_receipt": _receipt(),
+    }
+
+# ---- HTTP runner for HF Space / local run ----
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    # HTTP, path /mcp
+    mcp.run(transport="http", host="0.0.0.0", port=port, path="/mcp")

requirements.txt

@@ -0,0 +1,9 @@
+fastmcp
+fastapi
+uvicorn
+httpx
+pandas
+python-dateutil
+pinecone
+openai
+python-dotenv

space.yaml

@@ -0,0 +1,2 @@
+sdk: docker
+app_port: 7860