Upload 5 files

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY app.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -1,10 +1,93 @@
----
-title: Plasmidgpt
-emoji: 🦀
-colorFrom: yellow
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: PlasmidGPT API
+emoji: 🧬
+colorFrom: blue
+colorTo: green
+sdk: docker
+sdk_version: 4.0.0
+app_file: Dockerfile
+pinned: false
+license: cc-by-nc-4.0
+---
+
+# PlasmidGPT API Service
+
+This HuggingFace Space deploys the PlasmidGPT model as a FastAPI service for DNA sequence generation.
+
+## Features
+
+- 🧬 DNA sequence generation using PlasmidGPT
+- 🚀 FastAPI REST API
+- 💻 GPU acceleration (free on HuggingFace)
+- 🔒 CORS enabled for external API calls
+
+## API Endpoints
+
+### Health Check
+```
+GET /health
+```
+
+### Generate Sequences
+```
+POST /generate
+Content-Type: application/json
+
+{
+  "prompt": "ATGAAA",
+  "max_length": 100,
+  "temperature": 0.7,
+  "num_return_sequences": 1,
+  "do_sample": true,
+  "repetition_penalty": 1.1
+}
+```
+
+## Usage from Render Backend
+
+Once deployed, your Render backend can call this Space:
+
+```python
+import httpx
+
+space_url = "https://your-username-plasmidgpt-api.hf.space"
+response = await httpx.post(
+    f"{space_url}/generate",
+    json={
+        "prompt": "ATGAAA",
+        "max_length": 100,
+        "temperature": 0.7
+    }
+)
+```
+
+## Setup Instructions
+
+1. **Create Space:**
+   - Go to https://huggingface.co/spaces
+   - Click "Create new Space"
+   - Name: `your-username/plasmidgpt-api`
+   - SDK: Docker
+   - Visibility: Public
+
+2. **Upload Files:**
+   - Upload `app.py`
+   - Upload `requirements.txt`
+   - Upload `Dockerfile` (if using Docker SDK)
+
+3. **Deploy:**
+   - Space will automatically build and deploy
+   - Wait for model to load (first time takes ~5-10 minutes)
+   - Check `/health` endpoint to verify
+
+4. **Get Space URL:**
+   - Your Space URL: `https://your-username-plasmidgpt-api.hf.space`
+   - Use this in your Render backend configuration
+
+## Notes
+
+- First deployment takes longer (model download)
+- Model uses GPU if available (free on HuggingFace)
+- Space sleeps after inactivity (wake up on first request)
+- CORS is enabled for external API calls
+

SETUP_INSTRUCTIONS.md

