Upload 4 files

README.md

@@ -1,20 +1,71 @@
----
-title: Cleaneye Garbage Detection
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: 'MCP-enabled AI agent for real-time garbage detection '
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: CleanEye - AI Garbage Detection
+emoji: 🗑️
+colorFrom: green
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.38.0
+app_file: app.py
+pinned: false
+license: mit
+tags:
+  - computer-vision
+  - yolov8
+  - garbage-detection
+  - mcp
+  - sustainability
+---
+
+# 🗑️ CleanEye - AI Garbage Detection Agent
+
+**MCP-enabled AI agent for real-time garbage detection and smart city monitoring**
+
+Built for **MCP 1st Birthday Hackathon** - Track 2: MCP in Action (Agents)
+
+## 🎯 Features
+
+- 🤖 **YOLOv8 Detection** - Trained on 4000+ images
+- 📊 **6 Waste Categories** - Comprehensive classification  
+- 🎯 **Severity Analysis** - Clean, Moderate, Severe levels
+- 🔌 **MCP Integration** - Agent-callable tools for LLMs
+
+## 🚀 How to Use
+
+1. Upload an image containing garbage/waste
+2. Adjust confidence threshold if needed
+3. View results with bounding boxes and statistics
+
+## 📊 Performance
+
+- **Accuracy**: 85%+ mAP
+- **Training Data**: 4000+ annotated images
+- **Categories**: 6 types of waste
+- **Speed**: <1 second per image
+
+## 🌍 Real-World Applications
+
+- 🏙️ Smart city waste monitoring
+- 🤖 Autonomous cleanup robots
+- 📱 Citizen reporting systems
+- 📊 Environmental compliance auditing
+- 🗺️ Waste management optimization
+
+## 🏆 Hackathon Project
+
+**Track**: MCP in Action (Agents)  
+**Developer**: AlBaraa AlOlabi (@AlBaraa63)  
+**Period**: November 14-30, 2025
+
+## 🔗 Links
+
+- **GitHub**: https://github.com/AlBaraa-1/Computer-vision/tree/main/CleanEye
+- **MCP Server**: Full agent implementation with 4 MCP tools
+- **Documentation**: Complete setup and integration guides
+
+## 📄 License
+
+MIT License - Open source and free to use
+
+---
+
+*Making cities cleaner with AI agents* 🌍

Weights/best.pt

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

app.py

