Create app.py

app.py

@@ -0,0 +1,472 @@
+"""
+Sixfinger Backend API - FRONTEND UYUMLU VERSİYON
+Ultra-fast AI Chat Backend with Multi-Model Support
+"""
+
+import os
+import time
+import json
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from groq import Groq
+
+# ========== CONFIGURATION ==========
+API_VERSION = "1.0.0"
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+
+# Model mapping - Plan bazlı erişim kontrolü
+MODELS = {
+    # FREE Plan Models
+    "llama-8b-instant": {
+        "groq_id": "llama-3.1-8b-instant",
+        "size": "8B",
+        "language": "Multilingual",
+        "speed": "⚡⚡⚡",
+        "plans": ["free", "starter", "pro", "plus"],
+        "daily_limit": 14400
+    },
+    "allam-2-7b": {
+        "groq_id": "llama-3.1-8b-instant",  # Fallback
+        "size": "7B",
+        "language": "Turkish/Arabic",
+        "speed": "⚡⚡",
+        "plans": ["free", "starter", "pro", "plus"],
+        "daily_limit": 300
+    },
+    
+    # STARTER Plan Models
+    "qwen3-32b": {
+        "groq_id": "llama-3.3-70b-versatile",
+        "size": "32B",
+        "language": "Turkish/Chinese",
+        "speed": "⚡⚡",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "llama-70b": {
+        "groq_id": "llama-3.3-70b-versatile",
+        "size": "70B",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "llama-maverick-17b": {
+        "groq_id": "llama-3.1-8b-instant",
+        "size": "17B",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "llama-scout-17b": {
+        "groq_id": "llama-3.1-8b-instant",
+        "size": "17B",
+        "language": "Multilingual",
+        "speed": "⚡⚡⚡",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "gpt-oss-20b": {
+        "groq_id": "llama-3.1-8b-instant",
+        "size": "20B",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    
+    # PRO Plan Models
+    "gpt-oss-120b": {
+        "groq_id": "llama-3.3-70b-versatile",
+        "size": "120B",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "plans": ["pro", "plus"],
+        "daily_limit": 1000
+    },
+    "kimi-k2": {
+        "groq_id": "llama-3.3-70b-versatile",
+        "size": "Unknown",
+        "language": "Chinese",
+        "speed": "⚡⚡",
+        "plans": ["pro", "plus"],
+        "daily_limit": 1000
+    }
+}
+
+# Plan bazlı otomatik model seçimi
+DEFAULT_MODELS = {
+    "free": "llama-8b-instant",
+    "starter": "qwen3-32b",
+    "pro": "llama-70b",
+    "plus": "gpt-oss-120b"
+}
+
+# ========== LOGGING ==========
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# ========== FASTAPI APP ==========
+app = FastAPI(
+    title="Sixfinger Backend API",
+    version=API_VERSION,
+    description="Ultra-fast AI Chat Backend",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Production'da kısıtlayın
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Groq Client
+groq_client = Groq(api_key=GROQ_API_KEY) if GROQ_API_KEY else None
+
+# ========== MODELS ==========
+class ChatRequest(BaseModel):
+    prompt: str = Field(..., description="User's message")
+    max_tokens: int = Field(default=300, ge=1, le=4000)
+    temperature: float = Field(default=0.7, ge=0, le=2)
+    top_p: float = Field(default=0.9, ge=0, le=1)
+    system_prompt: Optional[str] = None
+    history: Optional[list] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    model: str
+    model_key: str
+    model_size: str
+    model_language: str
+    attempts: int
+    usage: Dict[str, int]
+    parameters: Dict[str, Any]
+
+# ========== HELPER FUNCTIONS ==========
+def get_allowed_models(plan: str) -> list:
+    """Plan'a göre izin verilen modelleri döndür"""
+    return [k for k, v in MODELS.items() if plan in v["plans"]]
+
+def select_model(plan: str, preferred_model: Optional[str] = None) -> str:
+    """Model seçimi yap"""
+    allowed_models = get_allowed_models(plan)
+    
+    # Eğer kullanıcı model belirtmişse ve erişimi varsa
+    if preferred_model and preferred_model in allowed_models:
+        return preferred_model
+    
+    # Otomatik seçim
+    default = DEFAULT_MODELS.get(plan, "llama-8b-instant")
+    return default if default in allowed_models else allowed_models[0]
+
+def build_messages(prompt: str, system_prompt: Optional[str], history: Optional[list]) -> list:
+    """Chat messages listesi oluştur"""
+    messages = []
+    
+    # System prompt
+    if system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+    
+    # History
+    if history:
+        for msg in history:
+            if "role" in msg and "content" in msg:
+                messages.append(msg)
+    
+    # Current prompt
+    messages.append({"role": "user", "content": prompt})
+    
+    return messages
+
+def call_groq_api(
+    model_id: str,
+    messages: list,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    stream: bool = False
+):
+    """Groq API'ye istek at (SYNC)"""
+    if not groq_client:
+        raise HTTPException(status_code=500, detail="Groq API key not configured")
+    
+    try:
+        response = groq_client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=stream
+        )
+        return response
+    except Exception as e:
+        logger.error(f"Groq API error: {e}")
+        raise HTTPException(status_code=500, detail=f"Groq API error: {str(e)}")
+
+# ========== ENDPOINTS ==========
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "version": API_VERSION,
+        "timestamp": datetime.now().isoformat(),
+        "groq_configured": bool(GROQ_API_KEY)
+    }
+
+@app.post("/api/chat")
+def chat(
+    request: ChatRequest,
+    x_user_plan: str = Header(default="free", alias="X-User-Plan"),
+    x_model: Optional[str] = Header(default=None, alias="X-Model")
+):
+    """
+    Normal chat endpoint (JSON response)
+    Frontend'e TAM UYUMLU format
+    """
+    start_time = time.time()
+    
+    # Model seçimi
+    model_key = select_model(x_user_plan, x_model)
+    model_config = MODELS[model_key]
+    groq_model_id = model_config["groq_id"]
+    
+    logger.info(f"Chat request: plan={x_user_plan}, model={model_key}")
+    
+    # Messages
+    messages = build_messages(
+        request.prompt,
+        request.system_prompt,
+        request.history
+    )
+    
+    # Groq API call
+    try:
+        response = call_groq_api(
+            model_id=groq_model_id,
+            messages=messages,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            stream=False
+        )
+        
+        # Extract response
+        content = response.choices[0].message.content
+        usage = {
+            "prompt_tokens": response.usage.prompt_tokens,
+            "completion_tokens": response.usage.completion_tokens,
+            "total_tokens": response.usage.total_tokens
+        }
+        
+        elapsed = time.time() - start_time
+        logger.info(f"Chat completed: tokens={usage['total_tokens']}, time={elapsed:.2f}s")
+        
+        # Frontend'in beklediği EXACT format
+        return {
+            "response": content,
+            "model": groq_model_id,
+            "model_key": model_key,
+            "model_size": model_config["size"],
+            "model_language": model_config["language"],
+            "attempts": 1,
+            "usage": usage,
+            "parameters": {
+                "max_tokens": request.max_tokens,
+                "temperature": request.temperature,
+                "top_p": request.top_p
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Chat error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/chat/stream")
+def chat_stream(
+    request: ChatRequest,
+    x_user_plan: str = Header(default="free", alias="X-User-Plan"),
+    x_model: Optional[str] = Header(default=None, alias="X-Model")
+):
+    """
+    Streaming chat endpoint (SSE)
+    Frontend'e TAM UYUMLU SSE format
+    ✅ SYNC generator (FastAPI StreamingResponse için doğru)
+    """
+    # Model seçimi
+    model_key = select_model(x_user_plan, x_model)
+    model_config = MODELS[model_key]
+    groq_model_id = model_config["groq_id"]
+    
+    logger.info(f"Stream request: plan={x_user_plan}, model={model_key}")
+    
+    # Messages
+    messages = build_messages(
+        request.prompt,
+        request.system_prompt,
+        request.history
+    )
+    
+    def generate():
+        """
+        SSE generator - SYNC function (FastAPI requirement)
+        Frontend iter_content() ile parse edecek
+        """
+        try:
+            # Info mesajı
+            info_msg = json.dumps({'info': f'Trying model: {model_key}'})
+            yield f"data: {info_msg}\n\n"
+            
+            # Groq streaming (SYNC)
+            response = call_groq_api(
+                model_id=groq_model_id,
+                messages=messages,
+                max_tokens=request.max_tokens,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                stream=True
+            )
+            
+            total_tokens = 0
+            prompt_tokens = 0
+            completion_tokens = 0
+            
+            # Stream chunks
+            for chunk in response:
+                # Text chunk
+                if chunk.choices[0].delta.content:
+                    text = chunk.choices[0].delta.content
+                    text_msg = json.dumps({'text': text})
+                    yield f"data: {text_msg}\n\n"
+                
+                # Usage bilgisi (son chunk'ta gelir)
+                if hasattr(chunk, 'x_groq') and hasattr(chunk.x_groq, 'usage'):
+                    usage_data = chunk.x_groq.usage
+                    if hasattr(usage_data, 'prompt_tokens'):
+                        prompt_tokens = usage_data.prompt_tokens
+                    if hasattr(usage_data, 'completion_tokens'):
+                        completion_tokens = usage_data.completion_tokens
+                    if hasattr(usage_data, 'total_tokens'):
+                        total_tokens = usage_data.total_tokens
+            
+            # Son usage hesaplama (eğer gelmediyse)
+            if total_tokens == 0 and completion_tokens > 0:
+                total_tokens = prompt_tokens + completion_tokens
+            
+            # Done mesajı - Frontend'in beklediği EXACT format
+            done_msg = json.dumps({
+                'done': True,
+                'model_key': model_key,
+                'attempts': 1,
+                'usage': {
+                    'prompt_tokens': prompt_tokens,
+                    'completion_tokens': completion_tokens,
+                    'total_tokens': total_tokens
+                }
+            })
+            yield f"data: {done_msg}\n\n"
+            
+            logger.info(f"Stream completed: model={model_key}, tokens={total_tokens}")
+            
+        except Exception as e:
+            logger.error(f"Stream error: {e}")
+            error_msg = json.dumps({'error': str(e)})
+            yield f"data: {error_msg}\n\n"
+    
+    return StreamingResponse(
+        generate(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+            "Connection": "keep-alive"
+        }
+    )
+
+@app.get("/api/models")
+def list_models(x_user_plan: str = Header(default="free", alias="X-User-Plan")):
+    """
+    Kullanıcının erişebileceği modelleri listele
+    """
+    allowed_models = get_allowed_models(x_user_plan)
+    
+    models_info = []
+    for model_key in allowed_models:
+        config = MODELS[model_key]
+        models_info.append({
+            "key": model_key,
+            "size": config["size"],
+            "language": config["language"],
+            "speed": config["speed"],
+            "daily_limit": config["daily_limit"]
+        })
+    
+    return {
+        "plan": x_user_plan,
+        "models": models_info,
+        "default_model": DEFAULT_MODELS.get(x_user_plan, "llama-8b-instant")
+    }
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """Custom HTTP exception handler"""
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "error": exc.detail,
+            "status_code": exc.status_code
+        }
+    )
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """General exception handler"""
+    logger.error(f"Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "detail": str(exc)
+        }
+    )
+
+# ========== STARTUP/SHUTDOWN ==========
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🚀 Sixfinger Backend API started")
+    logger.info(f"📦 Version: {API_VERSION}")
+    logger.info(f"🔑 Groq API: {'✅ Configured' if GROQ_API_KEY else '❌ Not configured'}")
+    logger.info(f"🤖 Models available: {len(MODELS)}")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("👋 Sixfinger Backend API shutting down")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )