Upload 20 files

Dockerfile

@@ -16,6 +16,7 @@ RUN mkdir -p /app/.torch_cache && chmod -R 777 /app/.torch_cache
 
 # === Gereken kütüphaneleri yükle
 COPY requirements.txt ./
+COPY controllers/ ./controllers/
 RUN pip install --no-cache-dir -r requirements.txt
 
 # === Uygulama dosyalarını kopyala

app.py

@@ -1,80 +1,31 @@
-import os
-import threading
-import uvicorn
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
-from service_config import ServiceConfig
-from session import SessionStore
-from llm_model import LLMModel, Message
-from chat_handler import handle_chat
-from log import log
-
-# Global nesneler
-service_config = ServiceConfig()
-session_store = SessionStore()
-llm_models = {}  # project_name -> LLMModel instance
-
-# FastAPI uygulaması
-app = FastAPI()
-
-@app.get("/")
-def health():
-    return {"status": "ok"}
-
-@app.post("/start_chat")
-def start_chat(request: Request):
-    project_name = request.query_params.get("project_name")
-    if not project_name:
-        raise HTTPException(status_code=400, detail="project_name parametresi gereklidir.")
-
-    if project_name not in service_config.projects:
-        raise HTTPException(status_code=400, detail="Geçersiz project_name değeri.")
-
-    session = session_store.create_session(project_name)
-    log(f"🆕 Yeni session başlatıldı: {session.session_id} (proje: {project_name})")
-    return {"session_id": session.session_id}
-
-@app.post("/reload_config")
-def reload_config():
-    try:
-        service_config.load(is_reload=True)
-        log("🔁 Config reload sonrası tüm projeler için modeller yeniden yükleniyor...")
-        for project_name in service_config.projects:
-            llm_config = service_config.get_project_llm_config(project_name)
-            model_base = llm_config["model_base"]
-            model_instance = LLMModel()
-            model_instance.setup(service_config, llm_config)
-            llm_models[project_name] = model_instance
-            log(f"✅ '{project_name}' için model yüklendi.")
-        return {"status": "ok", "message": "Konfigürasyon ve modeller yeniden yüklendi."}
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-@app.post("/chat")
-async def chat(msg: Message, request: Request):
-    session_id = request.headers.get("X-Session-ID")
-    if not session_id:
-        return JSONResponse(content={"error": "Session ID eksik."}, status_code=400)
-
-    session = session_store.get_session(session_id)
-    if not session:
-        return JSONResponse(content={"error": "Geçersiz veya süresi dolmuş session."}, status_code=400)
-
-    project_name = session.project_name
-    llm_model = llm_models.get(project_name)
-    if llm_model is None:
-        return JSONResponse(content={"error": f"{project_name} için model yüklenmemiş."}, status_code=500)
-
-    return await handle_chat(msg, request, app, service_config, session, llm_model)
-
-if __name__ == "__main__":
-    log("🌐 Servis başlatılıyor...")
-    service_config.load(is_reload=False)
-    for project_name in service_config.projects:
-        llm_config = service_config.get_project_llm_config(project_name)
-        model_base = llm_config["model_base"]
-        model_instance = LLMModel()
-        model_instance.setup(service_config, llm_config)
-        llm_models[project_name] = model_instance
-        log(f"✅ '{project_name}' için model yüklendi.")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+from fastapi import FastAPI
+from controllers import chat_controller, test_controller, admin_controller, health_controller
+from service_config import ServiceConfig
+from session import SessionStore
+from llm_model import LLMModel
+from log import log
+
+service_config = ServiceConfig()
+session_store = SessionStore()
+llm_models = {}
+
+app = FastAPI()
+
+app.include_router(health_controller.router)
+app.include_router(chat_controller.router)
+app.include_router(test_controller.router)
+app.include_router(admin_controller.router)
+
+if __name__ == "__main__":
+    log("🌐 Servis başlatılıyor...")
+    service_config.load(is_reload=False)
+    for project_name in service_config.projects:
+        llm_config = service_config.get_project_llm_config(project_name)
+        model_instance = LLMModel()
+        model_instance.setup(service_config, llm_config)
+        llm_models[project_name] = model_instance
+        log(f"✅ '{project_name}' için model yüklendi.")
+
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+

chat_handler_debug.py

