geminicahngeslast

Dockerfile

@@ -1,19 +1,14 @@
-FROM python:3.10-slim
+# Dockerfile (optional)
+FROM python:3.11-slim
 
-WORKDIR /code
+WORKDIR /app
 
-# Copy requirements
 COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Install dependencies
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+COPY . .
 
-# Copy application code
-COPY main.py .
+ENV PYTHONUNBUFFERED=1
+EXPOSE 8080
 
-# Expose port
-EXPOSE 7860
-
-# Run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8080"]

app.py

@@ -1,33 +1,66 @@
-from fastapi import FastAPI, HTTPException
+# app.py
+from fastapi import FastAPI, Request, HTTPException, status
 from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+import os
 import requests
+import time
 import json
-import os
-import hashlib
+import threading
+from typing import Dict
 from datetime import datetime, timedelta
-from typing import Optional
-
-app = FastAPI()
-
-# In-memory cache (resets when Space restarts)
-CACHE = {}
-CACHE_DURATION = timedelta(hours=1)  # Cache for 1 hour
-
-# Use Hugging Face Inference API (FREE!)
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-
-MODELS = {
-    "default": "microsoft/Phi-3-mini-4k-instruct",
-    "backup": "HuggingFaceH4/zephyr-7b-beta",
-}
-
-# Stats tracking
-STATS = {
-    "cache_hits": 0,
-    "api_calls": 0,
-    "total_requests": 0
-}
 
+# ---------- Configuration ----------
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+if not GEMINI_API_KEY:
+    print("WARNING: GEMINI_API_KEY not set. Set it in Space secrets or env.")
+
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash")  # change if needed
+GEMINI_BASE = os.environ.get("GEMINI_BASE", "https://generativelanguage.googleapis.com/v1beta")
+GENERATE_PATH = f"{GEMINI_BASE}/models/{GEMINI_MODEL}:generateContent"
+
+# Rate limit settings (in-memory). Tune these for your expected traffic.
+RATE_LIMIT_REQUESTS = int(os.environ.get("RATE_LIMIT_REQUESTS", "12"))  # requests per window per IP
+RATE_LIMIT_WINDOW = int(os.environ.get("RATE_LIMIT_WINDOW", "60"))     # window size in seconds
+
+# Retry settings for Gemini calls
+MAX_RETRIES = 3
+RETRY_BACKOFF = 1.5  # multiplier
+
+# ---------- Simple in-memory rate limiter ----------
+# Structure: { ip: [timestamp1, timestamp2, ...] }
+rate_table: Dict[str, list] = {}
+rate_lock = threading.Lock()
+
+def clean_old(ip: str):
+    now = time.time()
+    cutoff = now - RATE_LIMIT_WINDOW
+    with rate_lock:
+        timestamps = rate_table.get(ip, [])
+        timestamps = [t for t in timestamps if t >= cutoff]
+        rate_table[ip] = timestamps
+        return len(timestamps)
+
+def consume_token(ip: str):
+    with rate_lock:
+        cnt = clean_old(ip)
+        if cnt >= RATE_LIMIT_REQUESTS:
+            return False
+        rate_table.setdefault(ip, []).append(time.time())
+        return True
+
+# ---------- FastAPI setup ----------
+app = FastAPI(title="Hackathon Idea Generator (Gemini backend)")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # change to your frontend domain in production
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_headers=["*"],
+)
+
+# ---------- Request / Response models ----------
 class GenerateRequest(BaseModel):
     custom_prompt: str = ""
 
@@ -35,551 +68,189 @@ class DetailRequest(BaseModel):
     idea_id: int
     idea_title: str
 