@@ -0,0 +1,144 @@
+# PlasmidGPT HuggingFace Space Setup Instructions
+
+## Quick Start
+
+1. **Create HuggingFace Space**
+2. **Upload Files**
+3. **Deploy**
+4. **Configure Render Backend**
+
+## Step-by-Step Guide
+
+### Step 1: Create HuggingFace Space
+
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Fill in:
+   - **Space name**: `your-username/plasmidgpt-api` (replace `your-username` with your HF username)
+   - **SDK**: Select **"Docker"**
+   - **Hardware**: Select **"GPU Basic"** (free tier)
+   - **Visibility**: **Public** (required for API access)
+4. Click **"Create Space"**
+
+### Step 2: Upload Files
+
+In your new Space, upload these files from the `huggingface-space/` directory:
+
+1. **`app.py`** - Main FastAPI application
+2. **`requirements.txt`** - Python dependencies
+3. **`Dockerfile`** - Docker configuration
+4. **`README.md`** - Space documentation (optional)
+
+**How to upload:**
+- Click "Files and versions" tab
+- Click "Add file" → "Upload files"
+- Drag and drop the files
+- Commit changes
+
+### Step 3: Wait for Deployment
+
+1. HuggingFace will automatically build and deploy your Space
+2. **First deployment takes 5-10 minutes** (model download)
+3. Watch the logs in the Space interface
+4. Look for: `✅ PlasmidGPT model loaded successfully!`
+
+### Step 4: Test Your Space
+
+1. Go to your Space URL: `https://your-username-plasmidgpt-api.hf.space`
+2. Test the health endpoint:
+   ```
+   https://your-username-plasmidgpt-api.hf.space/health
+   ```
+3. Should return:
+   ```json
+   {
+     "status": "healthy",
+     "model_loaded": true,
+     "device": "cuda",
+     "model_name": "lingxusb/PlasmidGPT"
+   }
+   ```
+
+### Step 5: Configure Render Backend
+
+1. **Get your Space URL:**
+   - Format: `https://your-username-plasmidgpt-api.hf.space`
+   - No trailing slash!
+
+2. **Update `render.yaml`:**
+   ```yaml
+   envVars:
+     - key: PLASMIDGPT_ENABLED
+       value: "true"
+     - key: PLASMIDGPT_SPACE_URL
+       value: "https://your-username-plasmidgpt-api.hf.space"
+   ```
+
+3. **Or set environment variable in Render dashboard:**
+   - Go to your Render service
+   - Environment tab
+   - Add: `PLASMIDGPT_SPACE_URL` = `https://your-username-plasmidgpt-api.hf.space`
+
+4. **Redeploy your Render service**
+
+### Step 6: Verify Integration
+
+1. **Check backend logs:**
+   ```
+   INFO: HuggingFace client initialized for custom Space: https://your-username-plasmidgpt-api.hf.space
+   ```
+
+2. **Test health endpoint:**
+   ```bash
+   curl https://your-render-app.onrender.com/api/plasmidgpt/health
+   ```
+   Should return: `"status": "healthy"`
+
+3. **Test sequence generation:**
+   - Ask your design agent: "Generate a plasmid for protein expression"
+   - Should see: "🤖 Using LLM to generate optimized prompt for PlasmidGPT..."
+   - Then: "🧬 Starting AI-powered DNA sequence generation..."
+
+## Troubleshooting
+
+### Space won't deploy
+- Check Dockerfile syntax
+- Verify all files are uploaded
+- Check Space logs for errors
+
+### Model loading fails
+- Ensure GPU is selected (not CPU)
+- Check if model name is correct: `lingxusb/PlasmidGPT`
+- Verify you have enough disk space
+
+### Space sleeps after inactivity
+- This is normal! First request after sleep takes ~30 seconds
+- Space wakes up automatically on first API call
+- Consider upgrading to "GPU Basic" (still free) for faster wake-up
+
+### Backend can't connect
+- Verify Space URL is correct (no trailing slash)
+- Check CORS settings in `app.py` (should allow your Render domain)
+- Test Space health endpoint directly in browser
+
+### Generation fails
+- Check Space logs for errors
+- Verify model is loaded: `/health` endpoint
+- Test generation directly: `POST /generate` with test payload
+
+## Cost
+
+- **HuggingFace Space**: Free (GPU Basic tier)
+- **Render Backend**: Your existing plan (no changes needed)
+- **Total**: $0 additional cost! 🎉
+
+## Next Steps
+
+Once deployed:
+- ✅ PlasmidGPT is fully functional
+- ✅ Hybrid LLM integration works
+- ✅ Sequence generation available
+- ✅ No PyTorch needed on Render
+
+Enjoy your AI-powered plasmid design! 🧬
+

app.py