@@ -1,135 +1,135 @@
-from fastapi import Request
-from fastapi.responses import JSONResponse
-import traceback, random
-from intent import extract_parameters, validate_variable_formats, detect_intent
-from intent_api import execute_intent
-from llm_model import generate_response, get_model, get_tokenizer, Message
-from log import log
-
-DEBUG = True
-
-async def handle_chat(msg: Message, request: Request, app, s_config):
-    user_input = msg.user_input.strip()
-    session_id = request.headers.get("X-Session-ID", "demo-session")
-
-    if not hasattr(app.state, "session_store"):
-        app.state.session_store = {}
-
-    session_store = getattr(app.state, "session_store", {})
-    session = session_store.get(session_id, {
-        "session_id": session_id,
-        "variables": {},
-        "auth_tokens": {},
-        "last_intent": None,
-        "awaiting_variable": None
-    })
-
-    try:
-        if get_model() is None or get_tokenizer() is None:
-            return {"error": "Model yüklenmedi."}
-
-        detected_intent, intent_conf = await detect_intent(user_input)
-        if DEBUG:
-            log(f"🎯 Intent tespiti: {detected_intent}, Confidence: {intent_conf:.2f}")
-
-        current_intent = session.get("last_intent")
-        awaiting_variable = session.get("awaiting_variable")
-
-        if DEBUG:
-            log(f"📦 Session: {session}")
-            log(f"🧩 Awaiting: {awaiting_variable}, Last Intent: {current_intent}")
-
-        if (
-            awaiting_variable and
-            detected_intent and
-            detected_intent != current_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD
-        ):
-            log("🧹 Konu değişikliği algılandı → context sıfırlanıyor")
-            session["awaiting_variable"] = None
-            session["variables"] = {}
-            session["last_intent"] = detected_intent
-            current_intent = detected_intent
-
-        intent_is_valid = (
-            detected_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD and
-            detected_intent in s_config.INTENT_DEFINITIONS
-        )
-        if DEBUG:
-            log(f"✅ Intent geçerli mi?: {intent_is_valid}")
-
-        if intent_is_valid:
-            session["last_intent"] = detected_intent
-            definition = s_config.INTENT_DEFINITIONS[detected_intent]
-            pattern_list = definition.get("variables", [])
-            data_formats = s_config.DATA_FORMATS
-            variable_format_map = definition.get("variable_formats", {})
-
-            if awaiting_variable:
-                extracted = extract_parameters(pattern_list, user_input)
-                for p in extracted:
-                    if p["key"] == awaiting_variable:
-                        session["variables"][awaiting_variable] = p["value"]
-                        session["awaiting_variable"] = None
-                        log(f"✅ Awaiting parametre tamamlandı: {awaiting_variable} = {p['value']}")
-                        break
-
-            extracted = extract_parameters(pattern_list, user_input)
-            variables = {p["key"]: p["value"] for p in extracted}
-            session.setdefault("variables", {}).update(variables)
-
-            if DEBUG:
-                log(f"🧪 Tespit edilen parametreler: {variables}")
-
-            is_valid, validation_errors = validate_variable_formats(session["variables"], variable_format_map, data_formats)
-            if DEBUG:
-                log(f"📛 Validasyon hataları: {validation_errors}")
-
-            if not is_valid:
-                session["awaiting_variable"] = list(validation_errors.keys())[0]
-                session_store[session_id] = session
-                app.state.session_store = session_store
-                return {"response": list(validation_errors.values())[0]}
-
-            expected_vars = list(variable_format_map.keys())
-            missing_vars = [v for v in expected_vars if v not in session["variables"]]
-            if DEBUG:
-                log(f"📌 Beklenen parametreler: {expected_vars}, Eksik: {missing_vars}")
-
-            if missing_vars:
-                session["awaiting_variable"] = missing_vars[0]
-                session_store[session_id] = session
-                app.state.session_store = session_store
-                return {"response": f"Lütfen {missing_vars[0]} bilgisini belirtir misiniz?"}
-
-            log("🚀 execute_intent() çağrılıyor...")
-            result = execute_intent(
-                detected_intent,
-                user_input,
-                session,
-                s_config.INTENT_DEFINITIONS,
-                s_config.DATA_FORMATS
-            )
-            if "reply" in result:
-                session_store[session_id] = result["session"]
-                app.state.session_store = session_store
-                return {"reply": result["reply"]}
-            elif "errors" in result:
-                session_store[session_id] = result["session"]
-                app.state.session_store = session_store
-                return {"response": list(result["errors"].values())[0]}
-            else:
-                return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
-
-        log("🤖 execute_intent çağrılmadı → LLM fallback devrede")
-        session["awaiting_variable"] = None
-        session["variables"] = {}
-        response, response_conf = await generate_response(user_input, s_config)
-        if response_conf is not None and response_conf < s_config.LLM_CONFIDENCE_THRESHOLD:
-            return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
-        return {"response": response}
-
-    except Exception as e:
-        traceback.print_exc()
-        return JSONResponse(content={"error": str(e)}, status_code=500)
+from fastapi import Request
+from fastapi.responses import JSONResponse
+import traceback, random
+from intent import extract_parameters, validate_variable_formats, detect_intent
+from intent_api import execute_intent
+from llm_model import generate_response, get_model, get_tokenizer, Message
+from log import log
+
+DEBUG = True
+
+async def handle_chat(msg: Message, request: Request, app, s_config):
+    user_input = msg.user_input.strip()
+    session_id = request.headers.get("X-Session-ID", "demo-session")
+
+    if not hasattr(app.state, "session_store"):
+        app.state.session_store = {}
+
+    session_store = getattr(app.state, "session_store", {})
+    session = session_store.get(session_id, {
+        "session_id": session_id,
+        "variables": {},
+        "auth_tokens": {},
+        "last_intent": None,
+        "awaiting_variable": None
+    })
+
+    try:
+        if get_model() is None or get_tokenizer() is None:
+            return {"error": "Model yüklenmedi."}
+
+        detected_intent, intent_conf = await detect_intent(user_input)
+        if DEBUG:
+            log(f"🎯 Intent tespiti: {detected_intent}, Confidence: {intent_conf:.2f}")
+
+        current_intent = session.get("last_intent")
+        awaiting_variable = session.get("awaiting_variable")
+
+        if DEBUG:
+            log(f"📦 Session: {session}")
+            log(f"🧩 Awaiting: {awaiting_variable}, Last Intent: {current_intent}")
+
+        if (
+            awaiting_variable and
+            detected_intent and
+            detected_intent != current_intent and
+            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD
+        ):
+            log("🧹 Konu değişikliği algılandı → context sıfırlanıyor")
+            session["awaiting_variable"] = None
+            session["variables"] = {}
+            session["last_intent"] = detected_intent
+            current_intent = detected_intent
+
+        intent_is_valid = (
+            detected_intent and
+            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD and
+            detected_intent in s_config.INTENT_DEFINITIONS
+        )
+        if DEBUG:
+            log(f"✅ Intent geçerli mi?: {intent_is_valid}")
+
+        if intent_is_valid:
+            session["last_intent"] = detected_intent
+            definition = s_config.INTENT_DEFINITIONS[detected_intent]
+            pattern_list = definition.get("variables", [])
+            data_formats = s_config.DATA_FORMATS
+            variable_format_map = definition.get("variable_formats", {})
+
+            if awaiting_variable:
+                extracted = extract_parameters(pattern_list, user_input)
+                for p in extracted:
+                    if p["key"] == awaiting_variable:
+                        session["variables"][awaiting_variable] = p["value"]
+                        session["awaiting_variable"] = None
+                        log(f"✅ Awaiting parametre tamamlandı: {awaiting_variable} = {p['value']}")
+                        break
+
+            extracted = extract_parameters(pattern_list, user_input)
+            variables = {p["key"]: p["value"] for p in extracted}
+            session.setdefault("variables", {}).update(variables)
+
+            if DEBUG:
+                log(f"🧪 Tespit edilen parametreler: {variables}")
+
+            is_valid, validation_errors = validate_variable_formats(session["variables"], variable_format_map, data_formats)
+            if DEBUG:
+                log(f"📛 Validasyon hataları: {validation_errors}")
+
+            if not is_valid:
+                session["awaiting_variable"] = list(validation_errors.keys())[0]
+                session_store[session_id] = session
+                app.state.session_store = session_store
+                return {"response": list(validation_errors.values())[0]}
+
+            expected_vars = list(variable_format_map.keys())
+            missing_vars = [v for v in expected_vars if v not in session["variables"]]
+            if DEBUG:
+                log(f"📌 Beklenen parametreler: {expected_vars}, Eksik: {missing_vars}")
+
+            if missing_vars:
+                session["awaiting_variable"] = missing_vars[0]
+                session_store[session_id] = session
+                app.state.session_store = session_store
+                return {"response": f"Lütfen {missing_vars[0]} bilgisini belirtir misiniz?"}
+
+            log("🚀 execute_intent() çağrılıyor...")
+            result = execute_intent(
+                detected_intent,
+                user_input,
+                session,
+                s_config.INTENT_DEFINITIONS,
+                s_config.DATA_FORMATS
+            )
+            if "reply" in result:
+                session_store[session_id] = result["session"]
+                app.state.session_store = session_store
+                return {"reply": result["reply"]}
+            elif "errors" in result:
+                session_store[session_id] = result["session"]
+                app.state.session_store = session_store
+                return {"response": list(result["errors"].values())[0]}
+            else:
+                return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
+
+        log("🤖 execute_intent çağrılmadı → LLM fallback devrede")
+        session["awaiting_variable"] = None
+        session["variables"] = {}
+        response, response_conf = await generate_response(user_input, s_config)
+        if response_conf is not None and response_conf < s_config.LLM_CONFIDENCE_THRESHOLD:
+            return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
+        return {"response": response}
+
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(content={"error": str(e)}, status_code=500)