-def get_cache_key(prefix: str, data: str) -> str:
-    """Generate cache key from data"""
-    return f"{prefix}:{hashlib.md5(data.encode()).hexdigest()}"
+# ---------- Utility: call Gemini REST generateContent ----------
+def call_gemini(prompt_text: str, max_output_tokens: int = 1024, temperature: float = 0.7):
+    """
+    Call Gemini generateContent REST endpoint with retries and error handling.
+    Returns response JSON (raw).
+    """
+    if not GEMINI_API_KEY:
+        raise HTTPException(status_code=500, detail="GEMINI_API_KEY not configured on server.")
 
-def get_from_cache(key: str):
-    """Get from cache if not expired"""
-    if key in CACHE:
-        entry = CACHE[key]
-        if datetime.now() < entry["expires"]:
-            STATS["cache_hits"] += 1
-            return entry["data"]
-        else:
-            del CACHE[key]
-    return None
-
-def save_to_cache(key: str, data: dict):
-    """Save to cache with expiration"""
-    CACHE[key] = {
-        "data": data,
-        "expires": datetime.now() + CACHE_DURATION
-    }
-
-def call_hf_api(prompt: str, max_tokens: int = 800, model: str = "default") -> str:
-    """Call Hugging Face Inference API with rate limit handling"""
-    STATS["api_calls"] += 1
-    
-    api_url = f"https://api-inference.huggingface.co/models/{MODELS[model]}"
-    
     headers = {
-        "Authorization": f"Bearer {HF_TOKEN}" if HF_TOKEN else ""
-    }
-    
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "max_new_tokens": max_tokens,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "do_sample": True,
-            "return_full_text": False
-        }
-    }
-    
-    try:
-        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
-        
-        if response.status_code == 503:
-            return "MODEL_LOADING"
-        elif response.status_code == 429:
-            if model == "default":
-                return call_hf_api(prompt, max_tokens, "backup")
-            return "RATE_LIMIT"
-        
-        response.raise_for_status()
-        result = response.json()
-        
-        if isinstance(result, list) and len(result) > 0:
-            return result[0].get("generated_text", "")
-        return ""
-        
-    except Exception as e:
-        print(f"API Error: {e}")
-        return ""
-
-def generate_ideas_with_ai(custom_prompt: str) -> dict:
-    """Generate hackathon ideas with caching"""
-    STATS["total_requests"] += 1
-    
-    # Check cache first
-    cache_key = get_cache_key("ideas", custom_prompt.lower().strip())
-    cached = get_from_cache(cache_key)
-    if cached:
-        cached["_from_cache"] = True
-        return cached
-    
-    prompt = f"""You are a hackathon project expert. Generate 3 unique, creative hackathon project ideas.
-Focus: {custom_prompt if custom_prompt else "innovative web applications"}
-
-For each idea, provide:
-1. Title (creative, concise)
-2. Elevator pitch (one compelling sentence)
-3. Overview (2-3 sentences explaining the project)
-4. Tech stack (3-4 technologies)
-5. Difficulty (Easy/Medium/Hard)
-6. Time estimate in hours (12-48)
-
-Format your response EXACTLY like this:
-
-IDEA 1:
-Title: [title]
-Elevator: [pitch]
-Overview: [description]
-Tech: [tech1, tech2, tech3]
-Difficulty: [Easy/Medium/Hard]
-Hours: [number]
-
-IDEA 2:
-Title: [title]
-Elevator: [pitch]
-Overview: [description]
-Tech: [tech1, tech2, tech3]
-Difficulty: [Easy/Medium/Hard]
-Hours: [number]
-
-IDEA 3:
-Title: [title]
-Elevator: [pitch]
-Overview: [description]
-Tech: [tech1, tech2, tech3]
-Difficulty: [Easy/Medium/Hard]
-Hours: [number]
-
-Generate now:"""
-
-    response = call_hf_api(prompt, max_tokens=1000)
-    
-    if response == "MODEL_LOADING":
-        return {
-            "error": "Model is loading. Please wait 30 seconds and try again.",
-            "ideas": [],
-            "best_pick_id": 1,
-            "best_pick_reason": "Model loading"
-        }
-    elif response == "RATE_LIMIT":
-        # Return cached fallback ideas
-        return get_cached_fallback_ideas(custom_prompt)
-    
-    ideas = parse_ideas_from_text(response)
-    
-    if len(ideas) < 3:
-        ideas = generate_simple_fallback(custom_prompt)
-    
-    result = {
-        "ideas": ideas,
-        "best_pick_id": 2,
-        "best_pick_reason": "Balanced scope with achievable goals and innovative features",
-        "_from_cache": False
-    }
-    
-    # Save to cache
-    save_to_cache(cache_key, result)
-    
-    return result
-
-def get_cached_fallback_ideas(custom_prompt: str) -> dict:
-    """Return pre-generated fallback ideas when rate limited"""
-    focus = custom_prompt.lower().strip() if custom_prompt else "web"
-    
-    # Check if we have cached version of similar prompts
-    for key in CACHE:
-        if focus in key:
-            cached = get_from_cache(key)
-            if cached:
-                cached["_from_cache"] = True
-                cached["_note"] = "Rate limited - using cached similar results"
-                return cached
-    
-    # Generate simple fallback
-    result = {
-        "ideas": generate_simple_fallback(custom_prompt),
-        "best_pick_id": 2,
-        "best_pick_reason": "Rate limited - using fallback ideas",
-        "_from_cache": False,
-        "_note": "Rate limit reached. These are fallback ideas."
+        "Content-Type": "application/json",
+        "x-goog-api-key": GEMINI_API_KEY
     }