@@ -0,0 +1,196 @@
+"""
+PlasmidGPT HuggingFace Space Deployment
+
+This Space loads the PlasmidGPT model and exposes it as a FastAPI service
+that can be called from your Render backend.
+"""
+
+import os
+import logging
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import time
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="PlasmidGPT API",
+    description="PlasmidGPT model API for DNA sequence generation",
+    version="1.0.0"
+)
+
+# Enable CORS for Render backend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, restrict to your Render URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global model and tokenizer
+model = None
+tokenizer = None
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Request/Response models
+class GenerationRequest(BaseModel):
+    prompt: str = Field(..., description="DNA sequence prompt or seed")
+    max_length: int = Field(100, ge=10, le=1000, description="Maximum sequence length")
+    temperature: float = Field(0.7, ge=0.0, le=2.0, description="Sampling temperature")
+    num_return_sequences: int = Field(1, ge=1, le=3, description="Number of sequences to generate")
+    do_sample: bool = Field(True, description="Whether to use sampling")
+    repetition_penalty: float = Field(1.1, ge=1.0, le=2.0, description="Repetition penalty")
+
+class GenerationResponse(BaseModel):
+    sequences: list[str]
+    metadata: Dict[str, Any]
+    generation_time: float
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    device: str
+    model_name: str
+
+@app.on_event("startup")
+async def load_model():
+    """Load PlasmidGPT model on startup."""
+    global model, tokenizer
+    
+    logger.info("Loading PlasmidGPT model...")
+    logger.info(f"Using device: {device}")
+    
+    try:
+        model_name = "lingxusb/PlasmidGPT"
+        
+        # Load tokenizer
+        logger.info("Loading tokenizer...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        
+        # Load model
+        logger.info("Loading model (this may take a few minutes)...")
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+            device_map="auto" if device == "cuda" else None
+        )
+        
+        if device == "cpu":
+            model = model.to(device)
+        
+        model.eval()
+        
+        logger.info("✅ PlasmidGPT model loaded successfully!")
+        logger.info(f"Model device: {next(model.parameters()).device}")
+        
+    except Exception as e:
+        logger.error(f"Failed to load model: {str(e)}")
+        raise
+
+@app.get("/", response_model=HealthResponse)
+async def root():
+    """Health check endpoint."""
+    return HealthResponse(
+        status="healthy" if model is not None else "loading",
+        model_loaded=model is not None,
+        device=device,
+        model_name="lingxusb/PlasmidGPT"
+    )
+
+@app.get("/health", response_model=HealthResponse)
+async def health():
+    """Health check endpoint."""
+    return HealthResponse(
+        status="healthy" if model is not None else "loading",
+        model_loaded=model is not None,
+        device=device,
+        model_name="lingxusb/PlasmidGPT"
+    )
+
+@app.post("/generate", response_model=GenerationResponse)
+async def generate_sequences(request: GenerationRequest):
+    """
+    Generate DNA sequences using PlasmidGPT.
+    
+    Args:
+        request: Generation parameters
+        
+    Returns:
+        Generated sequences with metadata
+    """
+    if model is None or tokenizer is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Model is still loading. Please wait and try again."
+        )
+    
+    try:
+        start_time = time.time()
+        
+        # Tokenize input
+        inputs = tokenizer(request.prompt, return_tensors="pt").to(device)
+        
+        # Generate sequences
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_length=request.max_length,
+                temperature=request.temperature,
+                num_return_sequences=request.num_return_sequences,
+                do_sample=request.do_sample,
+                repetition_penalty=request.repetition_penalty,
+                pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        # Decode sequences
+        sequences = []
+        for output in outputs:
+            # Decode only the generated part (exclude prompt)
+            generated = output[inputs.input_ids.shape[1]:]
+            sequence = tokenizer.decode(generated, skip_special_tokens=True)
+            sequences.append(sequence)
+        
+        generation_time = time.time() - start_time
+        
+        return GenerationResponse(
+            sequences=sequences,
+            metadata={
+                "prompt": request.prompt,
+                "prompt_length": len(request.prompt),
+                "generated_lengths": [len(seq) for seq in sequences],
+                "device": device,
+                "model": "lingxusb/PlasmidGPT"
+            },
+            generation_time=generation_time
+        )
+        
+    except Exception as e:
+        logger.error(f"Generation failed: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Generation failed: {str(e)}"
+        )
+
+@app.post("/embed")
+async def extract_embeddings(request: Dict[str, Any]):
+    """
+    Extract embeddings from sequences (placeholder - implement if needed).
+    """
+    raise HTTPException(
+        status_code=501,
+        detail="Embedding extraction not yet implemented in Space deployment"
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+torch>=2.0.0
+transformers>=4.35.0
+accelerate>=0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6
+