controllers/admin_controller.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter
+from app import service_config, llm_models
+from llm_model import LLMModel
+from fastapi.responses import JSONResponse
+from log import log
+
+router = APIRouter()
+
+@router.post("/reload_config")
+def reload_config():
+    try:
+        service_config.load(is_reload=True)
+        log("🔁 Config reload sonrası tüm projeler için modeller yeniden yükleniyor...")
+        for project_name in service_config.projects:
+            llm_config = service_config.get_project_llm_config(project_name)
+            model_instance = LLMModel()
+            model_instance.setup(service_config, llm_config)
+            llm_models[project_name] = model_instance
+            log(f"✅ '{project_name}' için model yüklendi.")
+        return {"status": "ok", "message": "Konfigürasyon ve modeller yeniden yüklendi."}
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)

controllers/chat_controller.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, Request
+from llm_model import Message
+from chat_handler import handle_chat
+from app import service_config, session_store, llm_models
+
+router = APIRouter()
+
+@router.post("/chat")
+async def chat_endpoint(msg: Message, request: Request):
+    session_id = request.headers.get("X-Session-ID")
+    if not session_id:
+        return {"error": "Session ID eksik."}
+
+    session = session_store.get_session(session_id)
+    if not session:
+        return {"error": "Geçersiz veya süresi dolmuş session."}
+
+    project_name = session.project_name
+    llm_model = llm_models.get(project_name)
+    if llm_model is None:
+        return {"error": f"{project_name} için model yüklenmemiş."}
+
+    return await handle_chat(msg, request, None, service_config, session, llm_model)

controllers/health_controller.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/")
+def health():
+    return {"status": "ok"}

controllers/test_controller.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+import threading
+import intent_test_runner
+from log import log
+
+router = APIRouter()
+
+@router.post("/run_tests", status_code=202)
+def run_tests():
+    log("🚦 /run_tests çağrıldı. Testler başlatılıyor...")
+    threading.Thread(target=intent_test_runner.run_all_tests, daemon=True).start()
+    return {"status": "running", "message": "Test süreci başlatıldı."}

intent_system_design.md

@@ -1,137 +1,137 @@
-# Intent Tabanlı Chatbot Sistem Tasarımı (v1)
-
-Bu doküman, niyet (intent) tespiti, parametre çıkarımı, REST API entegrasyonu, session yönetimi, veri doğrulama ve LLM destekli hibrit karar mekanizmasını içeren chatbot altyapısını detaylı olarak tanımlar.
-
----
-
-## 🧠 Amaç
-
-- Kullanıcı ifadelerinden "intent" algılanması
-- Parametrelerin (variables) otomatik çıkarılması
-- Eksik ya da hatalı parametrelerin sorgulanması
-- Format kontrolleri ve validasyon
-- Gerekirse REST API çağrıları
-- Session bazlı token yönetimi
-- Gelen cevabın insani cevaplaşa dönüşü
-- Gelişmiş kararlar için hibrit sistem (LLM + logic)
-
----
-
-## 📂 JSON Şema (Intent + Data Format)
-
-```json
-{
-  "data_formats": [
-    {
-      "name": "currency_format",
-      "valid_options": ["dolar", "euro", "TL"],
-      "error_message": "Geçerli bir döviz cinsi belirtmelisiniz."
-    },
-    {
-      "name": "client_no_format",
-      "pattern": "^[0-9]{6}$",
-      "error_message": "Müşteri numaranız 6 haneli olmalıdır."
-    }
-  ],
-  "intents": [
-    {
-      "name": "doviz-kuru-intent",
-      "examples": ["dolar kuru nedir?"],
-      "variables": ["currency:{dolar} kuru nedir?"],
-      "variable_formats": {
-        "currency": "currency_format"
-      },
-      "action": {
-        "url": "https://api.ex.com/doviz",
-        "method": "POST",
-        "headers": [
-          { "key": "Authorization", "value": "Bearer {auth_tokens.doviz-kuru-intent.token}" }
-        ],
-        "body": {
-          "currency": "{variables.currency}"
-        },
-        "timeout": 5,
-        "retry_count": 1,
-        "tls": {
-          "verify": true,
-          "ca_bundle": "/app/certs/my-ca.pem"
-        },
-        "auth": {
-          "auth_endpoint": "https://api.ex.com/auth",
-          "auth_body": { "username": "user", "password": "pass" },
-          "auth_token_path": "token",
-          "auth_refresh_endpoint": "https://api.ex.com/refresh",
-          "refresh_body": { "refresh_token": "{session.refresh_token}" }
-        },
-        "response_parser": {
-          "field": "rate",
-          "format": "{variables.currency} kuru: {rate} TL"
-        },
-        "reply_template": "{variables.currency} kuru şu an {rate} TL."
-      }
-    }
-  ]
-}
-```
-
----
-
-## 🧭 Chat Akışı (Hibrit)
-
-1. Kullanıcıdan mesaj alınır (`POST /chat`)
-2. Session bulunur (`X-Session-ID` header)
-3. Intent tespiti (bert model)
-4. Parametreler `extract_parameters()` ile alınır
-5. `variable_formats` varsa validasyon yapılır
-6. Eksik/hatalı varsa `awaiting_variable` kaydedilir, soru sorulur
-7. Tüm parametreler tamamsa:
-   - Gerekirse auth token üretilir / yenilenir
-   - API çağrısı yapılır
-   - `response_parser` uygulanır
-   - `reply_template` ile mesaj hazır
-8. Session güncellenir, cevap döndürülür
-
----
-
-## 📦 Session Yapısı
-
-```json
-{
-  "session_id": "abc-123",
-  "variables": {
-    "tckn": "12345678900"
-  },
-  "auth_tokens": {
-    "doviz-kuru-intent": {
-      "token": "...",
-      "refresh_token": "..."
-    }
-  },
-  "awaiting_variable": "currency",
-  "last_intent": "doviz-kuru-intent"
-}
-```
-
----
-
-## 🧩 Placeholder Kullanımı
-
-| Amaç          | Yazım                          |
-|---------------|-------------------------------|
-| Parametre     | `{variables.currency}`        |
-| Session verisi| `{session.tckn}`             |
-| Token         | `{auth_tokens.intent.token}` |
-
----
-
-## ✅ Sonraki Adımlar
-
-- `resolve_placeholders()` fonksiyonu
-- `validate_variable_formats()`
-- `auth_token_handler()` → create + refresh
-- `execute_intent()` tam mantık
-- `log()` yapısı
-
----
-
-Bu tasarım, modüler ve üretim ortamı için ölçeklenebilir sağlam bir altyapı sunar.
+# Intent Tabanlı Chatbot Sistem Tasarımı (v1)
+
+Bu doküman, niyet (intent) tespiti, parametre çıkarımı, REST API entegrasyonu, session yönetimi, veri doğrulama ve LLM destekli hibrit karar mekanizmasını içeren chatbot altyapısını detaylı olarak tanımlar.
+
+---
+
+## 🧠 Amaç
+
+- Kullanıcı ifadelerinden "intent" algılanması
+- Parametrelerin (variables) otomatik çıkarılması
+- Eksik ya da hatalı parametrelerin sorgulanması
+- Format kontrolleri ve validasyon
+- Gerekirse REST API çağrıları
+- Session bazlı token yönetimi
+- Gelen cevabın insani cevaplaşa dönüşü
+- Gelişmiş kararlar için hibrit sistem (LLM + logic)
+
+---
+
+## 📂 JSON Şema (Intent + Data Format)
+
+```json
+{
+  "data_formats": [
+    {
+      "name": "currency_format",
+      "valid_options": ["dolar", "euro", "TL"],
+      "error_message": "Geçerli bir döviz cinsi belirtmelisiniz."
+    },
+    {
+      "name": "client_no_format",
+      "pattern": "^[0-9]{6}$",
+      "error_message": "Müşteri numaranız 6 haneli olmalıdır."
+    }
+  ],
+  "intents": [
+    {
+      "name": "doviz-kuru-intent",
+      "examples": ["dolar kuru nedir?"],
+      "variables": ["currency:{dolar} kuru nedir?"],
+      "variable_formats": {
+        "currency": "currency_format"
+      },
+      "action": {
+        "url": "https://api.ex.com/doviz",
+        "method": "POST",
+        "headers": [
+          { "key": "Authorization", "value": "Bearer {auth_tokens.doviz-kuru-intent.token}" }
+        ],
+        "body": {
+          "currency": "{variables.currency}"
+        },
+        "timeout": 5,
+        "retry_count": 1,
+        "tls": {
+          "verify": true,
+          "ca_bundle": "/app/certs/my-ca.pem"
+        },
+        "auth": {
+          "auth_endpoint": "https://api.ex.com/auth",
+          "auth_body": { "username": "user", "password": "pass" },
+          "auth_token_path": "token",
+          "auth_refresh_endpoint": "https://api.ex.com/refresh",
+          "refresh_body": { "refresh_token": "{session.refresh_token}" }
+        },
+        "response_parser": {
+          "field": "rate",
+          "format": "{variables.currency} kuru: {rate} TL"
+        },
+        "reply_template": "{variables.currency} kuru şu an {rate} TL."
+      }
+    }
+  ]
+}
+```
+
+---
+
+## 🧭 Chat Akışı (Hibrit)
+
+1. Kullanıcıdan mesaj alınır (`POST /chat`)
+2. Session bulunur (`X-Session-ID` header)
+3. Intent tespiti (bert model)
+4. Parametreler `extract_parameters()` ile alınır
+5. `variable_formats` varsa validasyon yapılır
+6. Eksik/hatalı varsa `awaiting_variable` kaydedilir, soru sorulur
+7. Tüm parametreler tamamsa:
+   - Gerekirse auth token üretilir / yenilenir
+   - API çağrısı yapılır
+   - `response_parser` uygulanır
+   - `reply_template` ile mesaj hazır
+8. Session güncellenir, cevap döndürülür
+
+---
+
+## 📦 Session Yapısı
+
+```json
+{
+  "session_id": "abc-123",
+  "variables": {
+    "tckn": "12345678900"
+  },
+  "auth_tokens": {
+    "doviz-kuru-intent": {
+      "token": "...",
+      "refresh_token": "..."
+    }
+  },
+  "awaiting_variable": "currency",
+  "last_intent": "doviz-kuru-intent"
+}
+```
+
+---
+
+## 🧩 Placeholder Kullanımı
+
+| Amaç          | Yazım                          |
+|---------------|-------------------------------|
+| Parametre     | `{variables.currency}`        |
+| Session verisi| `{session.tckn}`             |
+| Token         | `{auth_tokens.intent.token}` |
+
+---
+
+## ✅ Sonraki Adımlar
+
+- `resolve_placeholders()` fonksiyonu
+- `validate_variable_formats()`
+- `auth_token_handler()` → create + refresh
+- `execute_intent()` tam mantık
+- `log()` yapısı
+
+---
+
+Bu tasarım, modüler ve üretim ortamı için ölçeklenebilir sağlam bir altyapı sunar.

