Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,36 @@
+# Use NVIDIA CUDA base image for GPU support
+FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
+
+# Set working directory
+WORKDIR /app
+
+# Install Python 3.10 and system dependencies
+RUN apt-get update && apt-get install -y \
+    python3.10 \
+    python3-pip \
+    python3.10-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set Python 3.10 as default
+RUN update-alternatives --install /usr/bin/python python /usr/bin/python3.10 1
+RUN update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1
+
+# Upgrade pip
+RUN pip install --no-cache-dir --upgrade pip
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY main.py .
+
+# Expose port 7860 (HuggingFace Spaces default)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Run the FastAPI app with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -1,10 +1,109 @@
----
-title: Yyuujhu
-emoji: 📚
-colorFrom: gray
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: FastAPI NVIDIA A10G
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: apache-2.0
+suggested_hardware: a10g-large
+suggested_storage: large
+---
+
+# FastAPI Service with NVIDIA A10G Large GPU
+
+High-performance FastAPI service running on NVIDIA A10G Large GPU (24GB VRAM).
+
+## 🚀 Features
+
+- **FastAPI Framework**: Modern, fast web framework for building APIs
+- **Uvicorn Server**: Lightning-fast ASGI server with uvicorn[standard]
+- **GPU Acceleration**: NVIDIA A10G Large (24GB VRAM, 24 vCPU, 96GB RAM)
+- **Docker SDK**: Containerized deployment for reliability
+- **PyTorch Support**: Full CUDA support for ML workloads
+- **Auto-scaling**: Optimized for high-performance workloads
+
+## 📊 Hardware Specs
+
+- **GPU**: NVIDIA A10G Large (24GB VRAM)
+- **CPU**: 24 vCPUs
+- **RAM**: 96GB
+- **Storage**: Large (100GB)
+- **Cost**: ~$3.15/hour
+
+## 🔗 API Endpoints
+
+### Root
+```
+GET /
+```
+Returns API information and available endpoints.
+
+### Health Check
+```
+GET /health
+```
+Returns service health status and GPU availability.
+
+### GPU Information
+```
+GET /gpu-info
+```
+Returns detailed GPU specifications and memory information.
+
+### Process Text
+```
+POST /process
+Content-Type: application/json
+
+{
+  "text": "Your text here",
+  "max_length": 100
+}
+```
+Example text processing endpoint.
+
+## 🛠️ API Documentation
+
+Interactive API documentation available at:
+- Swagger UI: `/docs`
+- ReDoc: `/redoc`
+
+## 🔧 Configuration
+
+The service runs on port 7860 (HuggingFace Spaces default) with:
+- Single worker process for GPU efficiency
+- CORS enabled for cross-origin requests
+- Automatic GPU detection and utilization
+
+## 📦 Dependencies
+
+- FastAPI 0.104.1
+- Uvicorn[standard] 0.24.0
+- PyTorch 2.1.0 (CUDA support)
+- Pydantic 2.5.0
+
+## 🚀 Usage
+
+```python
+import requests
+
+# Health check
+response = requests.get("https://huggingface.co/spaces/Speedofmastery/yyuujhu")
+print(response.json())
+
+# GPU info
+gpu_info = requests.get("https://huggingface.co/spaces/Speedofmastery/yyuujhu/gpu-info")
+print(gpu_info.json())
+
+# Process text
+result = requests.post(
+    "https://huggingface.co/spaces/Speedofmastery/yyuujhu/process",
+    json={"text": "Hello World", "max_length": 100}
+)
+print(result.json())
+```
+
+## 📝 License
+
+Apache 2.0

main.py

@@ -0,0 +1,125 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import torch
+import os
+
+# GPU Verification on startup
+print("=" * 50)
+print("🚀 OpenManus FastAPI - GPU Verification")
+print("=" * 50)
+print(f"Is CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"CUDA device count: {torch.cuda.device_count()}")
+    print(f"CUDA device: {torch.cuda.get_device_name(torch.cuda.current_device())}")
+    print(f"CUDA version: {torch.version.cuda}")
+    print(f"PyTorch version: {torch.__version__}")
+else:
+    print("⚠️  WARNING: CUDA not available - running on CPU")
+print("=" * 50)
+
+app = FastAPI(
+    title="OpenManus FastAPI",
+    description="High-performance FastAPI service with NVIDIA A10G GPU support",
+    version="1.0.0",
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Request models
+class TextRequest(BaseModel):
+    text: str
+    max_length: int = 100
+
+
+class HealthResponse(BaseModel):
+    status: str
+    gpu_available: bool
+    cuda_devices: int
+    device_name: str = None
+
+
+@app.get("/", response_model=dict)
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "OpenManus FastAPI Service",
+        "version": "1.0.0",
+        "endpoints": {"health": "/health", "gpu_info": "/gpu-info", "docs": "/docs"},
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint with GPU status"""
+    gpu_available = torch.cuda.is_available()
+    cuda_devices = torch.cuda.device_count() if gpu_available else 0
+    device_name = (
+        torch.cuda.get_device_name(0) if gpu_available and cuda_devices > 0 else None
+    )
+
+    return HealthResponse(
+        status="healthy",
+        gpu_available=gpu_available,
+        cuda_devices=cuda_devices,
+        device_name=device_name,
+    )
+
+
+@app.get("/gpu-info")
+async def gpu_info():
+    """Detailed GPU information"""
+    if not torch.cuda.is_available():
+        return {"error": "CUDA not available"}
+
+    info = {
+        "cuda_available": True,
+        "device_count": torch.cuda.device_count(),
+        "devices": [],
+    }
+
+    for i in range(torch.cuda.device_count()):
+        device_props = torch.cuda.get_device_properties(i)
+        info["devices"].append(
+            {
+                "id": i,
+                "name": torch.cuda.get_device_name(i),
+                "total_memory_gb": round(device_props.total_memory / 1024**3, 2),
+                "major": device_props.major,
+                "minor": device_props.minor,
+                "multi_processor_count": device_props.multi_processor_count,
+            }
+        )
+
+    return info
+
+
+@app.post("/process")
+async def process_text(request: TextRequest):
+    """Example endpoint for text processing"""
+    try:
+        # Example processing logic
+        result = {
+            "input": request.text,
+            "length": len(request.text),
+            "max_length": request.max_length,
+            "processed": request.text.upper(),  # Simple transformation
+            "gpu_used": torch.cuda.is_available(),
+        }
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run("main:app", host="0.0.0.0", port=port, reload=False, workers=1)

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6
+huggingface-hub>=0.20.0
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch==2.1.0+cu118
+torchaudio==2.1.0+cu118
+torchvision==0.16.0+cu118