@@ -0,0 +1,447 @@
+"""
+CleanEye Streamlit Dashboard - Cloud Optimized
+----------------------------------------------
+Optimized for Hugging Face Spaces and Streamlit Cloud deployment.
+Interactive interface for garbage detection demo.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from typing import Dict, List
+
+import cv2
+import numpy as np
+import streamlit as st
+
+# Cloud-compatible paths
+ROOT_DIR = Path(__file__).resolve().parent
+MODEL_PATH = ROOT_DIR / "Weights" / "best.pt"
+
+# Fallback if Weights folder doesn't exist at same level
+if not MODEL_PATH.exists():
+    MODEL_PATH = Path(__file__).resolve().parent.parent / "Weights" / "best.pt"
+
+# Simple color mapping
+COLORS = {
+    "0": (0, 165, 255),           # Orange
+    "c": (255, 215, 0),            # Gold
+    "garbage": (0, 0, 255),        # Red
+    "garbage_bag": (255, 0, 255),  # Magenta
+    "waste": (0, 255, 0),          # Green
+    "trash": (255, 140, 0),        # Dark Orange
+}
+
+
+@st.cache_resource(show_spinner=False)
+def load_model():
+    """Load YOLOv8 model with caching"""
+    from ultralytics import YOLO
+    
+    if not MODEL_PATH.exists():
+        st.error(f"Model not found at {MODEL_PATH}")
+        st.stop()
+    
+    try:
+        model = YOLO(str(MODEL_PATH))
+        return model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        st.stop()
+
+
+def annotate_image(model, image: np.ndarray, confidence: float) -> Dict:
+    """Run detection and annotate image"""
+    results = model(image, conf=confidence, verbose=False)
+    annotated = image.copy()
+    detections: List[Dict] = []
+
+    for box in results[0].boxes:
+        cls_id = int(box.cls[0])
+        conf = float(box.conf[0])
+        label = model.names[cls_id]
+        color = COLORS.get(label, (255, 255, 255))
+        x1, y1, x2, y2 = map(int, box.xyxy[0])
+
+        # Draw bounding box
+        cv2.rectangle(annotated, (x1, y1), (x2, y2), color, 2)
+        
+        # Draw label
+        cv2.putText(
+            annotated,
+            f"{label} {conf:.0%}",
+            (x1, max(25, y1 - 10)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.7,
+            color,
+            2,
+            cv2.LINE_AA,
+        )
+
+        detections.append({
+            "label": label,
+            "confidence": conf,
+            "bbox": [x1, y1, x2, y2]
+        })
+
+    return {"image": annotated, "detections": detections}
+
+
+def calculate_severity(detections: List[Dict], image_shape: tuple) -> Dict:
+    """Calculate waste severity level"""
+    count = len(detections)
+    h, w = image_shape[:2]
+    image_area = h * w
+    
+    # Calculate total detection area
+    total_detection_area = 0
+    for det in detections:
+        x1, y1, x2, y2 = det["bbox"]
+        total_detection_area += (x2 - x1) * (y2 - y1)
+    
+    # Calculate coverage percentage
+    coverage = (total_detection_area / image_area * 100) if image_area > 0 else 0
+    
+    # Determine severity
+    if count == 0:
+        level = "🟢 Clean"
+        color = "green"
+        recommendation = "Area appears clean. Regular monitoring recommended."
+    elif count < 3 or coverage < 5:
+        level = "🟡 Light"
+        color = "orange"
+        recommendation = "Minor waste detected. Schedule routine cleanup."
+    elif count < 8 or coverage < 15:
+        level = "🟠 Moderate"
+        color = "orange"
+        recommendation = "Moderate waste detected. Schedule cleanup within 24-48 hours."
+    else:
+        level = "🔴 Severe"
+        color = "red"
+        recommendation = "High waste concentration! Immediate cleanup required."
+    
+    return {
+        "level": level,
+        "color": color,
+        "count": count,
+        "coverage": coverage,
+        "recommendation": recommendation
+    }
+
+
+def main():
+    """Main Streamlit app"""
+    
+    # Page configuration
+    st.set_page_config(
+        page_title="CleanEye - AI Garbage Detection",
+        page_icon="🗑️",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Custom CSS
+    st.markdown("""
+        <style>
+        .main-header {
+            font-size: 3rem;
+            color: #2E7D32;
+            text-align: center;
+            margin-bottom: 0;
+        }
+        .sub-header {
+            text-align: center;
+            color: #666;
+            margin-bottom: 2rem;
+        }
+        .metric-card {
+            background: #f0f2f6;
+            padding: 1rem;
+            border-radius: 0.5rem;
+            margin: 0.5rem 0;
+        }
+        .stButton>button {
+            width: 100%;
+            background-color: #2E7D32;
+            color: white;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+    
+    # Header
+    st.markdown('<h1 class="main-header">🗑️ CleanEye</h1>', unsafe_allow_html=True)
+    st.markdown(
+        '<p class="sub-header">AI-Powered Garbage Detection for Smart Cities | Built for MCP Hackathon</p>',
+        unsafe_allow_html=True
+    )
+    
+    # Sidebar
+    with st.sidebar:
+        st.image("https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg", width=200)
+        st.markdown("---")
+        
+        st.markdown("### 🎯 About CleanEye")
+        st.info(
+            "CleanEye uses YOLOv8 trained on 4000+ images to detect and classify "
+            "urban waste in real-time. Built for the **MCP 1st Birthday Hackathon**."
+        )
+        
+        st.markdown("### ⚙️ Detection Settings")
+        confidence = st.slider(
+            "Confidence Threshold",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.25,
+            step=0.05,
+            help="Higher values = fewer but more confident detections"
+        )
+        
+        st.markdown("---")
+        st.markdown("### 📊 Waste Categories")
+        categories = [
+            "🟠 General Waste (0)",
+            "🟡 Containers (c)",
+            "🔴 Garbage",
+            "🟣 Garbage Bags",
+            "🟢 Waste",
+            "🟤 Trash"
+        ]
+        for cat in categories:
+            st.markdown(f"- {cat}")
+        
+        st.markdown("---")
+        st.markdown("### 🔗 Links")
+        st.markdown("- [GitHub Repo](https://github.com/AlBaraa-1/Computer-vision)")
+        st.markdown("- [MCP Documentation](https://github.com/AlBaraa-1/Computer-vision/tree/main/CleanEye)")
+        st.markdown("- [Hackathon Info](https://huggingface.co/spaces/Gradio-Blocks/mcp-1st-birthday)")
+        
+        st.markdown("---")
+        st.markdown("**Developer:** AlBaraa AlOlabi (@AlBaraa63)")
+        st.markdown("**Track:** MCP in Action (Agents)")
+    
+    # Main content
+    tab1, tab2, tab3 = st.tabs(["📸 Image Detection", "📊 About", "🏆 Hackathon"])
+    
+    with tab1:
+        st.markdown("### Upload an Image for Detection")
+        
+        uploaded_file = st.file_uploader(
+            "Choose an image (JPG, PNG, JPEG)",
+            type=["jpg", "jpeg", "png"],
+            help="Upload an image containing garbage or waste"
+        )
+        
+        if uploaded_file is not None:
+            # Read and display original image
+            file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+            image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("#### Original Image")
+                st.image(image_rgb, use_container_width=True)
+            
+            # Run detection
+            with st.spinner("🔍 Detecting garbage..."):
+                model = load_model()
+                result = annotate_image(model, image, confidence)
+                
+                # Calculate severity
+                severity = calculate_severity(result["detections"], image.shape)
+            
+            with col2:
+                st.markdown("#### Detection Results")
+                annotated_rgb = cv2.cvtColor(result["image"], cv2.COLOR_BGR2RGB)
+                st.image(annotated_rgb, use_container_width=True)
+            
+            # Display statistics
+            st.markdown("---")
+            st.markdown("### 📊 Analysis Results")
+            
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total Detections", severity["count"])
+            
+            with col2:
+                st.metric("Coverage", f"{severity['coverage']:.1f}%")
+            
+            with col3:
+                st.metric("Severity", severity["level"])
+            
+            with col4:
+                avg_conf = np.mean([d["confidence"] for d in result["detections"]]) if result["detections"] else 0
+                st.metric("Avg Confidence", f"{avg_conf:.0%}")
+            
+            # Severity assessment
+            st.markdown(f"### {severity['level']} Assessment")
+            if severity["color"] == "green":
+                st.success(severity["recommendation"])
+            elif severity["color"] == "orange":
+                st.warning(severity["recommendation"])
+            else:
+                st.error(severity["recommendation"])
+            
+            # Category breakdown
+            if result["detections"]:
+                st.markdown("### 🏷️ Category Breakdown")
+                
+                category_counts = {}
+                for det in result["detections"]:
+                    label = det["label"]
+                    category_counts[label] = category_counts.get(label, 0) + 1
+                
+                cols = st.columns(len(category_counts))
+                for idx, (category, count) in enumerate(category_counts.items()):
+                    with cols[idx]:
+                        st.metric(category.title(), count)
+                
+                # Detailed detections table
+                with st.expander("📋 View Detailed Detections"):
+                    for idx, det in enumerate(result["detections"], 1):
+                        st.markdown(
+                            f"**Detection {idx}:** {det['label']} "
+                            f"({det['confidence']:.1%} confidence)"
+                        )
+            else:
+                st.info("No garbage detected in this image! 🎉")
+        
+        else:
+            # Show example placeholder
+            st.info("👆 Upload an image to start detecting garbage")
+            st.markdown("#### 💡 Tips for Best Results:")
+            st.markdown("""
+            - Use clear, well-lit images
+            - Ensure garbage is visible and not too far away
+            - Multiple items can be detected in a single image
+            - Adjust confidence threshold if needed (sidebar)
+            """)
+    
+    with tab2:
+        st.markdown("## 🎯 About CleanEye")
+        
+        st.markdown("""
+        **CleanEye** is an MCP-enabled AI agent for real-time garbage detection and 
+        smart city monitoring. It uses YOLOv8 computer vision to identify and classify 
+        urban waste, helping cities optimize cleanup operations and reduce environmental impact.
+        """)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("### 🚀 Key Features")
+            st.markdown("""
+            - ✅ **6 Waste Categories** detected
+            - ✅ **Real-time Detection** (<1 second)
+            - ✅ **85%+ Accuracy** on test set
+            - ✅ **4000+ Training Images**
+            - ✅ **MCP Integration** for AI agents
+            - ✅ **Severity Assessment** algorithm
+            """)
+        
+        with col2:
+            st.markdown("### 🌍 Use Cases")
+            st.markdown("""
+            - 🏙️ Smart city waste monitoring
+            - 🤖 Autonomous cleanup robots
+            - 📱 Citizen reporting apps
+            - 📊 Environmental compliance
+            - 🗺️ Waste mapping systems
+            - 🚛 Optimized collection routes
+            """)
+        
+        st.markdown("---")
+        st.markdown("### 🏗️ Technology Stack")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.markdown("**Computer Vision**")
+            st.markdown("- YOLOv8 (Ultralytics)")
+            st.markdown("- OpenCV")
+            st.markdown("- PyTorch")
+        
+        with col2:
+            st.markdown("**Agent Framework**")
+            st.markdown("- Model Context Protocol (MCP)")
+            st.markdown("- 4 Agent-callable tools")
+            st.markdown("- LLM integration ready")
+        
+        with col3:
+            st.markdown("**Deployment**")
+            st.markdown("- Streamlit Dashboard")
+            st.markdown("- Hugging Face Spaces")
+            st.markdown("- Python 3.12")
+    
+    with tab3:
+        st.markdown("## 🏆 MCP 1st Birthday Hackathon")
+        
+        st.markdown("""
+        This project was built for the **MCP 1st Birthday Hackathon** 
+        (November 14-30, 2025), hosted by Anthropic and Gradio.
+        """)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("### 🎯 Track Selection")
+            st.info("**Track 2: MCP in Action (Agents)**")
+            st.markdown("""
+            CleanEye demonstrates how AI agents can sense and act in the real world 
+            through computer vision, combining perception with decision-making for 
+            environmental sustainability.
+            """)
+        
+        with col2:
+            st.markdown("### 💡 Innovation")
+            st.markdown("""
+            - First garbage detection system with MCP
+            - Agent-to-agent communication via MCP tools
+            - Real environmental impact potential
+            - Scalable to entire smart city networks
+            """)
+        
+        st.markdown("---")
+        
+        st.markdown("### 🔌 MCP Tools Available")
+        st.markdown("""
+        CleanEye exposes 4 MCP tools that AI agents can call:
+        
+        1. **`detect_garbage_image`** - Detect garbage in images with bounding boxes
+        2. **`get_detection_statistics`** - Access real-time detection stats
+        3. **`analyze_area_severity`** - Assess cleanup priority levels
+        4. **`get_detection_reports`** - Retrieve historical detection data
+        """)
+        
+        st.markdown("### 📊 Project Impact")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Training Images", "4,000+")
+        
+        with col2:
+            st.metric("Model Accuracy", "85%+")
+        
+        with col3:
+            st.metric("Detection Speed", "<1 sec")
+        
+        st.markdown("---")
+        
+        st.markdown("### 👨‍💻 Developer")
+        st.markdown("""
+        **AlBaraa AlOlabi**
+        - 🤗 Hugging Face: [@AlBaraa63](https://huggingface.co/AlBaraa63)
+        - 💻 GitHub: [@AlBaraa-1](https://github.com/AlBaraa-1)
+        - 📧 Email: 666645@gmail.com
+        """)
+        
+        st.markdown("---")
+        st.success("🌍 Making cities cleaner with AI agents!")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+streamlit==1.38.0
+ultralytics==8.2.74
+opencv-python-headless==4.10.0.84
+numpy==1.26.4
+pillow==10.4.0
+torch==2.3.1
+torchvision==0.18.1
+pandas==2.2.2
+pyyaml==6.0.2