intent_test_runner.py

@@ -1,76 +1,70 @@
-import os
-import requests
-from log import log
-
-BASE_URL = "http://localhost:7860"
-PROJECT_NAME = "project1"
-
-test_results = []
-
-def assert_test(name, actual, expected_substring, explanation=None):
-    if explanation:
-        log(f"🧪 TEST: {name} → {explanation}")
-    actual_str = str(actual)
-    if expected_substring in actual_str:
-        log(f"[TEST] {name:<45} ✅")
-        test_results.append((name, True))
-    else:
-        log(f"[TEST] {name:<45} ❌ — Beklenen: {expected_substring}, Gelen: {actual_str[:100]}...")
-        test_results.append((name, False))
-
-def summarize_tests():
-    total = len(test_results)
-    success = sum(1 for _, ok in test_results if ok)
-    fail = total - success
-    log("🧾 TEST SONUCU ÖZETİ")
-    log(f"🔢 Toplam Test       : {total}")
-    log(f"✅ Başarılı          : {success}")
-    log(f"❌ Başarısız         : {fail}")
-
-def run_all_tests():
-    try:
-        log("🚀 Test süreci başlatıldı.")
-
-        # ✅ Yeni session başlatırken project_name gönderiyoruz
-        response = requests.post(f"{BASE_URL}/start_chat?project_name={PROJECT_NAME}")
-        response.raise_for_status()
-        session_id = response.json().get("session_id")
-        if not session_id:
-            raise Exception("Session ID alınamadı.")
-        
-        headers = {"X-Session-ID": session_id}
-
-        # 1️⃣ LLM fallback testi
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "bilinmeyen bir soru"}, headers=headers)
-        assert_test("LLM fallback", r.json(), "maalesef")
-
-        # 2️⃣ Eksik parametre testi (döviz kuru)
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "döviz kuru nedir"}, headers=headers)
-        assert_test("Eksik parametre — currency", r.json(), "Lütfen currency")
-
-        # 3️⃣ Eksik parametre tamamlanınca tekrar deneme
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "dolar"}, headers=headers)
-        assert_test("Parametre tamamlandı — dolar", r.json(), "dolar kuru şu an")
-
-        # 4️⃣ Geçersiz parametre validasyonu
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yenidolar kuru nedir"}, headers=headers)
-        assert_test("Geçersiz parametre — currency", r.json(), "Geçerli bir döviz")
-
-        # 5️⃣ Konu değişikliği → awaiting reset
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "hava nasıl"}, headers=headers)
-        assert_test("Konu değişikliği sonrası fallback", r.json(), "maalesef")
-
-        # 6️⃣ Yol durumu testi (eksik from_location)
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yol durumu"}, headers=headers)
-        assert_test("Eksik parametre — from_location", r.json(), "Lütfen from_location")
-
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "Ankara"}, headers=headers)
-        assert_test("Eksik parametre — to_location", r.json(), "Lütfen to_location")
-
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "İstanbul"}, headers=headers)
-        assert_test("Parametre tamamlandı — yol durumu", r.json(), "trafik açık")
-
-        summarize_tests()
-
-    except Exception as e:
+import os
+import requests
+from log import log
+
+BASE_URL = "http://localhost:7860"
+MOCK_BASE = os.getenv("MOCK_BASE_URL")  # Örnek: https://abc123.ngrok.io
+
+test_results = []
+
+def assert_test(name, actual, expected_substring, explanation=None):
+    if explanation:
+        log(f"🧪 TEST: {name} → {explanation}")
+    actual_str = str(actual)
+    if expected_substring in actual_str:
+        log(f"[TEST] {name:<45} ✅")
+        test_results.append((name, True))
+    else:
+        log(f"[TEST] {name:<45} ❌ — Beklenen: {expected_substring}, Gelen: {actual_str[:100]}...")
+        test_results.append((name, False))
+
+def summarize_tests():
+    total = len(test_results)
+    success = sum(1 for _, ok in test_results if ok)
+    fail = total - success
+    log("🧾 TEST SONUCU ÖZETİ")
+    log(f"🔢 Toplam Test       : {total}")
+    log(f"✅ Başarılı          : {success}")
+    log(f"❌ Başarısız         : {fail}")
+
+def run_all_tests():
+    try:
+        log("🚀 Test süreci başlatıldı.")
+        response = requests.post(f"{BASE_URL}/start_chat?project_name=project1")
+        session_id = response.json().get("session_id")
+        headers = {"X-Session-ID": session_id}
+
+        # 1. LLM fallback testi (intent bulunamadığında)
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "bilinmeyen bir soru"}, headers=headers)
+        assert_test("LLM fallback", r.json(), "maalesef")
+
+        # 2. Eksik parametre testi (döviz kuru)
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "döviz kuru nedir"}, headers=headers)
+        assert_test("Eksik parametre — currency", r.json(), "Lütfen currency")
+
+        # 3. Eksik parametre tamamlanınca tekrar deneme
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "dolar"}, headers=headers)
+        assert_test("Parametre tamamlandı — dolar", r.json(), "dolar kuru şu an")
+
+        # 4. Geçersiz parametre validasyonu
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yenidolar kuru nedir"}, headers=headers)
+        assert_test("Geçersiz parametre — currency", r.json(), "geçerli bir döviz")
+
+        # 5. Konu değişikliği → awaiting reset
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "hava nasıl"}, headers=headers)
+        assert_test("Konu değişikliği sonrası fallback", r.json(), "maalesef")
+
+        # 6. Yol durumu testi (iki parametre eksik veya biri eksik)
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yol durumu"}, headers=headers)
+        assert_test("Eksik parametre — from_location", r.json(), "Lütfen from_location")
+
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "Ankara"}, headers=headers)
+        assert_test("Eksik parametre — to_location", r.json(), "Lütfen to_location")
+
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "İstanbul"}, headers=headers)
+        assert_test("Parametre tamamlandı — yol durumu", r.json(), "trafik açık")
+
+        summarize_tests()
+
+    except Exception as e:
         log(f"❌ run_all_tests sırasında hata oluştu: {e}")

