Update app.py

app.py

@@ -1,35 +1,73 @@
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 import json
 import os
+import socket
 from datetime import datetime, date
 import requests
 import logging
+import threading
 
 # Logging ayarı
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="AI Chat API", version="1.0.0")
+app = FastAPI(
+    title="AI Chat API",
+    version="2.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
 
-# CORS ayarları
+# TÜM CORS izinleri - Telefondan erişim için
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # Tüm domain'lere izin ver
+    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
+    expose_headers=["*"]
 )
 
-# Dosya yolları ve konfigürasyon
+# Dosya yolları
 DB_PATH = "users.json"
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
 API_URL = f"https://api-inference.huggingface.co/models/{MODEL_NAME}"
 
-# Varsayılan limitler
+# Limitler
 DAILY_LIMIT = 100
-MAX_TOKENS = 200
+MAX_TOKENS = 150
+
+def get_local_ip():
+    """Bilgisayarın IP adresini bul"""
+    try:
+        # İnternet bağlantısı olan bir socket oluştur
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))  # Google DNS
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except:
+        return "127.0.0.1"
+
+# Sunucu bilgileri
+SERVER_IP = get_local_ip()
+SERVER_PORT = 8000
+BASE_URL = f"http://{SERVER_IP}:{SERVER_PORT}"
+
+# QR kodu oluşturmak için
+def generate_qr_code_url():
+    """Telefonda açmak için QR kodu URL'si"""
+    import urllib.parse
+    html_url = f"{BASE_URL}/test"
+    qr_url = f"https://api.qrserver.com/v1/create-qr-code/?size=200x200&data={urllib.parse.quote(html_url)}"
+    return qr_url
 
 def load_db():
     """Kullanıcı veritabanını yükle"""
@@ -52,15 +90,14 @@ def save_db(data):
         logger.error(f"Veritabanı kaydetme hatası: {e}")
         return False
 
-def get_model_response_v1(message):
-    """Model yanıtı - V1 (Daha basit format)"""
+def get_model_response_simple(message):
+    """Basit model yanıtı - Hata toleranslı"""
     if not HF_TOKEN:
-        logger.warning("HF_TOKEN bulunamadı")
-        return "API token bulunamadı. Lütfen HF_TOKEN ortam değişkenini ayarlayın."
+        return "🔑 API token bulunamadı. Lütfen HF_TOKEN ayarlayın."
     
     try:
-        # Mistral için uygun prompt formatı
-        formatted_prompt = f"<s>[INST] {message} [/INST]"
+        # Daha kısa ve basit prompt
+        prompt = f"Kullanıcı soruyor: {message}\nYanıt:"
         
         response = requests.post(
             API_URL,
@@ -69,216 +106,214 @@ def get_model_response_v1(message):
                 "Content-Type": "application/json"
             },
             json={
-                "inputs": formatted_prompt,
+                "inputs": prompt,
                 "parameters": {
                     "max_new_tokens": MAX_TOKENS,
                     "temperature": 0.7,
-                    "top_p": 0.95,
+                    "top_p": 0.9,
                     "do_sample": True,
                     "return_full_text": False
                 }
             },
-            timeout=30
+            timeout=15
         )
         
-        logger.info(f"API Yanıt Kodu: {response.status_code}")
+        logger.info(f"API Status: {response.status_code}")
         
         if response.status_code == 200:
             result = response.json()
-            logger.info(f"API Yanıtı: {result}")
             
-            # Farklı response formatlarını işle
+            # Farklı formatları işle
             if isinstance(result, list):
-                if len(result) > 0:
-                    if isinstance(result[0], dict):
-                        # Format 1: [{'generated_text': '...'}]
-                        if 'generated_text' in result[0]:
-                            text = result[0]['generated_text']
-                            # Prompt'u temizle
+                for item in result:
+                    if isinstance(item, dict):
+                        # Format: [{'generated_text': '...'}]
+                        if 'generated_text' in item:
+                            text = item['generated_text']
                             if isinstance(text, str):