-    return result
 
-def parse_ideas_from_text(text: str) -> list:
-    """Parse AI-generated text into structured ideas"""
-    ideas = []
-    lines = text.split('\n')
-    current_idea = {}
-    
-    for line in lines:
-        line = line.strip()
-        if not line:
-            continue
-            
-        if line.startswith("Title:"):
-            if current_idea and len(current_idea) >= 5:
-                ideas.append(format_idea(current_idea, len(ideas) + 1))
-            current_idea = {"title": line.replace("Title:", "").strip()}
-        elif line.startswith("Elevator:"):
-            current_idea["elevator"] = line.replace("Elevator:", "").strip()
-        elif line.startswith("Overview:"):
-            current_idea["overview"] = line.replace("Overview:", "").strip()
-        elif line.startswith("Tech:"):
-            tech_str = line.replace("Tech:", "").strip()
-            current_idea["tech"] = [t.strip() for t in tech_str.split(',')]
-        elif line.startswith("Difficulty:"):
-            current_idea["difficulty"] = line.replace("Difficulty:", "").strip()
-        elif line.startswith("Hours:"):
-            try:
-                current_idea["hours"] = int(line.replace("Hours:", "").strip())
-            except:
-                current_idea["hours"] = 24
-    
-    if current_idea and len(current_idea) >= 5:
-        ideas.append(format_idea(current_idea, len(ideas) + 1))
-    
-    return ideas[:3]
-
-def format_idea(data: dict, id: int) -> dict:
-    """Format idea into expected structure"""
-    return {
-        "id": id,
-        "title": data.get("title", f"Project {id}")[:100],
-        "elevator": data.get("elevator", "An innovative hackathon project")[:200],
-        "overview": data.get("overview", "A comprehensive solution for developers")[:400],
-        "primary_tech_stack": data.get("tech", ["React", "Node.js", "MongoDB"])[:4],
-        "difficulty": data.get("difficulty", "Medium"),
-        "time_estimate_hours": data.get("hours", 24)
-    }
-
-def generate_simple_fallback(custom_prompt: str) -> list:
-    """High-quality fallback ideas"""
-    focus = custom_prompt.lower() if custom_prompt else "web"
-    
-    # AI/ML ideas
-    if any(k in focus for k in ["ai", "ml", "machine learning", "neural"]):
-        return [
-            {
-                "id": 1,
-                "title": "AI Code Review Assistant",
-                "elevator": "Automatically analyze code for bugs, security issues, and best practices using machine learning",
-                "overview": "A developer tool that integrates with Git workflows to provide intelligent code reviews, detect potential bugs early, and suggest improvements based on industry best practices and learned patterns.",
-                "primary_tech_stack": ["Python", "TensorFlow", "FastAPI", "VS Code API"],
-                "difficulty": "Medium",
-                "time_estimate_hours": 28
-            },
-            {
-                "id": 2,
-                "title": "Smart Document Summarizer",
-                "elevator": "Transform lengthy documents into concise summaries using natural language processing",
-                "overview": "An NLP-powered web application that processes PDFs and documents to generate intelligent summaries, extract key points, and identify action items automatically, saving hours of reading time.",
-                "primary_tech_stack": ["React", "Python", "Transformers", "MongoDB"],
-                "difficulty": "Easy",
-                "time_estimate_hours": 20
-            },
-            {
-                "id": 3,
-                "title": "Predictive Analytics Dashboard",
-                "elevator": "Forecast trends and patterns using machine learning on business data",
-                "overview": "A comprehensive analytics platform that uses ML algorithms to predict future trends, identify patterns in business data, and provide actionable insights through interactive visualizations.",
-                "primary_tech_stack": ["React", "scikit-learn", "PostgreSQL", "Plotly"],
-                "difficulty": "Hard",
-                "time_estimate_hours": 36
-            }
-        ]
-    
-    # Web3/Blockchain ideas
-    elif any(k in focus for k in ["web3", "blockchain", "crypto", "nft"]):
-        return [
-            {
-                "id": 1,
-                "title": "NFT Certificate Platform",
-                "elevator": "Issue tamper-proof digital certificates as NFTs for courses and achievements",
-                "overview": "A blockchain-based certification system that allows educational institutions to create and distribute verifiable certificates as NFTs, ensuring authenticity and preventing fraud.",
-                "primary_tech_stack": ["Solidity", "React", "Polygon", "IPFS"],
-                "difficulty": "Medium",
-                "time_estimate_hours": 26
-            },
-            {
-                "id": 2,
-                "title": "Decentralized Freelance Marketplace",
-                "elevator": "Connect freelancers and clients using smart contracts for secure payments",
-                "overview": "A Web3 platform where freelancers showcase work and clients post projects, with smart contracts handling automatic milestone-based payments and dispute resolution.",
-                "primary_tech_stack": ["Solidity", "Next.js", "Ethereum", "The Graph"],
-                "difficulty": "Hard",
-                "time_estimate_hours": 40
-            },
-            {
-                "id": 3,
-                "title": "Crypto Portfolio Tracker",
-                "elevator": "Track cryptocurrency investments across multiple wallets in real-time",
-                "overview": "A comprehensive dashboard aggregating data from various blockchain networks, providing real-time portfolio valuation, profit/loss tracking, and automated tax reporting.",
-                "primary_tech_stack": ["React", "Web3.js", "Node.js", "CoinGecko API"],
-                "difficulty": "Easy",
-                "time_estimate_hours": 18
-            }
-        ]
-    
-    # Default/General ideas
-    else:
-        return [
+    body = {
+        "contents": [
             {
-                "id": 1,
-                "title": "Real-Time Collaboration Hub",
-                "elevator": "Digital workspace for remote teams with live editing and video chat",
-                "overview": "A comprehensive collaboration platform featuring real-time document editing, interactive whiteboard, video conferencing, and task management all in one seamless interface.",
-                "primary_tech_stack": ["React", "WebSocket", "Node.js", "WebRTC"],
-                "difficulty": "Medium",
-                "time_estimate_hours": 30
-            },
-            {
-                "id": 2,
-                "title": "Smart Recipe Finder",
-                "elevator": "Discover recipes based on ingredients you already have at home",
-                "overview": "A mobile-optimized web app that helps reduce food waste by suggesting recipes based on available ingredients, complete with nutritional information and step-by-step cooking instructions.",
-                "primary_tech_stack": ["Vue.js", "Node.js", "Spoonacular API", "MongoDB"],
-                "difficulty": "Easy",
-                "time_estimate_hours": 16
-            },
-            {
-                "id": 3,
-                "title": "Event Discovery Platform",
-                "elevator": "Find local events and meetups happening in your community",
-                "overview": "A location-based platform aggregating events from multiple sources, providing personalized recommendations, facilitating RSVPs, and enabling social connections around shared interests.",
-                "primary_tech_stack": ["React", "Google Maps API", "Firebase", "Express"],
-                "difficulty": "Medium",
-                "time_estimate_hours": 24
-            }
-        ]
-
-def generate_details_with_ai(idea_id: int, idea_title: str) -> dict:
-    """Generate detailed plan with caching"""
-    # Check cache
-    cache_key = get_cache_key("details", f"{idea_id}:{idea_title}")
-    cached = get_from_cache(cache_key)
-    if cached:
-        return cached
-    
-    # For details, always use simple generation to save API calls
-    result = generate_simple_details(idea_id, idea_title)
-    save_to_cache(cache_key, result)
-    return result
-
-def generate_simple_details(idea_id: int, idea_title: str) -> dict:
-    """Generate structured details"""
-    return {
-        "id": idea_id,
-        "title": idea_title,
-        "mermaid_architecture": """graph TB
-    A[Frontend UI] --> B[API Gateway]
-    B --> C[Authentication]
-    B --> D[Business Logic]
-    D --> E[Database]
-    D --> F[External Services]
-    E --> G[(Data Store)]""",
-        "phases": [
-            {
-                "name": "MVP",
-                "time_hours": 20,
-                "tasks": [
-                    "Initialize project with React/Vue and set up development environment",
-                    "Design and implement database schema with proper indexing",
-                    "Build authentication system with JWT tokens",
-                    "Create core API endpoints for main functionality",
-                    "Develop essential UI components and layouts",
-                    "Integrate frontend with backend APIs",
-                    "Implement basic error handling and validation"
-                ],
-                "deliverables": [
-                    "Functional prototype with core features operational",
-                    "User authentication and authorization working",
-                    "Database deployed with initial data",
-                    "Responsive UI covering primary user flows"
-                ]
-            },
-            {
-                "name": "Polish",
-                "time_hours": 18,
-                "tasks": [
-                    "Enhance UI/UX with animations and micro-interactions",
-                    "Add comprehensive error handling across all endpoints",
-                    "Implement loading states and user feedback mechanisms",
-                    "Optimize API performance and database queries",
-                    "Add unit tests for critical business logic",
-                    "Implement logging and monitoring systems",
-                    "Create comprehensive user documentation"
-                ],
-                "deliverables": [
-                    "Production-ready interface with polished UX",
-                    "Robust error handling for all edge cases",
-                    "Performance optimizations implemented",
-                    "Test coverage for critical paths",
-                    "Complete API and user documentation"
-                ]
-            },
-            {
-                "name": "Demo",
-                "time_hours": 10,
-                "tasks": [
-                    "Design compelling presentation deck with key metrics",
-                    "Create realistic demo scenarios and user personas",
-                    "Set up production demo environment and test thoroughly",
-                    "Record backup video demo as contingency plan",
-                    "Practice pitch and prepare for Q&A",
-                    "Optimize demo flow for maximum impact",
-                    "Final bug fixes and polish for demo features"
-                ],
-                "deliverables": [
-                    "Professional pitch deck ready to present",
-                    "Polished live demo environment",
-                    "Backup video demonstration recorded",
-                    "Q&A preparation with anticipated questions",
-                    "Clean GitHub repository with README"
+                "parts": [
+                    {"text": prompt_text}
                 ]
             }
         ],
-        "critical_code_snippets": [
-            {
-                "title": "Express API Server with Error Handling",
-                "language": "javascript",
-                "code": """const express = require('express');
-const cors = require('cors');
-const helmet = require('helmet');
-
-const app = express();
-
-// Security and parsing middleware
-app.use(helmet());
-app.use(cors());
-app.use(express.json());
-
-// API Routes
-app.post('/api/data', async (req, res) => {
-  try {
-    const result = await processData(req.body);
-    res.json({ success: true, data: result });
-  } catch (error) {
-    console.error('Error:', error);
-    res.status(500).json({ 
-      success: false,
-      error: error.message 
-    });
-  }
-});
-
-// Global error handler
-app.use((err, req, res, next) => {
-  res.status(err.status || 500).json({
-    error: err.message
-  });
-});
-
-const PORT = process.env.PORT || 3000;
-app.listen(PORT);"""
-            },
-            {
-                "title": "React Component with Hooks",
-                "language": "javascript",
-                "code": """import React, { useState, useEffect } from 'react';
-import axios from 'axios';
-
-function Dashboard() {
-  const [data, setData] = useState([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-
-  useEffect(() => {
-    fetchData();
-  }, []);
-
-  const fetchData = async () => {
-    try {
-      setLoading(true);
-      const res = await axios.get('/api/data');
-      setData(res.data);
-      setError(null);
-    } catch (err) {
-      setError(err.message);
-    } finally {
-      setLoading(false);
+        # optional tuning params depending on API; keep compact
+        "temperature": temperature,
+        "maxOutputTokens": max_output_tokens
     }
-  };
 
-  if (loading) return <Spinner />;
-  if (error) return <Error message={error} />;
-  
-  return (
-    <div className="dashboard">
-      {data.map(item => (
-        <Card key={item.id} data={item} />
-      ))}
-    </div>
-  );
-}"""
-            }
-        ],
-        "ui_components": [
-            {"name": "Navigation Bar", "purpose": "Primary navigation with branding and user menu"},
-            {"name": "Dashboard View", "purpose": "Main interface with data visualization and key metrics"},
-            {"name": "Form Components", "purpose": "User input collection with real-time validation"},
-            {"name": "Data Table", "purpose": "Display items with sorting, filtering, and pagination"},
-            {"name": "Modal Dialogs", "purpose": "Handle confirmations and detailed item views"},
-            {"name": "Settings Panel", "purpose": "User preferences and app configuration"}
-        ],
-        "risks_and_mitigations": [
-            {"risk": "API rate limits affecting user experience", "mitigation": "Implement request caching, queuing, and retry logic with exponential backoff"},
-            {"risk": "Database performance degradation under load", "mitigation": "Add proper indexing, implement pagination, use connection pooling, and consider read replicas"},
-            {"risk": "Authentication security vulnerabilities", "mitigation": "Use battle-tested libraries (Passport.js), implement rate limiting, secure password hashing with bcrypt"},
-            {"risk": "Insufficient time for complete feature set", "mitigation": "Prioritize MVP features using MoSCoW method, use feature flags for progressive rollout"}
-        ]
-    }
+    attempt = 0
+    backoff = 1.0
+    while attempt < MAX_RETRIES:
+        try:
+            resp = requests.post(GENERATE_PATH, headers=headers, json=body, timeout=60)
+            if resp.status_code == 200:
+                return resp.json()
+            # retry on 429/5xx
+            if resp.status_code in (429, 500, 502, 503, 504):
+                attempt += 1
+                time.sleep(backoff)
+                backoff *= RETRY_BACKOFF
+                continue
+            # for other errors, raise with message
+            try:
+                d = resp.json()
+                message = d.get("error", d)
+            except Exception:
+                message = resp.text
+            raise HTTPException(status_code=resp.status_code, detail=f"Gemini API error: {message}")
+        except requests.Timeout:
+            attempt += 1
+            time.sleep(backoff)
+            backoff *= RETRY_BACKOFF
+            continue
+        except requests.RequestException as e:
+            attempt += 1
+            time.sleep(backoff)
+            backoff *= RETRY_BACKOFF
+            continue
+
+    raise HTTPException(status_code=502, detail="Gemini API unavailable after retries.")
+
+# ---------- Helpers to extract text from Gemini response ----------
+def extract_text_from_gemini(resp_json):
+    """
+    There are several forms of Gemini responses; try to robustly extract
+    the generated text from the response payload.
+    """
+    # Newer responses may have "candidates" or "output" structure
+    # See docs: the easy path is to inspect "candidates" or "outputs" etc.
+    # We'll try common possibilities.
+    try:
+        # Example: { "candidates": [{"content": [{"text": "..."}]}] }
+        if "candidates" in resp_json:
+            cand = resp_json["candidates"]
+            if isinstance(cand, list) and len(cand) > 0:
+                # dive into structured content
+                content = cand[0].get("content")
+                if isinstance(content, list):
+                    parts = []
+                    for item in content:
+                        if isinstance(item, dict) and "text" in item:
+                            parts.append(item["text"])
+                    if parts:
+                        return "".join(parts)
+                # fallback to "output" keys
+                if "output" in cand[0]:
+                    return cand[0]["output"].get("text", "")
+        # Example newer API: { "outputs": [{"content":[{"text":"..."}]}] }
+        if "outputs" in resp_json:
+            outs = resp_json["outputs"]
+            if isinstance(outs, list) and len(outs) > 0:
+                content = outs[0].get("content", [])
+                parts = []
+                for c in content:
+                    if isinstance(c, dict) and "text" in c:
+                        parts.append(c["text"])
+                if parts:
+                    return "".join(parts)
+        # Example minimal: { "text": "..." }
+        if "text" in resp_json:
+            return resp_json["text"]
+        # Example nested: "candidates":[{"content":[{"parts":[{"text":"..."}]}]}]
+        if "candidates" in resp_json:
+            try:
+                return resp_json["candidates"][0]["content"][0]["parts"][0]["text"]
+            except:
+                pass
+    except Exception:
+        pass
+
+    # last resort: return stringified json
+    return json.dumps(resp_json)
+
+# ---------- JSON extraction helper ----------
+import re
+def extract_json_from_text(text: str):
+    # Find first JSON object in text
+    m = re.search(r'\{[\s\S]*\}', text)
+    if m:
+        try:
+            return json.loads(m.group())
+        except:
+            return None
+    # also try array
+    m2 = re.search(r'\[[\s\S]*\]', text)
+    if m2:
+        try:
+            arr = json.loads(m2.group())
+            return {"ideas": arr}
+        except:
+            return None
+    return None
 
+# ---------- Endpoints ----------
 @app.get("/")
-def home():
-    return {
-        "status": "AI Hackathon Generator (Optimized for Launch)",
-        "endpoints": ["/generate", "/details", "/stats"],
-        "model": MODELS["default"],
-        "features": [
-            "Real AI generation",
-            "Smart caching (1 hour)",
-            "Rate limit protection",
-            "Fallback system"
-        ],
-        "cache_info": {
-            "cached_entries": len(CACHE),
-            "duration_hours": 1
-        }
-    }
+def root():
+    return {"status": "ok", "model": GEMINI_MODEL}
 
 @app.get("/stats")
-def get_stats():
-    """Get usage statistics"""
-    cache_hit_rate = 0
-    if STATS["total_requests"] > 0:
-        cache_hit_rate = (STATS["cache_hits"] / STATS["total_requests"]) * 100
-    
-    return {
-        "total_requests": STATS["total_requests"],
-        "api_calls": STATS["api_calls"],
-        "cache_hits": STATS["cache_hits"],
-        "cache_hit_rate": f"{cache_hit_rate:.1f}%",
-        "cached_entries": len(CACHE),
-        "api_calls_saved": STATS["cache_hits"]
-    }
+def stats():
+    # simple stats not persisted across restarts
+    return {"rate_limit_requests": RATE_LIMIT_REQUESTS, "rate_limit_window_seconds": RATE_LIMIT_WINDOW}
 
 @app.post("/generate")
-def generate(req: GenerateRequest):
-    try:
-        return generate_ideas_with_ai(req.custom_prompt)
-    except Exception as e:
-        return {
-            "error": str(e),
-            "ideas": generate_simple_fallback(req.custom_prompt),
-            "best_pick_id": 2,
-            "best_pick_reason": "Fallback due to error"
-        }
+async def generate(req: GenerateRequest, request: Request):
+    client_ip = request.client.host if request.client else "unknown"
+    if not consume_token(client_ip):
+        raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                            detail=f"Rate limit exceeded. Max {RATE_LIMIT_REQUESTS} requests per {RATE_LIMIT_WINDOW}s.")
+
+    # compose system + user prompt. Keep it compact to reduce tokens.
+    system_prefix = (
+        "[SYSTEM] You are a JSON API that returns exactly 3 hackathon ideas in valid JSON. "
+        "Return only JSON and nothing else. "
+    )
+    user_prompt = f"Topic: {req.custom_prompt.strip() or 'innovative technology'}"
+    prompt_text = f"{system_prefix}\n{user_prompt}\n\nReturn JSON with format:\n" \
+                  "{ \"ideas\": [ { \"id\":1, \"title\":\"...\", \"elevator\":\"...\", \"overview\":\"...\", \"primary_tech_stack\":[], \"difficulty\":\"Medium\", \"time_estimate_hours\":24 }, ... ], \"best_pick_id\": 2, \"best_pick_reason\": \"...\" }"
+
+    resp = call_gemini(prompt_text, max_output_tokens=1024, temperature=0.7)
+    generated_text = extract_text_from_gemini(resp)
+    parsed = extract_json_from_text(generated_text)
+    if not parsed:
+        # return debug for easier local debugging
+        raise HTTPException(status_code=502, detail={"error": "PARSE_ERROR", "raw": generated_text[:1000], "gemini_raw": resp})
+    return parsed
 
 @app.post("/details")
-def details(req: DetailRequest):
-    try:
-        return generate_details_with_ai(req.idea_id, req.idea_title)
-    except Exception as e:
-        return generate_simple_details(req.idea_id, req.idea_title)
+async def details(req: DetailRequest, request: Request):
+    client_ip = request.client.host if request.client else "unknown"
+    if not consume_token(client_ip):
+        raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                            detail=f"Rate limit exceeded. Max {RATE_LIMIT_REQUESTS} requests per {RATE_LIMIT_WINDOW}s.")
+
+    prompt_text = (
+        "[SYSTEM] You are a JSON API that returns a full 48-hour implementation plan in JSON. "
+        "Return only JSON.\n"
+        f"Project title: {req.idea_title}\n\n"
+        "Return format: {\"id\": <id>, \"title\": \"...\", \"mermaid_architecture\":\"...\", \"phases\": [ {\"name\":\"MVP\",\"time_hours\":20,\"tasks\":[..],\"deliverables\":[..]} , ... ], \"critical_code_snippets\":[...], \"ui_components\": [...], \"risks_and_mitigations\":[...] }"
+    )
+    resp = call_gemini(prompt_text, max_output_tokens=1400, temperature=0.7)
+    generated_text = extract_text_from_gemini(resp)
+    parsed = extract_json_from_text(generated_text)
+    if not parsed:
+        raise HTTPException(status_code=502, detail={"error": "PARSE_ERROR", "raw": generated_text[:1000], "gemini_raw": resp})
+    return parsed
+# ---------- Run with: uvicorn app:app --host 0.0.0.0 --port 8080

requirements.txt

@@ -1,4 +1,5 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-pydantic==2.5.0
-requests==2.31.0
+fastapi
+uvicorn
+requests
+pydantic
+python-multipart