llm_model.py

@@ -1,83 +1,83 @@
-import torch
-import traceback
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from log import log
-from pydantic import BaseModel
-
-class Message(BaseModel):
-    user_input: str
-
-class LLMModel:
-    def __init__(self):
-        self.model = None
-        self.tokenizer = None
-        self.eos_token_id = None
-
-    def setup(self, s_config, project_config):
-        try:
-            log("🧠 LLMModel setup() başladı")
-            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            log(f"📡 Kullanılan cihaz: {device}")
-
-            model_base = project_config["model_base"]
-
-            if s_config.work_mode == "hfcloud":
-                token = s_config.get_auth_token()
-                log(f"📦 Hugging Face cloud modeli yükleniyor: {model_base}")
-                self.tokenizer = AutoTokenizer.from_pretrained(model_base, token=token, use_fast=False)
-                self.model = AutoModelForCausalLM.from_pretrained(model_base, token=token, torch_dtype=torch.float32).to(device)
-            elif s_config.work_mode == "cloud":
-                log(f"📦 Diğer cloud ortamından model indiriliyor: {model_base}")
-                self.tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
-                self.model = AutoModelForCausalLM.from_pretrained(model_base, torch_dtype=torch.float32).to(device)
-
-            elif s_config.work_mode == "on-prem":
-                log(f"📦 On-prem model path: {model_base}")
-                self.tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
-                self.model = AutoModelForCausalLM.from_pretrained(model_base, torch_dtype=torch.float32).to(device)
-
-            else:
-                raise Exception(f"Bilinmeyen work_mode: {s_config.work_mode}")
-
-            self.tokenizer.pad_token = self.tokenizer.pad_token or self.tokenizer.eos_token
-            self.model.config.pad_token_id = self.tokenizer.pad_token_id
-            self.eos_token_id = self.tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
-            self.model.eval()
-
-            log("✅ LLMModel setup() başarıyla tamamlandı.")
-        except Exception as e:
-            log(f"❌ LLMModel setup() hatası: {e}")
-            traceback.print_exc()
-
-    async def generate_response(self, text, project_config):
-        messages = [{"role": "user", "content": text}]
-        encodeds = self.tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
-        input_ids = encodeds.to(self.model.device)
-        attention_mask = (input_ids != self.tokenizer.pad_token_id).long()
-
-        with torch.no_grad():
-            output = self.model.generate(
-                input_ids=input_ids,
-                attention_mask=attention_mask,
-                max_new_tokens=128,
-                do_sample=project_config["use_sampling"],
-                eos_token_id=self.eos_token_id,
-                pad_token_id=self.tokenizer.pad_token_id,
-                return_dict_in_generate=True,
-                output_scores=True
-            )
-
-        if not project_config["use_sampling"]:
-            scores = torch.stack(output.scores, dim=1)
-            probs = torch.nn.functional.softmax(scores[0], dim=-1)
-            top_conf = probs.max().item()
-        else:
-            top_conf = None
-
-        decoded = self.tokenizer.decode(output.sequences[0], skip_special_tokens=True).strip()
-        for tag in ["assistant", "<|im_start|>assistant"]:
-            start = decoded.find(tag)
-            if start != -1:
-                decoded = decoded[start + len(tag):].strip()
-                break
-        return decoded, top_conf
+import torch
+import traceback
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from log import log
+from pydantic import BaseModel
+
+class Message(BaseModel):
+    user_input: str
+
+class LLMModel:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.eos_token_id = None
+
+    def setup(self, s_config, project_config):
+        try:
+            log("🧠 LLMModel setup() başladı")
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            log(f"📡 Kullanılan cihaz: {device}")
+
+            model_base = project_config["model_base"]
+
+            if s_config.work_mode == "hfcloud":
+                token = s_config.get_auth_token()
+                log(f"📦 Hugging Face cloud modeli yükleniyor: {model_base}")
+                self.tokenizer = AutoTokenizer.from_pretrained(model_base, token=token, use_fast=False)
+                self.model = AutoModelForCausalLM.from_pretrained(model_base, token=token, torch_dtype=torch.float32).to(device)
+            elif s_config.work_mode == "cloud":
+                log(f"📦 Diğer cloud ortamından model indiriliyor: {model_base}")
+                self.tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+                self.model = AutoModelForCausalLM.from_pretrained(model_base, torch_dtype=torch.float32).to(device)
+
+            elif s_config.work_mode == "on-prem":
+                log(f"📦 On-prem model path: {model_base}")
+                self.tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+                self.model = AutoModelForCausalLM.from_pretrained(model_base, torch_dtype=torch.float32).to(device)
+
+            else:
+                raise Exception(f"Bilinmeyen work_mode: {s_config.work_mode}")
+
+            self.tokenizer.pad_token = self.tokenizer.pad_token or self.tokenizer.eos_token
+            self.model.config.pad_token_id = self.tokenizer.pad_token_id
+            self.eos_token_id = self.tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
+            self.model.eval()
+
+            log("✅ LLMModel setup() başarıyla tamamlandı.")
+        except Exception as e:
+            log(f"❌ LLMModel setup() hatası: {e}")
+            traceback.print_exc()
+
+    async def generate_response(self, text, project_config):
+        messages = [{"role": "user", "content": text}]
+        encodeds = self.tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
+        input_ids = encodeds.to(self.model.device)
+        attention_mask = (input_ids != self.tokenizer.pad_token_id).long()
+
+        with torch.no_grad():
+            output = self.model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=128,
+                do_sample=project_config["use_sampling"],
+                eos_token_id=self.eos_token_id,
+                pad_token_id=self.tokenizer.pad_token_id,
+                return_dict_in_generate=True,
+                output_scores=True
+            )
+
+        if not project_config["use_sampling"]:
+            scores = torch.stack(output.scores, dim=1)
+            probs = torch.nn.functional.softmax(scores[0], dim=-1)
+            top_conf = probs.max().item()
+        else:
+            top_conf = None
+
+        decoded = self.tokenizer.decode(output.sequences[0], skip_special_tokens=True).strip()
+        for tag in ["assistant", "<|im_start|>assistant"]:
+            start = decoded.find(tag)
+            if start != -1:
+                decoded = decoded[start + len(tag):].strip()
+                break
+        return decoded, top_conf