-                                text = text.replace(formatted_prompt, "").strip()
-                                return text
+                                # Prompt'u temizle
+                                text = text.replace(prompt, "").strip()
+                                if text:
+                                    return text
                         
-                        # Format 2: [{'generated_text': [{'content': '...'}]}]
-                        for key in result[0]:
-                            if isinstance(result[0][key], str):
-                                text = result[0][key]
-                                text = text.replace(formatted_prompt, "").strip()
-                                return text
+                        # Diğer formatlar
+                        for key, value in item.items():
+                            if isinstance(value, str) and len(value) > 10:
+                                cleaned = value.replace(prompt, "").strip()
+                                if cleaned:
+                                    return cleaned
             
-            # Direk string dönerse
-            if isinstance(result, str):
-                return result.replace(formatted_prompt, "").strip()
-                
-            return "Yanıt alındı ancak format beklenmiyor."
+            return "🤖 Yanıt alındı ancak işlenemedi."
         
         elif response.status_code == 503:
-            logger.warning("Model yükleniyor...")
-            return "Model şu anda yükleniyor, lütfen 10-20 saniye sonra tekrar deneyin."
+            return "⏳ Model yükleniyor, lütfen 15 saniye bekleyin..."
         
         elif response.status_code == 429:
-            return "Çok fazla istek gönderildi. Lütfen bir süre bekleyin."
-        
-        elif response.status_code == 401:
-            return "API token geçersiz. Lütfen token'ı kontrol edin."
+            return "🚫 Çok fazla istek, lütfen bekleyin."
         
         else:
-            logger.error(f"API Hatası: {response.status_code} - {response.text[:200]}")
-            return f"API hatası: {response.status_code}"
-        
-    except requests.exceptions.Timeout:
-        logger.error("API timeout hatası")
-        return "Model yanıt verme süresi aşıldı. Lütfen daha sonra tekrar deneyin."
+            return f"❌ API hatası: {response.status_code}"
     
-    except requests.exceptions.ConnectionError:
-        logger.error("API bağlantı hatası")
-        return "API'ye bağlanılamadı. Lütfen internet bağlantınızı kontrol edin."
+    except requests.exceptions.Timeout:
+        return "⏱️ Zaman aşımı, lütfen daha kısa soru sorun."
     
     except Exception as e:
-        logger.error(f"Model iletişim hatası: {str(e)}")
-        return f"Beklenmeyen hata: {str(e)}"
+        logger.error(f"Model hatası: {e}")
+        return f"⚠️ Teknik hata: {str(e)[:50]}"
 
