Create app.py

app.py

@@ -0,0 +1,130 @@
+import os
+import time
+import httpx
+import json
+import re
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import List, Optional
+
+app = FastAPI(title="KAI STUDIO ROUTER")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+# --- Konfiguracja backendów ---
+BACKENDS = {
+    "qwen": {
+        "url": os.environ.get("KAI_QWEN_URL", "https://your-qwen-space.hf.space"),
+        "key": os.environ.get("KEY_QWEN"),
+        "models": ["Qwen2.5-7B-Instruct"]
+    },
+    "mistral": {
+        "url": os.environ.get("KAI_MISTRAL_URL", "https://your-mistral-space.hf.space"),
+        "key": os.environ.get("KEY_MISTRAL"),
+        "models": ["Mistral-7B-v0.3"]
+    }
+}
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: List[Message]
+    max_tokens: Optional[int] = 400
+    temperature: Optional[float] = 0.7
+    stream: bool = True
+    model: Optional[str] = None
+
+# --- Heurystyka wyboru modelu ---
+CODE_KEYWORDS = re.compile(r'\b(def|class|import|function|const|let|var|public|private|return|python|javascript|java|c\+\+|sql|html|css|json|api|docker|git|kod|funkcja|program|skrypt|algorytm)\b', re.I)
+MATH_KEYWORDS = re.compile(r'\b(oblicz|policz|równanie|całka|pochodna|macierz|prawdopodobieństwo|logarytm|pierwiastek|ile to|=\?|\d+\s*[\+\-\*\/]\s*\d+)\b', re.I)
+CREATIVE_KEYWORDS = re.compile(r'\b(napisz|wiersz|opowiadanie|historia|bajka|rap|tekst|piosenka|kreatywny|stwórz|wymyśl|zrób post|dialog)\b', re.I)
+
+def route_model(messages: List[Message], forced_model: Optional[str] = None) -> str:
+    if forced_model and forced_model in BACKENDS:
+        return forced_model
+
+    user_text = " ".join([m.content for m in messages if m.role == "user"]).lower()
+
+    # Priorytet 1: Kod lub matma -> Qwen
+    if CODE_KEYWORDS.search(user_text) or MATH_KEYWORDS.search(user_text):
+        return "qwen"
+
+    # Priorytet 2: Kreatywne PL -> Mistral
+    if CREATIVE_KEYWORDS.search(user_text):
+        return "mistral"
+
+    # Domyślnie: Mistral dla PL, Qwen dla reszty
+    # Prosta heurystyka PL
+    pl_chars = len(re.findall(r'[ąćęłńóśźż]', user_text))
+    if pl_chars > 2:
+        return "mistral"
+
+    return "qwen" # domyślnie Qwen bo szybszy
+
+# --- Proxy do backendu ---
+async def proxy_to_backend(backend_name: str, request_data: dict, stream: bool):
+    backend = BACKENDS[backend_name]
+    url = f"{backend['url']}/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {backend['key']}",
+        "Content-Type": "application/json"
+    }
+
+    async with httpx.AsyncClient(timeout=180.0) as client:
+        if stream:
+            async with client.stream("POST", url, json=request_data, headers=headers) as r:
+                if r.status_code!= 200:
+                    err = await r.aread()
+                    raise HTTPException(r.status_code, f"Backend {backend_name} error: {err.decode()}")
+
+                # Wysyłamy info który model został użyty
+                yield f": x-kai-model-used {backend_name}\n\n"
+                yield f": connected\n\n"
+
+                async for chunk in r.aiter_bytes():
+                    yield chunk
+        else:
+            r = await client.post(url, json=request_data, headers=headers)
+            if r.status_code!= 200:
+                raise HTTPException(r.status_code, f"Backend {backend_name} error: {r.text}")
+            data = r.json()
+            data["kai_model_used"] = backend_name
+            return data
+
+# --- Endpointy ---
+@app.get("/", response_class=HTMLResponse)
+async def serve_frontend():
+    with open("static/index.html", "r", encoding="utf-8") as f:
+        return HTMLResponse(content=f.read())
+
+@app.post("/v1/chat/completions")
+async def chat_completions(data: ChatRequest, request: Request):
+    chosen_backend = route_model(data.messages, data.model)
+
+    request_data = data.dict()
+    request_data.pop("model", None) # usuwamy bo backendy nie potrzebują
+
+    if data.stream:
+        generator = proxy_to_backend(chosen_backend, request_data, True)
+        return StreamingResponse(generator, media_type="text/event-stream")
+    else:
+        result = await proxy_to_backend(chosen_backend, request_data, False)
+        return JSONResponse(content=result)
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "backends": list(BACKENDS.keys())}
+
+# Serwuj pliki statyczne
+app.mount("/static", StaticFiles(directory="static"), name="static")