Add initial project structure with Docker, FastAPI, and Ollama integration

- Create Dockerfile for FastAPI and Ollama services
- Set up docker-compose for service orchestration
- Implement FastAPI application for fashion analysis
- Add Makefile for common development commands
- Include .gitignore for Python and Docker files
- Create README files for project and Docker setup
- Add startup scripts for Ollama and FastAPI
- Define requirements for Python dependencies

.gitignore

@@ -0,0 +1,212 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, it is generally recommended to include the cache and path variables, but
+#  exclude the .idea/ folder.
+#  https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+.idea/
+
+# VS Code
+.vscode/
+
+# FastAPI specific
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Log files
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Docker
+.dockerignore
+docker-compose.override.yml
+
+# Alembic (database migrations)
+alembic/versions/*.py
+!alembic/versions/
+alembic.ini
+
+# Static files (if using)
+static/
+media/
+
+# Configuration files with sensitive data
+config.ini
+settings.ini
+.secrets
+
+# API documentation generated files
+docs/build/
+
+#Virtual Environment
+venv/
+ollama/

DockerFile

@@ -0,0 +1,43 @@
+FROM ollama/ollama:0.9.2
+
+# Install Python and dependencies with security updates
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    curl \
+    && apt-get upgrade -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Create non-root user for security
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install Python packages
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Copy your FastAPI app
+COPY fast.py .
+COPY start.sh .
+RUN chmod +x start.sh
+
+# Change ownership to non-root user
+RUN chown -R appuser:appuser /app
+
+# Set environment variables
+ENV OLLAMA_HOST=0.0.0.0:11434
+ENV OLLAMA_ORIGINS=*
+
+# Expose ports
+EXPOSE 7860
+EXPOSE 11434
+
+# Switch to non-root user
+USER appuser
+
+# Start both Ollama and FastAPI
+ENTRYPOINT []
+CMD ["bash", "/app/start.sh"]

Dockerfile.fastapi

@@ -0,0 +1,41 @@
+FROM python:3.11-slim
+
+# Install system dependencies with security updates
+RUN apt-get update && apt-get install -y \
+    curl \
+    && apt-get upgrade -y \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Create non-root user for security
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install Python packages
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir --upgrade pip && \
+    pip3 install --no-cache-dir -r requirements.txt
+
+# Copy FastAPI application
+COPY fast.py .
+
+# Create logs directory
+RUN mkdir -p /app/logs
+
+# Change ownership to non-root user
+RUN chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start FastAPI
+CMD ["python3", "-m", "uvicorn", "fast:app", "--host", "0.0.0.0", "--port", "7860"]

Makefile

@@ -0,0 +1,72 @@
+.PHONY: help build up down logs clean restart status health
+
+# Default target
+help:
+	@echo "Fashion Analyzer - Docker Compose Commands"
+	@echo ""
+	@echo "Available commands:"
+	@echo "  build     - Build all services"
+	@echo "  up        - Start all services"
+	@echo "  down      - Stop all services"
+	@echo "  logs      - View logs from all services"
+	@echo "  clean     - Stop services and remove volumes"
+	@echo "  restart   - Restart all services"
+	@echo "  status    - Show service status"
+	@echo "  health    - Check application health"
+	@echo "  shell-api - Open shell in FastAPI container"
+	@echo "  shell-ollama - Open shell in Ollama container"
+
+# Build all services
+build:
+	docker-compose build
+
+# Start all services
+up:
+	docker-compose up -d
+	@echo "Services starting... Check status with 'make status'"
+	@echo "Web interface will be available at: http://localhost:7860"
+
+# Stop all services
+down:
+	docker-compose down
+
+# View logs
+logs:
+	docker-compose logs -f
+
+# Clean everything (including volumes)
+clean:
+	docker-compose down -v --remove-orphans
+	docker system prune -f
+
+# Restart all services
+restart: down up
+
+# Show service status
+status:
+	docker-compose ps
+
+# Check application health
+health:
+	@echo "Checking Ollama health..."
+	@curl -s http://localhost:11434/api/tags > /dev/null && echo "✅ Ollama: Healthy" || echo "❌ Ollama: Unhealthy"
+	@echo "Checking FastAPI health..."
+	@curl -s http://localhost:7860/health > /dev/null && echo "✅ FastAPI: Healthy" || echo "❌ FastAPI: Unhealthy"
+
+# Open shell in FastAPI container
+shell-api:
+	docker-compose exec fastapi bash
+
+# Open shell in Ollama container
+shell-ollama:
+	docker-compose exec ollama bash
+
+# Development commands
+dev-build:
+	docker-compose build --no-cache
+
+dev-logs-api:
+	docker-compose logs -f fastapi
+
+dev-logs-ollama:
+	docker-compose logs -f ollama

README copy.md

@@ -0,0 +1,162 @@
+# OutFitly API
+
+A FastAPI-based web application for outfit management and recommendations.
+
+## Features
+
+- Fast and modern API built with FastAPI
+- Image processing capabilities with Pillow
+- Data validation with Pydantic
+- HTTP client functionality with requests
+- Automatic API documentation
+
+## Prerequisites
+
+- Python 3.8 or higher
+- pip (Python package installer)
+
+## Installation
+
+1. **Clone the repository**
+
+   ```bash
+   git clone <repository-url>
+   cd OutFitly
+   ```
+
+2. **Create a virtual environment**
+
+   ```bash
+   python -m venv ollama
+
+   # On Windows
+   ollama\Scripts\activate
+
+   # On macOS/Linux
+   source ollama/bin/activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r fastapi_requirements.txt
+   ```
+
+## Usage
+
+### Running the Development Server
+
+Start the FastAPI development server:
+
+```bash
+uvicorn main:app --reload
+```
+
+The API will be available at:
+
+- **API**: http://localhost:8000
+- **Interactive API docs (Swagger UI)**: http://localhost:8000/docs
+- **Alternative API docs (ReDoc)**: http://localhost:8000/redoc
+
+### Running in Production
+
+For production deployment:
+
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+## API Documentation
+
+Once the server is running, you can access the interactive API documentation at:
+
+- Swagger UI: http://localhost:8000/docs
+- ReDoc: http://localhost:8000/redoc
+
+## Project Structure
+
+```
+OutFitly/
+├── AI/
+│   ├── fastapi_requirements.txt
+│   └── [other AI-related files]
+├── main.py                 # FastAPI application entry point
+├── requirements.txt        # Python dependencies
+├── .gitignore             # Git ignore rules
+└── README.md              # This file
+```
+
+## Dependencies
+
+- **FastAPI** (0.104.1): Modern, fast web framework for building APIs
+- **Uvicorn** (0.24.0): ASGI server for running FastAPI applications
+- **Pillow** (10.0.1): Python Imaging Library for image processing
+- **Requests** (2.31.0): HTTP library for making API calls
+- **Pydantic** (2.4.2): Data validation and settings management
+
+## Development
+
+### Setting up Development Environment
+
+1. Follow the installation steps above
+2. Install additional development dependencies (if any):
+   ```bash
+   pip install pytest pytest-asyncio httpx
+   ```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Style
+
+This project follows PEP 8 style guidelines. You can check code style with:
+
+```bash
+flake8 .
+```
+
+## Environment Variables
+
+Create a `.env` file in the root directory for environment-specific configurations:
+
+```env
+# Example environment variables
+DEBUG=True
+DATABASE_URL=sqlite:///./app.db
+SECRET_KEY=your-secret-key-here
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have questions, please:
+
+1. Check the [documentation](http://localhost:8000/docs) when the server is running
+2. Search existing [issues](../../issues)
+3. Create a new issue if needed
+
+## Roadmap
+
+- [ ] Add authentication and authorization
+- [ ] Implement outfit recommendation algorithms
+- [ ] Add image upload and processing features
+- [ ] Create user management system
+- [ ] Add database integration
+- [ ] Implement caching layer
+
+---
+
+**Built with ❤️ using FastAPI**

README-docker-compose.md

@@ -0,0 +1,201 @@
+# Fashion Analyzer - Docker Compose Setup
+
+This project provides a secure, containerized fashion analysis application using Ollama and FastAPI with Docker Compose.
+
+## 🏗️ Architecture
+
+The application consists of three services:
+
+1. **Ollama Service**: Runs the Ollama server with LLaVA model for vision analysis
+2. **FastAPI Service**: Provides the web API and user interface
+3. **Model Loader**: One-time service to download the required LLaVA model
+
+## 🔒 Security Features
+
+- ✅ **Pinned Ollama version** (0.9.2) - No critical vulnerabilities
+- ✅ **Non-root user execution** - Enhanced container security
+- ✅ **Security updates** - Latest package updates applied
+- ✅ **Health checks** - Service monitoring and restart policies
+- ✅ **Network isolation** - Services communicate via internal network
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Docker Engine 20.10+
+- Docker Compose 2.0+
+
+### 1. Start the Application
+
+```bash
+# Start all services
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Check service status
+docker-compose ps
+```
+
+### 2. Access the Application
+
+- **Web Interface**: http://localhost:7860
+- **API Documentation**: http://localhost:7860/docs
+- **Health Check**: http://localhost:7860/health
+- **Ollama API**: http://localhost:11434
+
+### 3. Stop the Application
+
+```bash
+# Stop all services
+docker-compose down
+
+# Stop and remove volumes (removes downloaded models)
+docker-compose down -v
+```
+
+## 📁 Project Structure
+
+```
+AI/
+├── docker-compose.yml      # Main orchestration file
+├── Dockerfile.fastapi      # FastAPI service Dockerfile
+├── .env                    # Environment variables
+├── .dockerignore          # Docker build exclusions
+├── fast.py                # FastAPI application
+├── requirements.txt       # Python dependencies
+└── logs/                  # Application logs (created at runtime)
+```
+
+## ⚙️ Configuration
+
+### Environment Variables (.env)
+
+```env
+OLLAMA_HOST=0.0.0.0:11434
+OLLAMA_ORIGINS=*
+OLLAMA_BASE_URL=http://ollama:11434
+OLLAMA_PORT=11434
+FASTAPI_PORT=7860
+```
+
+### Custom Configuration
+
+To modify ports or other settings:
+
+1. Edit `.env` file
+2. Restart services: `docker-compose up -d`
+
+## 🔧 Development
+
+### Building Images
+
+```bash
+# Build only FastAPI service
+docker-compose build fastapi
+
+# Build with no cache
+docker-compose build --no-cache
+```
+
+### Viewing Logs
+
+```bash
+# All services
+docker-compose logs -f
+
+# Specific service
+docker-compose logs -f fastapi
+docker-compose logs -f ollama
+```
+
+### Debugging
+
+```bash
+# Execute commands in running containers
+docker-compose exec fastapi bash
+docker-compose exec ollama bash
+
+# Check service health
+docker-compose exec fastapi curl http://localhost:7860/health
+```
+
+## 📊 Monitoring
+
+### Health Checks
+
+All services include health checks:
+- **Ollama**: Checks API availability
+- **FastAPI**: Checks application health and Ollama connectivity
+
+### Service Dependencies
+
+- FastAPI waits for Ollama to be healthy before starting
+- Model loader runs after Ollama is ready
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+1. **Port conflicts**: Change ports in `.env` file
+2. **Model download fails**: Check internet connection and Ollama logs
+3. **FastAPI can't connect to Ollama**: Verify network configuration
+
+### Reset Everything
+
+```bash
+# Stop and remove everything
+docker-compose down -v --remove-orphans
+
+# Remove images
+docker-compose down --rmi all
+
+# Start fresh
+docker-compose up -d
+```
+
+## 📈 Scaling
+
+To run multiple FastAPI instances:
+
+```bash
+# Scale FastAPI service
+docker-compose up -d --scale fastapi=3
+```
+
+Note: You'll need a load balancer for multiple instances.
+
+## 🔐 Security Considerations
+
+- Services run as non-root users
+- Network isolation between services
+- No sensitive data in environment variables
+- Regular security updates applied
+- Pinned dependency versions
+
+## 📝 API Usage
+
+### Upload and Analyze Image
+
+```bash
+curl -X POST "http://localhost:7860/analyze-image" \
+     -H "accept: application/json" \
+     -H "Content-Type: multipart/form-data" \
+     -F "[email protected]"
+```
+
+### Health Check
+
+```bash
+curl http://localhost:7860/health
+```
+
+## 🤝 Contributing
+
+1. Make changes to the code
+2. Test with `docker-compose up --build`
+3. Submit pull request
+
+## 📄 License
+
+This project is licensed under the MIT License.

docker-compose.prod.yml

@@ -0,0 +1,57 @@
+version: '3.8'
+
+# Production overrides for docker-compose.yml
+# Usage: docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d
+
+services:
+  ollama:
+    restart: always
+    deploy:
+      resources:
+        limits:
+          memory: 8G
+        reservations:
+          memory: 4G
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+  fastapi:
+    restart: always
+    deploy:
+      resources:
+        limits:
+          memory: 1G
+        reservations:
+          memory: 512M
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+    environment:
+      - ENVIRONMENT=production
+      - LOG_LEVEL=info
+
+  # Add nginx reverse proxy for production
+  nginx:
+    image: nginx:alpine
+    container_name: fashion-analyzer-nginx
+    restart: always
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./ssl:/etc/nginx/ssl:ro
+    depends_on:
+      - fastapi
+    networks:
+      - fashion-analyzer
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"

docker-compose.yml

@@ -0,0 +1,68 @@
+version: '3.8'
+
+services:
+  ollama:
+    image: ollama/ollama:0.9.2
+    container_name: ollama-server
+    restart: unless-stopped
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama_data:/root/.ollama
+    environment:
+      - OLLAMA_HOST=0.0.0.0:11434
+      - OLLAMA_ORIGINS=*
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    networks:
+      - fashion-analyzer
+
+  fastapi:
+    build:
+      context: .
+      dockerfile: Dockerfile.fastapi
+    container_name: fashion-analyzer-api
+    restart: unless-stopped
+    ports:
+      - "7860:7860"
+    environment:
+      - OLLAMA_BASE_URL=http://ollama:11434
+    depends_on:
+      ollama:
+        condition: service_healthy
+    networks:
+      - fashion-analyzer
+    volumes:
+      - ./logs:/app/logs
+
+  model-loader:
+    image: ollama/ollama:0.9.2
+    container_name: model-loader
+    restart: "no"
+    environment:
+      - OLLAMA_HOST=http://ollama:11434
+    depends_on:
+      ollama:
+        condition: service_healthy
+    networks:
+      - fashion-analyzer
+    command: >
+      sh -c "
+        echo 'Waiting for Ollama server to be ready...' &&
+        sleep 10 &&
+        echo 'Pulling LLaVA model for vision analysis...' &&
+        ollama pull llava:7b &&
+        echo 'Model pulled successfully!'
+      "
+
+volumes:
+  ollama_data:
+    driver: local
+
+networks:
+  fashion-analyzer:
+    driver: bridge

fast.py

@@ -0,0 +1,184 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.responses import JSONResponse, HTMLResponse, PlainTextResponse
+from pydantic import BaseModel
+from typing import List, Optional
+import requests
+import json
+import base64
+from PIL import Image
+import io
+import os
+import time
+import uvicorn
+
+app = FastAPI(title="Ollama Fashion Analyzer API", version="1.0.0")
+
+class OllamaFashionAnalyzer:
+    def __init__(self, base_url=None):
+        """Initialize Ollama client"""
+        self.base_url = base_url or os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+        self.model = "llava:7b"  # Using LLaVA for vision analysis
+    
+    def encode_image_from_bytes(self, image_bytes):
+        """Encode image bytes to base64 for Ollama"""
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Convert to base64
+        buffered = io.BytesIO()
+        image.save(buffered, format="JPEG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        
+        return img_str
+    
+    def analyze_clothing_from_bytes(self, image_bytes):
+        """Detailed clothing analysis using Ollama from image bytes"""
+        
+        # Encode image
+        image_b64 = self.encode_image_from_bytes(image_bytes)
+        
+        # Fashion analysis prompt
+        prompt = """Analyze this clothing item in detail and provide information about:
+
+1. GARMENT TYPE: What type of clothing is this?
+2. COLORS: Primary and secondary colors
+3. COLLAR/NECKLINE: Style of collar or neckline
+4. SLEEVES: Sleeve type and length
+5. PATTERN: Any patterns or designs
+6. FIT: How does it fit (loose, fitted, etc.)
+7. MATERIAL: Apparent fabric type
+8. FEATURES: Buttons, pockets, zippers, etc.
+9. STYLE: Fashion style category
+10. OCCASION: Suitable occasions for wearing
+
+Be specific and detailed in your analysis."""
+        
+        # Make request to Ollama
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "images": [image_b64],
+            "stream": False,
+            "options": {
+                "temperature": 0.2,
+                "num_predict": 500
+            }
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/generate",
+                json=payload,
+                timeout=120  # Increased timeout for vision models
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            return result.get('response', 'No response received')
+            
+        except requests.exceptions.RequestException as e:
+            return f"Error: {str(e)}"
+
+# Initialize analyzer
+analyzer = OllamaFashionAnalyzer()
+
+# Request/Response models
+class AnalysisResponse(BaseModel):
+    analysis: str
+
+# API Endpoints
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Main page with file upload interface"""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Fashion Analyzer</title>
+        <style>
+            body { font-family: Arial, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; }
+            .upload-area { border: 2px dashed #ccc; padding: 50px; text-align: center; margin: 20px 0; }
+            .result { background: #f5f5f5; padding: 20px; margin: 20px 0; border-radius: 5px; }
+        </style>
+    </head>
+    <body>
+        <h1>🎽 Fashion Analyzer</h1>
+        <p>Upload an image of clothing to get detailed fashion analysis</p>
+        
+        <div class="upload-area">
+            <input type="file" id="imageInput" accept="image/*" style="margin: 10px;">
+            <br>
+            <button onclick="analyzeImage()" style="padding: 10px 20px; margin: 10px;">Analyze Fashion</button>
+        </div>
+        
+        <div id="result" class="result" style="display: none;">
+            <h3>Analysis Result:</h3>
+            <pre id="analysisText"></pre>
+        </div>
+
+        <script>
+        async function analyzeImage() {
+            const input = document.getElementById('imageInput');
+            const file = input.files[0];
+            
+            if (!file) {
+                alert('Please select an image file');
+                return;
+            }
+            
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            document.getElementById('analysisText').textContent = 'Analyzing... Please wait...';
+            document.getElementById('result').style.display = 'block';
+            
+            try {
+                const response = await fetch('/analyze-image', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                const result = await response.json();
+                document.getElementById('analysisText').textContent = result.analysis;
+            } catch (error) {
+                document.getElementById('analysisText').textContent = 'Error: ' + error.message;
+            }
+        }
+        </script>
+    </body>
+    </html>
+    """
+
+@app.post("/analyze-image", response_model=AnalysisResponse)
+async def analyze_image(file: UploadFile = File(...)):
+    """Analyze uploaded image"""
+    try:
+        # Read image bytes
+        image_bytes = await file.read()
+        
+        # Analyze the clothing
+        analysis = analyzer.analyze_clothing_from_bytes(image_bytes)
+        
+        return AnalysisResponse(analysis=analysis)
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error analyzing image: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    try:
+        # Test Ollama connection
+        response = requests.get(f"{analyzer.base_url}/api/tags", timeout=5)
+        if response.status_code == 200:
+            return {"status": "healthy", "ollama": "connected"}
+        else:
+            return {"status": "unhealthy", "ollama": "disconnected"}
+    except:
+        return {"status": "unhealthy", "ollama": "disconnected"}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

fastapi_startup_script.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Start Ollama server in background
+ollama serve &
+
+# Wait for Ollama to start
+echo "Waiting for Ollama server to start..."
+while ! curl -s http://localhost:11434 > /dev/null; do
+  sleep 1
+done
+
+echo "Ollama server started!"
+
+# Pull the LLaVA model for vision analysis
+echo "Pulling LLaVA model for vision analysis..."
+ollama pull llava:7b
+
+echo "Model pulled successfully!"
+
+# Start FastAPI on port 7860 (HF Spaces requirement)
+echo "Starting FastAPI server on port 7860..."
+cd /app
+python3 -m uvicorn fast:app --host 0.0.0.0 --port 7860

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+requests==2.31.0
+Pillow==10.0.1
+pydantic==2.4.2
+python-multipart

start.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Start Ollama server in background
+ollama serve &
+
+# Wait for Ollama to start
+echo "Waiting for Ollama server to start..."
+while ! curl -s http://localhost:11434 > /dev/null; do
+  sleep 1
+done
+
+echo "Ollama server started!"
+
+# Pull the LLaVA model for vision analysis
+echo "Pulling LLaVA model for vision analysis..."
+ollama pull llava:7b
+
+echo "Model pulled successfully!"
+
+# Start FastAPI on port 7860 (HF Spaces requirement)
+echo "Starting FastAPI server on port 7860..."
+cd /app
+python3 -m uvicorn fast:app --host 0.0.0.0 --port 7860