-def get_model_response_v2(message):
-    """Model yanıtı - V2 (Alternatif yaklaşım)"""
-    if not HF_TOKEN:
-        return "API token bulunamadı."
-    
-    try:
-        # Daha basit prompt formatı
-        formatted_prompt = f"Kullanıcı: {message}\nAsistan:"
-        
-        response = requests.post(
-            API_URL,
-            headers={"Authorization": f"Bearer {HF_TOKEN}"},
-            json={
-                "inputs": formatted_prompt,
-                "parameters": {
-                    "max_new_tokens": 150,
-                    "temperature": 0.8,
-                    "top_k": 50,
-                    "return_full_text": False
-                }
-            },
-            timeout=25
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    """Ana sayfa - QR kodu ve bağlantılar"""
+    html_content = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>AI Chat API - Telefon Erişimi</title>
+        <style>
+            body {{
+                font-family: Arial, sans-serif;
+                max-width: 800px;
+                margin: 0 auto;
+                padding: 20px;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                min-height: 100vh;
+                color: white;
+            }}
+            .container {{
+                background: rgba(255,255,255,0.95);
+                border-radius: 20px;
+                padding: 30px;
+                color: #333;
+                box-shadow: 0 10px 40px rgba(0,0,0,0.3);
+            }}
+            h1 {{ color: #4f46e5; }}
+            .qr-container {{
+                text-align: center;
+                margin: 30px 0;
+                padding: 20px;
+                background: #f8fafc;
+                border-radius: 15px;
+            }}
+            .qr-code {{
+                width: 200px;
+                height: 200px;
+                margin: 0 auto;
+                background: white;
+                padding: 10px;
+                border-radius: 10px;
+            }}
+            .link-box {{
+                background: #e0f2fe;
+                padding: 15px;
+                border-radius: 10px;
+                margin: 10px 0;
+                word-break: break-all;
+            }}
+            .btn {{
+                display: inline-block;
+                background: #4f46e5;
+                color: white;
+                padding: 12px 24px;
+                text-decoration: none;
+                border-radius: 10px;
+                margin: 5px;
+                font-weight: bold;
+            }}
+            .status {{
+                padding: 10px;
+                border-radius: 8px;
+                margin: 10px 0;
+            }}
+            .success {{ background: #d1fae5; color: #065f46; }}
+            .warning {{ background: #fef3c7; color: #92400e; }}
+            .error {{ background: #fee2e2; color: #dc2626; }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🤖 AI Chat API</h1>
+            <p>Telefonunuzdan bağlanmak için:</p>
             
-            # Basit format çözümleme
-            if isinstance(result, list):
-                for item in result:
-                    if isinstance(item, dict):
-                        for key, value in item.items():
-                            if isinstance(value, str):
-                                # Prompt'u temizle
-                                cleaned = value.replace(formatted_prompt, "").strip()
-                                if cleaned:
-                                    return cleaned
-                            elif isinstance(value, list):
-                                for sub_item in value:
-                                    if isinstance(sub_item, dict) and 'content' in sub_item:
-                                        return sub_item['content']
+            <div class="status {'success' if HF_TOKEN else 'warning'}">
+                <strong>Model Durumu:</strong> {'✅ Hazır' if HF_TOKEN else '⚠️ Token Eksik'}
+            </div>
             
-            return "Anlamlı bir yanıt alınamadı."
-        
-        return "Model geçici olarak kullanılamıyor."
-    
-    except Exception:
-        return "Bağlantı hatası oluştu."
-
-def get_model_response_v3(message):
-    """Model yanıtı - V3 (En basit)"""
-    if not HF_TOKEN:
-        return "Sistem hazır değil. Lütfen daha sonra tekrar deneyin."
-    
-    try:
-        # En basit yaklaşım
-        response = requests.post(
-            API_URL,
-            headers={"Authorization": f"Bearer {HF_TOKEN}"},
-            json={"inputs": message},
-            timeout=20
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
+            <div class="qr-container">
+                <h3>📱 Telefon ile Bağlan</h3>
+                <p>Telefon kameranızla bu QR kodu tarayın:</p>
+                <div class="qr-code">
+                    <img src="{generate_qr_code_url()}" width="200" height="200">
+                </div>
+                <p style="font-size: 14px; color: #666;">veya bağlantıya tıklayın</p>
+            </div>
             
-            # Çok basit parsing
-            if isinstance(result, list):
-                return str(result[0]) if result else "Boş yanıt"
-            elif isinstance(result, dict):
-                for value in result.values():
-                    if isinstance(value, str) and value.strip():
-                        return value.strip()
+            <h3>🔗 Bağlantılar:</h3>
+            <div class="link-box">
+                <strong>Test Arayüzü:</strong><br>
+                <a href="/test" class="btn">📲 Aç</a>
+                <a href="{BASE_URL}/test" target="_blank">{BASE_URL}/test</a>
+            </div>
             
-            return "Yanıt işlenemedi"
-        
-        return f"Hata kodu: {response.status_code}"
-    
-    except Exception:
-        return "Servis geçici olarak kullanılamıyor."
-
-def get_model_response(message):
-    """Ana model yanıt fonksiyonu - Tüm versiyonları dener"""
-    logger.info(f"Gelen mesaj: {message}")
-    
-    # Versiyonları sırayla dene
-    responses = []
-    
-    # V1'i dene
-    response_v1 = get_model_response_v1(message)
-    if response_v1 and len(response_v1) > 10 and "token" not in response_v1.lower() and "hata" not in response_v1.lower():
-        return response_v1
-    responses.append(response_v1)
-    
-    # V2'yi dene
-    response_v2 = get_model_response_v2(message)
-    if response_v2 and len(response_v2) > 10 and "token" not in response_v2.lower() and "hata" not in response_v2.lower():
-        return response_v2
-    responses.append(response_v2)
-    
-    # V3'ü dene
-    response_v3 = get_model_response_v3(message)
-    if response_v3 and len(response_v3) > 10:
-        return response_v3
-    
-    # Hiçbiri çalışmazsa en iyi yanıtı seç
-    for resp in responses:
-        if resp and len(resp) > 5:
-            return resp
-    
-    return "Üzgünüm, şu anda yanıt veremiyorum. Lütfen daha sonra tekrar deneyin."
-
-@app.get("/")
-def home():
-    """Ana sayfa"""
-    return {
-        "app": "AI Chat API",
-        "version": "1.0.0",
-        "status": "active",
-        "endpoints": {
-            "health": "/health",
-            "chat": "/api/chat (POST)",
-            "stats": "/api/stats/{email} (GET)"
-        }
-    }
+            <div class="link-box">
+                <strong>API Dokümantasyon:</strong><br>
+                <a href="/docs" class="btn">📚 Aç</a>
+                <a href="{BASE_URL}/docs" target="_blank">{BASE_URL}/docs</a>
+            </div>
+            
+            <div class="link-box">
+                <strong>Health Check:</strong><br>
+                <a href="/health" class="btn">🩺 Aç</a>
+                <a href="{BASE_URL}/health" target="_blank">{BASE_URL}/health</a>
+            </div>
+            
+            <div style="margin-top: 30px; padding-top: 20px; border-top: 2px solid #e5e7eb;">
+                <h4>📋 Bilgiler:</h4>
+                <p><strong>IP Adresi:</strong> {SERVER_IP}</p>
+                <p><strong>Port:</strong> {SERVER_PORT}</p>
+                <p><strong>Model:</strong> {MODEL_NAME}</p>
+                <p><strong>Günlük Limit:</strong> {DAILY_LIMIT} sorgu/kullanıcı</p>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
 
 @app.get("/health")
-def health():
-    """Sağlık kontrolü"""
-    token_status = "valid" if HF_TOKEN else "missing"
+async def health():
+    """Sağlık kontrolü - JSON formatında"""
     db_status = "exists" if os.path.exists(DB_PATH) else "missing"
+    token_exists = bool(HF_TOKEN)
     
     return {
-        "status": "healthy",
+        "status": "healthy" if token_exists else "no_token",
         "timestamp": datetime.now().isoformat(),
-        "token": token_status,
-        "database": db_status,
+        "server_ip": SERVER_IP,
+        "port": SERVER_PORT,
         "model": MODEL_NAME,
-        "daily_limit": DAILY_LIMIT
+        "token": "valid" if token_exists else "missing",
+        "database": db_status,
+        "daily_limit": DAILY_LIMIT,
+        "api_url": f"http://{SERVER_IP}:{SERVER_PORT}",
+        "test_url": f"http://{SERVER_IP}:{SERVER_PORT}/test"
     }
 
+@app.get("/test", response_class=HTMLResponse)
+async def test_page():
+    """Test arayüzü sayfası"""
+    with open("test.html", "r", encoding="utf-8") as f:
+        html_content = f.read()
+    
+    # API URL'sini dinamik olarak ayarla
+    html_content = html_content.replace(
+        'const API_BASE_URL = \'http://localhost:8000\';',
+        f'const API_BASE_URL = \'http://{SERVER_IP}:{SERVER_PORT}\';'
+    )
+    
+    return HTMLResponse(content=html_content)
+
 @app.post("/api/chat")
 async def chat(request: Request):
     """Chat endpoint'i"""
@@ -287,28 +322,19 @@ async def chat(request: Request):
         email = data.get("email", "").strip().lower()
         message = data.get("message", "").strip()
         
-        logger.info(f"Chat isteği - Email: {email}, Mesaj: {message[:50]}...")
+        logger.info(f"Chat isteği: {email} - {message[:30]}...")
         
         # Validasyon
         if not email or "@" not in email:
-            return JSONResponse(
-                status_code=400,
-                content={"error": "Geçerli bir email adresi giriniz."}
-            )
+            raise HTTPException(400, "Geçerli email gerekli")
         
         if not message:
-            return JSONResponse(
-                status_code=400,
-                content={"error": "Mesaj boş olamaz."}
-            )
+            raise HTTPException(400, "Mesaj boş olamaz")
         
-        if len(message) > 1000:
-            return JSONResponse(
-                status_code=400,
-                content={"error": "Mesaj çok uzun. Maksimum 1000 karakter."}
-            )
+        if len(message) > 500:
+            raise HTTPException(400, "Mesaj çok uzun (max 500 karakter)")
         
-        # Veritabanı işlemleri
+        # Veritabanı
         db = load_db()
         today = date.today().isoformat()
         
@@ -317,145 +343,126 @@ async def chat(request: Request):
                 "count": 0,
                 "total": 0,
                 "last_reset": today,
-                "created_at": datetime.now().isoformat(),
-                "last_used": datetime.now().isoformat()
+                "created": datetime.now().isoformat()
             }
         
         user = db[email]
         
-        # Günlük limit kontrolü
+        # Limit kontrol
         if user["last_reset"] != today:
             user["count"] = 0
             user["last_reset"] = today
         
         if user["count"] >= DAILY_LIMIT:
-            return JSONResponse(
-                status_code=429,
-                content={
-                    "error": "Günlük limit doldu",
-                    "limit": DAILY_LIMIT,
-                    "reset_date": today
-                }
-            )
-        
-        # Model yanıtını al
-        start_time = datetime.now()
-        ai_response = get_model_response(message)
-        response_time = (datetime.now() - start_time).total_seconds()
-        
-        logger.info(f"Yanıt süresi: {response_time:.2f}s")
+            raise HTTPException(429, f"Günlük limit ({DAILY_LIMIT}) doldu")
         
-        # Kullanıcı istatistiklerini güncelle
+        # Model yanıtı
+        ai_response = get_model_response_simple(message)
         user["count"] += 1
         user["total"] += 1
-        user["last_used"] = datetime.now().isoformat()
         
-        # Veritabanını kaydet
         save_db(db)
         
-        # Yanıt
         return {
             "response": ai_response,
             "status": "success",
             "remaining": DAILY_LIMIT - user["count"],
             "used_today": user["count"],
             "total_used": user["total"],
-            "response_time": f"{response_time:.2f}s"
+            "timestamp": datetime.now().isoformat()
         }
         
-    except json.JSONDecodeError:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Geçersiz JSON formatı"}
-        )
-    
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Chat hatası: {str(e)}")
-        return JSONResponse(
-            status_code=500,
-            content={"error": f"Sunucu hatası: {str(e)}"}
-        )
+        logger.error(f"Chat hatası: {e}")
+        raise HTTPException(500, f"Sunucu hatası: {str(e)}")
 
 @app.get("/api/stats/{email}")
-def get_stats(email: str):
-    """Kullanıcı istatistiklerini getir"""
-    try:
-        email = email.strip().lower()
-        db = load_db()
-        
-        if email not in db:
-            return JSONResponse(
-                status_code=404,
-                content={"error": "Kullanıcı bulunamadı"}
-            )
-        
-        user = db[email]
-        today = date.today().isoformat()
-        
-        # Günlük limit sıfırlama kontrolü
-        if user["last_reset"] != today:
-            user["count"] = 0
-            user["last_reset"] = today
-            save_db(db)
-        
-        return {
-            "email": email,
-            "used_today": user["count"],
-            "remaining_today": DAILY_LIMIT - user["count"],
-            "total_used": user["total"],
-            "last_reset": user["last_reset"],
-            "last_used": user.get("last_used", "never"),
-            "created_at": user.get("created_at", "unknown")
-        }
-        
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={"error": str(e)}
-        )
+async def get_stats(email: str):
+    """İstatistikler"""
+    email = email.strip().lower()
+    db = load_db()
+    
+    if email not in db:
+        raise HTTPException(404, "Kullanıcı bulunamadı")
+    
+    user = db[email]
+    today = date.today().isoformat()
+    
+    if user["last_reset"] != today:
+        user["count"] = 0
+        user["last_reset"] = today
+        save_db(db)
+    
+    return {
+        "email": email,
+        "used_today": user["count"],
+        "remaining_today": DAILY_LIMIT - user["count"],
+        "total_used": user["total"],
+        "last_reset": user["last_reset"],
+        "created": user.get("created", "unknown")
+    }
 
-@app.get("/api/reset-test/{email}")
-def reset_test(email: str):
-    """Test için kullanıcı limitini sıfırla"""
-    try:
-        email = email.strip().lower()
-        db = load_db()
+@app.get("/api/reset/{email}")
+async def reset_limit(email: str):
+    """Limit sıfırlama (test için)"""
+    email = email.strip().lower()
+    db = load_db()
+    
+    if email in db:
+        db[email]["count"] = 0
+        db[email]["last_reset"] = date.today().isoformat()
+        save_db(db)
         
-        if email in db:
-            db[email]["count"] = 0
-            db[email]["last_reset"] = date.today().isoformat()
-            save_db(db)
-            
-            return {
-                "status": "success",
-                "message": f"{email} limiti sıfırlandı"
-            }
-        else:
-            return JSONResponse(
-                status_code=404,
-                content={"error": "Kullanıcı bulunamadı"}
-            )
-            
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={"error": str(e)}
-        )
+        return {"status": "success", "message": f"{email} limiti sıfırlandı"}
+    else:
+        raise HTTPException(404, "Kullanıcı bulunamadı")
+
+@app.get("/api/info")
+async def api_info():
+    """API bilgileri"""
+    return {
+        "api_name": "AI Chat API",
+        "version": "2.0.0",
+        "model": MODEL_NAME,
+        "server_ip": SERVER_IP,
+        "port": SERVER_PORT,
+        "base_url": f"http://{SERVER_IP}:{SERVER_PORT}",
+        "endpoints": {
+            "home": "/",
+            "test_ui": "/test",
+            "chat": "POST /api/chat",
+            "health": "GET /health",
+            "stats": "GET /api/stats/{email}",
+            "reset": "GET /api/reset/{email}",
+            "docs": "/docs"
+        }
+    }
 
 if __name__ == "__main__":
     import uvicorn
     
-    logger.info("=" * 50)
-    logger.info("AI Chat API Başlatılıyor...")
-    logger.info(f"Model: {MODEL_NAME}")
-    logger.info(f"Token Durumu: {'Var' if HF_TOKEN else 'Yok'}")
-    logger.info(f"Günlük Limit: {DAILY_LIMIT}")
-    logger.info("=" * 50)
+    logger.info("=" * 60)
+    logger.info("🤖 AI Chat API Başlatılıyor...")
+    logger.info(f"📡 Sunucu IP: {SERVER_IP}")
+    logger.info(f"🔌 Port: {SERVER_PORT}")
+    logger.info(f"🧠 Model: {MODEL_NAME}")
+    logger.info(f"🔑 Token: {'✅ Var' if HF_TOKEN else '❌ Yok'}")
+    logger.info(f"📊 Günlük Limit: {DAILY_LIMIT}")
+    logger.info("=" * 60)
+    logger.info("📱 Telefon bağlantıları:")
+    logger.info(f"   • Test Arayüzü: http://{SERVER_IP}:{SERVER_PORT}/test")
+    logger.info(f"   • API Doküman: http://{SERVER_IP}:{SERVER_PORT}/docs")
+    logger.info(f"   • Health Check: http://{SERVER_IP}:{SERVER_PORT}/health")
+    logger.info("=" * 60)
     
+    # Uvicorn'u başlat
     uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=8000,
+        app,
+        host="0.0.0.0",  # Tüm ağlardan erişime izin ver
+        port=SERVER_PORT,
         reload=True,
-        log_level="info"
+        log_level="info",
+        access_log=True
     )