Upload 22 files

.dockerignore

@@ -1,12 +1,12 @@
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.git/
-.vscode/
-*.log
-*.sqlite3
-*.db
-.DS_Store
-.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.git/
+.vscode/
+*.log
+*.sqlite3
+*.db
+.DS_Store
+.env
 *.zip

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,22 +1,22 @@
-FROM python:3.10-slim
-
-# === Hugging Face Spaces özel dizinleri
-RUN mkdir -p /data/chunks /data/projects /data/tokenized_chunks /data/zip_temp /data/output /app/.cache /app/.torch_cache && chmod -R 777 /data /app
-
-# === Ortam değişkenleri
-ENV HF_HOME=/app/.cache \
-    HF_DATASETS_CACHE=/app/.cache \
-    HF_HUB_CACHE=/app/.cache \
-    TORCH_HOME=/app/.torch_cache
-
-# PyTorch kernel cache için klasör
-ENV TORCH_HOME=/app/.torch_cache
-    
-# ✅ Tüm proje klasörünü kopyala
-COPY . .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# ✅ Çalıştırılacak komut
+FROM python:3.10-slim
+
+# === Hugging Face Spaces özel dizinleri
+RUN mkdir -p /data/chunks /data/projects /data/tokenized_chunks /data/zip_temp /data/output /app/.cache /app/.torch_cache && chmod -R 777 /data /app
+
+# === Ortam değişkenleri
+ENV HF_HOME=/app/.cache \
+    HF_DATASETS_CACHE=/app/.cache \
+    HF_HUB_CACHE=/app/.cache \
+    TORCH_HOME=/app/.torch_cache
+
+# PyTorch kernel cache için klasör
+ENV TORCH_HOME=/app/.torch_cache
+    
+# ✅ Tüm proje klasörünü kopyala
+COPY . .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ✅ Çalıştırılacak komut
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,44 +1,44 @@
-from fastapi import FastAPI
-from controllers import chat_controller, test_controller, admin_controller, health_controller
-from core import service_config, session_store, llm_models
-from llm_model import LLMModel
-from log import log
-import os
-import warnings
-
-warnings.simplefilter(action='ignore', category=FutureWarning)
-
-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)
-
-BASE_PROJECTS_DIR = "/data/projects"
-
-def load_project(project_name, config, project_path):
-    llm_config = config.get_project_llm_config(project_name)
-    model_instance = LLMModel()
-    model_instance.setup(config, llm_config, project_path)
-
-    # ❌ Intent modeli artık kullanılmıyor → bu blok kaldırıldı
-
-    return model_instance
-
-log("🌐 Servis başlatılıyor...")
-service_config.load(is_reload=False)
-
-for project_name in service_config.projects:
-    project_path = os.path.join(BASE_PROJECTS_DIR, project_name)
-    os.makedirs(project_path, exist_ok=True)
-    os.makedirs(os.path.join(project_path, "llm", "base_model"), exist_ok=True)
-    os.makedirs(os.path.join(project_path, "llm", "fine_tune"), exist_ok=True)
-
-    model_instance = load_project(project_name, service_config, project_path)
-    llm_models[project_name] = model_instance
-    log(f"✅ '{project_name}' için tüm modeller yüklenip belleğe alındı.")
-
-if __name__ == "__main__":
-    import uvicorn
-    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 core import service_config, session_store, llm_models
+from llm_model import LLMModel
+from log import log
+import os
+import warnings
+
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
+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)
+
+BASE_PROJECTS_DIR = "/data/projects"
+
+def load_project(project_name, config, project_path):
+    llm_config = config.get_project_llm_config(project_name)
+    model_instance = LLMModel()
+    model_instance.setup(config, llm_config, project_path)
+
+    # ❌ Intent modeli artık kullanılmıyor → bu blok kaldırıldı
+
+    return model_instance
+
+log("🌐 Servis başlatılıyor...")
+service_config.load(is_reload=False)
+
+for project_name in service_config.projects:
+    project_path = os.path.join(BASE_PROJECTS_DIR, project_name)
+    os.makedirs(project_path, exist_ok=True)
+    os.makedirs(os.path.join(project_path, "llm", "base_model"), exist_ok=True)
+    os.makedirs(os.path.join(project_path, "llm", "fine_tune"), exist_ok=True)
+
+    model_instance = load_project(project_name, service_config, project_path)
+    llm_models[project_name] = model_instance
+    log(f"✅ '{project_name}' için tüm modeller yüklenip belleğe alındı.")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

chat_handler.py

@@ -1,85 +1,85 @@
-from fastapi import Request
-from fastapi.responses import JSONResponse
-import traceback
-import random
-from llm_model import Message, LLMModel
-from intent_api import execute_intent
-from intent_utils import validate_variable_formats
-from parse_llm_blocks import parse_llm_blocks
-from log import log
-
-async def handle_chat(msg: Message, request: Request, app, service_config, session, llm_model: LLMModel):
-    try:
-        user_input = msg.user_input.strip()
-        log(f"💬 Kullanıcı input'u: '{user_input}'")
-
-        project_name = session.project_name
-        project_config = service_config.get_project_llm_config(project_name)
-        system_prompt = service_config.system_prompt  # 👉 system_prompt buradan alınıyor
-
-        # Chat history'ye user mesajını ekle
-        session.chat_history.append({"role": "user", "content": user_input})
-
-        # === LLM çağrısı
-        llm_response = await llm_model.generate_response_with_messages(session.chat_history, project_config, system_prompt)
-        log(f"🤖 LLM cevabı: {llm_response}")
-
-        # === LLM cevabını parse et
-        parsed = parse_llm_blocks(llm_response)
-        intent = parsed["intent"]
-        params = parsed["params"]
-        missing = parsed["missing"]
-        action_json = parsed["action_json"]
-
-        # Chat history'ye assistant cevabını ekle
-        session.chat_history.append({"role": "assistant", "content": llm_response})
-
-        # === INTENT yok → havadan sudan konuşma
-        if intent == "NONE":
-            session.awaiting_variable = None
-            session.last_intent = None
-            session.variables.clear()
-            return {"response": llm_response}
-
-        # === INTENT varsa
-        session.last_intent = intent
-        session.variables.update(params)
-
-        # Eksik parametre varsa
-        if missing:
-            session.awaiting_variable = missing[0]
-            return {"response": f"Lütfen {', '.join(missing)} bilgisini belirtir misiniz?"}
-
-        # === API çağrısı yap
-        intent_definitions = {i["name"]: i for i in service_config.get_project_intents(project_name)}
-        data_formats = service_config.data_formats
-
-        # Parametreleri validasyonla kontrol et (backend güvenlik katmanı)
-        variable_format_map = intent_definitions.get(intent, {}).get("variable_formats", {})
-        is_valid, validation_errors = validate_variable_formats(session.variables, variable_format_map, data_formats)
-
-        if not is_valid:
-            session.awaiting_variable = list(validation_errors.keys())[0]
-            return {"response": list(validation_errors.values())[0]}
-
-        log("🚀 execute_intent() çağrılıyor...")
-        result = execute_intent(
-            intent,
-            user_input,
-            session.__dict__,
-            intent_definitions,
-            data_formats,
-            project_name,
-            service_config
-        )
-
-        if "reply" in result:
-            return {"reply": result["reply"]}
-        elif "errors" in result:
-            return {"response": list(result["errors"].values())[0]}
-        else:
-            return {"response": random.choice(project_config["fallback_answers"])}
-
-    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
+import random
+from llm_model import Message, LLMModel
+from intent_api import execute_intent
+from intent_utils import validate_variable_formats
+from parse_llm_blocks import parse_llm_blocks
+from log import log
+
+async def handle_chat(msg: Message, request: Request, app, service_config, session, llm_model: LLMModel):
+    try:
+        user_input = msg.user_input.strip()
+        log(f"💬 Kullanıcı input'u: '{user_input}'")
+
+        project_name = session.project_name
+        project_config = service_config.get_project_llm_config(project_name)
+        system_prompt = service_config.system_prompt  # 👉 system_prompt buradan alınıyor
+
+        # Chat history'ye user mesajını ekle
+        session.chat_history.append({"role": "user", "content": user_input})
+
+        # === LLM çağrısı
+        llm_response = await llm_model.generate_response_with_messages(session.chat_history, project_config, system_prompt)
+        log(f"🤖 LLM cevabı: {llm_response}")
+
+        # === LLM cevabını parse et
+        parsed = parse_llm_blocks(llm_response)
+        intent = parsed["intent"]
+        params = parsed["params"]
+        missing = parsed["missing"]
+        action_json = parsed["action_json"]
+
+        # Chat history'ye assistant cevabını ekle
+        session.chat_history.append({"role": "assistant", "content": llm_response})
+
+        # === INTENT yok → havadan sudan konuşma
+        if intent == "NONE":
+            session.awaiting_variable = None
+            session.last_intent = None
+            session.variables.clear()
+            return {"response": llm_response}
+
+        # === INTENT varsa
+        session.last_intent = intent
+        session.variables.update(params)
+
+        # Eksik parametre varsa
+        if missing:
+            session.awaiting_variable = missing[0]
+            return {"response": f"Lütfen {', '.join(missing)} bilgisini belirtir misiniz?"}
+
+        # === API çağrısı yap
+        intent_definitions = {i["name"]: i for i in service_config.get_project_intents(project_name)}
+        data_formats = service_config.data_formats
+
+        # Parametreleri validasyonla kontrol et (backend güvenlik katmanı)
+        variable_format_map = intent_definitions.get(intent, {}).get("variable_formats", {})
+        is_valid, validation_errors = validate_variable_formats(session.variables, variable_format_map, data_formats)
+
+        if not is_valid:
+            session.awaiting_variable = list(validation_errors.keys())[0]
+            return {"response": list(validation_errors.values())[0]}
+
+        log("🚀 execute_intent() çağrılıyor...")
+        result = execute_intent(
+            intent,
+            user_input,
+            session.__dict__,
+            intent_definitions,
+            data_formats,
+            project_name,
+            service_config
+        )
+
+        if "reply" in result:
+            return {"reply": result["reply"]}
+        elif "errors" in result:
+            return {"response": list(result["errors"].values())[0]}
+        else:
+            return {"response": random.choice(project_config["fallback_answers"])}
+
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(content={"error": str(e)}, status_code=500)

controllers/admin_controller.py

@@ -1,81 +1,113 @@
-from fastapi import APIRouter, Request
-from core import service_config, llm_models
-from llm_model import LLMModel
-from log import log
-import os, shutil, threading
-
-router = APIRouter()
-
-@router.post("/reload_config")
-async def reload_config(request: Request):
-    body = await request.json()
-    project_name = body.get("project_name")
-    new_config_data = body.get("service_config")
-
-    if not project_name or not new_config_data:
-        return {"error": "project_name ve service_config gereklidir."}
-
-    def background_reload():
-        try:
-            current_project = service_config.projects.get(project_name)
-            incoming_project = new_config_data.get("projects", {}).get(project_name)
-
-            if not incoming_project:
-                log(f"❌ '{project_name}' yeni config içinde bulunamadı, işlem durduruldu.")
-                return
-
-            project_path = f"/data/projects/{project_name}"
-            temp_path = f"/data/projects/{project_name}_temp"
-
-            if os.path.exists(temp_path):
-                shutil.rmtree(temp_path)
-            os.makedirs(temp_path, exist_ok=True)
-
-            llm_config = incoming_project["llm"]
-
-            temp_instance = LLMModel()
-
-            if current_project is None:
-                log(f"🆕 Yeni proje '{project_name}' tespit edildi, yükleme başlatılıyor...")
-                temp_instance.setup(service_config, llm_config, temp_path)
-
-                if os.path.exists(project_path):
-                    shutil.rmtree(project_path)
-                shutil.copytree(temp_path, project_path)
-
-                llm_models[project_name] = temp_instance
-                service_config.projects[project_name] = incoming_project
-
-                log(f"✅ Yeni proje '{project_name}' başarıyla yüklendi ve belleğe alındı.")
-                return
-
-            if current_project == incoming_project:
-                log(f"ℹ️ '{project_name}' için değişiklik bulunamadı, işlem atlandı.")
-                return
-
-            log(f"🔄 '{project_name}' güncellemesi tespit edildi, güncelleme başlatılıyor...")
-
-            if current_project["llm"]["model_base"] != llm_config["model_base"]:
-                temp_instance.setup(service_config, llm_config, temp_path)
-            else:
-                temp_instance.model = llm_models[project_name].model
-                temp_instance.tokenizer = llm_models[project_name].tokenizer
-
-            if os.path.exists(project_path):
-                shutil.rmtree(project_path)
-            shutil.copytree(temp_path, project_path)
-
-            llm_models[project_name] = temp_instance
-            service_config.projects[project_name] = incoming_project
-
-            log(f"✅ '{project_name}' güncellemesi tamamlandı ve belleğe alındı.")
-
-        except Exception as e:
-            log(f"❌ reload_config background hatası: {e}")
-
-    threading.Thread(target=background_reload, daemon=True).start()
-
-    return {
-        "status": "accepted",
-        "message": f"'{project_name}' için güncelleme arka planda başlatıldı. İşlem loglardan takip edilebilir."
-    }
+from fastapi import APIRouter, Request
+from core import service_config, llm_models
+from llm_model import LLMModel
+from intent_utils import background_training
+from log import log
+import json, os, shutil, threading
+
+router = APIRouter()
+
+@router.post("/reload_config")
+async def reload_config(request: Request):
+    body = await request.json()
+    project_name = body.get("project_name")
+    new_config_data = body.get("service_config")
+
+    if not project_name or not new_config_data:
+        return {"error": "project_name ve service_config gereklidir."}
+
+    def background_reload():
+        try:
+            current_project = service_config.projects.get(project_name)
+            incoming_project = new_config_data.get("projects", {}).get(project_name)
+
+            if not incoming_project:
+                log(f"❌ '{project_name}' yeni config içinde bulunamadı, işlem durduruldu.")
+                return
+
+            project_path = f"/data/projects/{project_name}"
+            temp_path = f"/data/projects/{project_name}_temp"
+
+            if os.path.exists(temp_path):
+                shutil.rmtree(temp_path)
+            os.makedirs(temp_path, exist_ok=True)
+
+            llm_config = incoming_project["llm"]
+            intents = incoming_project["intents"]
+
+            temp_instance = LLMModel()
+
+            # 🆕 Yeni proje ekleniyor
+            if current_project is None:
+                log(f"🆕 Yeni proje '{project_name}' tespit edildi, yükleme başlatılıyor...")
+
+                temp_instance.setup(service_config, llm_config, temp_path)
+                intent_model_path = os.path.join(temp_path, "intent", "trained_model")
+                background_training(
+                    project_name,
+                    intents,
+                    llm_config["intent_model_id"],
+                    intent_model_path,
+                    llm_config["train_confidence_treshold"]
+                )
+                temp_instance.load_intent_model(intent_model_path)
+
+                if os.path.exists(project_path):
+                    shutil.rmtree(project_path)
+                shutil.copytree(temp_path, project_path)
+
+                llm_models[project_name] = temp_instance
+                service_config.projects[project_name] = incoming_project
+
+                log(f"✅ Yeni proje '{project_name}' başarıyla yüklendi ve belleğe alındı.")
+                return
+
+            # 🔄 Var olan projede değişiklik varsa güncelle
+            if current_project == incoming_project:
+                log(f"ℹ️ '{project_name}' için değişiklik bulunamadı, işlem atlandı.")
+                return
+
+            log(f"🔄 '{project_name}' güncellemesi tespit edildi, güncelleme başlatılıyor...")
+
+            # Ana model değiştiyse yükle
+            if current_project["llm"]["model_base"] != llm_config["model_base"]:
+                temp_instance.setup(service_config, llm_config, temp_path)
+            else:
+                temp_instance.model = llm_models[project_name].model
+                temp_instance.tokenizer = llm_models[project_name].tokenizer
+
+            # Intent değiştiyse yeniden eğit
+            if current_project["intents"] != intents:
+                intent_model_path = os.path.join(temp_path, "intent", "trained_model")
+                background_training(
+                    project_name,
+                    intents,
+                    llm_config["intent_model_id"],
+                    intent_model_path,
+                    llm_config["train_confidence_treshold"]
+                )
+                temp_instance.load_intent_model(intent_model_path)
+            else:
+                temp_instance.intent_model = llm_models[project_name].intent_model
+                temp_instance.intent_tokenizer = llm_models[project_name].intent_tokenizer
+                temp_instance.intent_label2id = llm_models[project_name].intent_label2id
+
+            if os.path.exists(project_path):
+                shutil.rmtree(project_path)
+            shutil.copytree(temp_path, project_path)
+
+            llm_models[project_name] = temp_instance
+            service_config.projects[project_name] = incoming_project
+
+            log(f"✅ '{project_name}' güncellemesi tamamlandı ve belleğe alındı.")
+
+        except Exception as e:
+            log(f"❌ reload_config background hatası: {e}")
+
+    # Arka planda başlat
+    threading.Thread(target=background_reload, daemon=True).start()
+
+    return {
+        "status": "accepted",
+        "message": f"'{project_name}' için güncelleme arka planda başlatıldı. İşlem loglardan takip edilebilir."
+    }

controllers/chat_controller.py

@@ -1,33 +1,33 @@
-from fastapi import APIRouter, Request
-from llm_model import Message
-from chat_handler import handle_chat
-from core import service_config, session_store, llm_models
-import uuid
-
-router = APIRouter()
-
-@router.post("/start_chat")
-def start_chat(request: Request):
-    project_name = request.query_params.get("project_name")
-    if not project_name:
-        return {"error": "project_name parametresi gereklidir."}
-
-    session = session_store.create_session(project_name)
-    return {"session_id": session.session_id}
-
-@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)
+from fastapi import APIRouter, Request
+from llm_model import Message
+from chat_handler import handle_chat
+from core import service_config, session_store, llm_models
+import uuid
+
+router = APIRouter()
+
+@router.post("/start_chat")
+def start_chat(request: Request):
+    project_name = request.query_params.get("project_name")
+    if not project_name:
+        return {"error": "project_name parametresi gereklidir."}
+
+    session = session_store.create_session(project_name)
+    return {"session_id": session.session_id}
+
+@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

@@ -1,13 +1,13 @@
-from fastapi import APIRouter
-from core import llm_models
-
-router = APIRouter()
-
-@router.get("/")
-def health():
-    return {"status": "ok"}
-
-@router.get("/health/intents")
-def health_intents():
-    loaded_projects = [proj for proj, model in llm_models.items() if model.intent_model is not None]
-    return {"status": "ok", "loaded_projects": loaded_projects}
+from fastapi import APIRouter
+from core import llm_models
+
+router = APIRouter()
+
+@router.get("/")
+def health():
+    return {"status": "ok"}
+
+@router.get("/health/intents")
+def health_intents():
+    loaded_projects = [proj for proj, model in llm_models.items() if model.intent_model is not None]
+    return {"status": "ok", "loaded_projects": loaded_projects}

controllers/test_controller.py

@@ -1,12 +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ı."}
+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ı."}

core.py

@@ -1,6 +1,7 @@
-from service_config import ServiceConfig
-from session import SessionStore
-
-service_config = ServiceConfig()
-session_store = SessionStore()
-llm_models = {}
+from service_config import ServiceConfig
+from session import SessionStore
+
+service_config = ServiceConfig()
+session_store = SessionStore()
+llm_models = {}
+INTENT_MODELS = {}

intent_api.py

@@ -1,197 +1,198 @@
-import intent_utils as intent
-import requests
-import traceback
-from log import log
-
-def auth_token_handler(api_name, auth_config, session):
-    try:
-        token_info = session.get("auth_tokens", {}).get(api_name)
-        if token_info and "token" in token_info:
-            return token_info["token"], session
-
-        auth_endpoint = auth_config.get("auth_endpoint")
-        auth_body = auth_config.get("auth_body", {})
-        token_path = auth_config.get("auth_token_path")
-
-        if not auth_endpoint or not token_path:
-            raise Exception("auth_endpoint veya token_path tanımsız")
-
-        resolved_body = {
-            k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in auth_body.items()
-        }
-
-        response = requests.post(auth_endpoint, json=resolved_body, timeout=5)
-        response.raise_for_status()
-        json_resp = response.json()
-
-        token_parts = token_path.split(".")
-        token = json_resp
-        for part in token_parts:
-            token = token.get(part)
-            if token is None:
-                raise Exception(f"Token path çözülemedi: {token_path}")
-
-        refresh_token = json_resp.get("refresh_token")
-        session.setdefault("auth_tokens", {})[api_name] = {
-            "token": token,
-            "refresh_token": refresh_token
-        }
-
-        return token, session
-
-    except Exception as e:
-        log(f"❌ Auth token alınamadı: {e}")
-        traceback.print_exc()
-        raise e
-
-def refresh_auth_token(api_name, auth_config, session):
-    try:
-        refresh_endpoint = auth_config.get("auth_refresh_endpoint")
-        refresh_body = auth_config.get("refresh_body", {})
-        token_path = auth_config.get("auth_token_path")
-
-        if not refresh_endpoint or not token_path:
-            raise Exception("Refresh yapılandırması eksik")
-
-        refresh_token = session.get("auth_tokens", {}).get(api_name, {}).get("refresh_token")
-        if not refresh_token:
-            raise Exception("Mevcut refresh token bulunamadı")
-
-        resolved_body = {
-            k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in refresh_body.items()
-        }
-
-        response = requests.post(refresh_endpoint, json=resolved_body, timeout=5)
-        response.raise_for_status()
-        json_resp = response.json()
-
-        token_parts = token_path.split(".")
-        token = json_resp
-        for part in token_parts:
-            token = token.get(part)
-            if token is None:
-                raise Exception(f"Token path çözülemedi: {token_path}")
-
-        new_refresh_token = json_resp.get("refresh_token", refresh_token)
-
-        session.setdefault("auth_tokens", {})[api_name] = {
-            "token": token,
-            "refresh_token": new_refresh_token
-        }
-
-        log(f"🔁 Token başarıyla yenilendi: {api_name}")
-        return token, session
-
-    except Exception as e:
-        log(f"❌ Token yenileme başarısız: {e}")
-        traceback.print_exc()
-        raise e
-
-def execute_intent(intent_name, user_input, session_dict, intent_definitions, data_formats, project_name, service_config):
-    try:
-        session = session_dict
-        intent_def = intent_definitions.get(intent_name)
-
-        if not intent_def:
-            raise Exception(f"'{intent_name}' için intent tanımı bulunamadı.")
-
-        action_api_name = intent_def.get("action")
-
-        if not action_api_name:
-            raise Exception(f"Intent '{intent_name}' için action tanımı eksik.")
-
-        api_def = service_config.get_api_config(action_api_name)
-        if not api_def:
-            raise Exception(f"API '{action_api_name}' tanımı bulunamadı.")
-
-        variables = session.get("variables", {})
-        log(f"🚀 execute_intent('{intent_name}')")
-        log(f"🔍 Kullanılan parametreler: {variables}")
-
-        variable_format_map = intent_def.get("variable_formats", {})
-        is_valid, validation_errors = intent.validate_variable_formats(variables, variable_format_map, data_formats)
-        if not is_valid:
-            log(f"⚠️ Validasyon hatası: {validation_errors}")
-            return {
-                "errors": validation_errors,
-                "awaiting_variable": list(validation_errors.keys())[0],
-                "session": session
-            }
-
-        headers = api_def.get("headers", [])
-        body = api_def.get("body", {})
-        method = api_def.get("method", "POST")
-        url = api_def["url"]
-        timeout = api_def.get("timeout", 5)
-        retry_count = api_def.get("retry_count", 0)
-        auth_config = api_def.get("auth")
-        tls = api_def.get("tls", {})
-        verify = tls.get("verify", True)
-        verify_path = tls.get("ca_bundle") if verify and tls.get("ca_bundle") else verify
-
-        if auth_config:
-            token, session = auth_token_handler(action_api_name, auth_config, session)
-        else:
-            token = None
-
-        resolved_headers = {
-            h["key"]: intent.resolve_placeholders(h["value"], session, variables)
-            for h in headers
-        }
-        resolved_body = {
-            k: intent.resolve_placeholders(str(v), session, variables)
-            for k, v in body.items()
-        }
-
-        for attempt in range(retry_count + 1):
-            try:
-                response = requests.request(
-                    method=method,
-                    url=url,
-                    headers=resolved_headers,
-                    json=resolved_body,
-                    timeout=timeout,
-                    verify=verify_path
-                )
-                if response.status_code == 401 and auth_config and attempt < retry_count:
-                    log("🔁 Token expired. Yenileniyor...")
-                    token, session = refresh_auth_token(action_api_name, auth_config, session)
-                    continue
-                response.raise_for_status()
-                break
-            except requests.HTTPError as e:
-                if response.status_code != 401 or attempt == retry_count:
-                    raise e
-
-        log("✅ API çağrısı başarılı")
-        json_resp = response.json()
-
-        field = api_def.get("response_parser", {}).get("field")
-        value = json_resp.get(field) if field else json_resp
-        template = api_def.get("reply_template", str(value))
-
-        merged_variables = {**session.get("variables", {}), **variables}
-        if field:
-            merged_variables[field] = str(value)
-
-        log(f"🧩 merged_variables: {merged_variables}")
-        log(f"🧩 reply_template: {template}")
-
-        reply = intent.resolve_placeholders(template, session, merged_variables)
-        log(f"🛠 Final reply: {reply}")
-
-        session.setdefault("variables", {}).update(merged_variables)
-        session["last_intent"] = intent_name
-
-        return {
-            "reply": reply,
-            "session": session
-        }
-
-    except Exception as e:
-        log(f"❌ execute_intent() hatası: {e}")
-        traceback.print_exc()
-        return {
-            "error": str(e),
-            "session": session
-        }
+import intent_utils as intent
+import requests
+import traceback
+from log import log
+from core import llm_models
+
+def auth_token_handler(api_name, auth_config, session):
+    try:
+        token_info = session.get("auth_tokens", {}).get(api_name)
+        if token_info and "token" in token_info:
+            return token_info["token"], session
+
+        auth_endpoint = auth_config.get("auth_endpoint")
+        auth_body = auth_config.get("auth_body", {})
+        token_path = auth_config.get("auth_token_path")
+
+        if not auth_endpoint or not token_path:
+            raise Exception("auth_endpoint veya token_path tanımsız")
+
+        resolved_body = {
+            k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in auth_body.items()
+        }
+
+        response = requests.post(auth_endpoint, json=resolved_body, timeout=5)
+        response.raise_for_status()
+        json_resp = response.json()
+
+        token_parts = token_path.split(".")
+        token = json_resp
+        for part in token_parts:
+            token = token.get(part)
+            if token is None:
+                raise Exception(f"Token path çözülemedi: {token_path}")
+
+        refresh_token = json_resp.get("refresh_token")
+        session.setdefault("auth_tokens", {})[api_name] = {
+            "token": token,
+            "refresh_token": refresh_token
+        }
+
+        return token, session
+
+    except Exception as e:
+        log(f"❌ Auth token alınamadı: {e}")
+        traceback.print_exc()
+        raise e
+
+def refresh_auth_token(api_name, auth_config, session):
+    try:
+        refresh_endpoint = auth_config.get("auth_refresh_endpoint")
+        refresh_body = auth_config.get("refresh_body", {})
+        token_path = auth_config.get("auth_token_path")
+
+        if not refresh_endpoint or not token_path:
+            raise Exception("Refresh yapılandırması eksik")
+
+        refresh_token = session.get("auth_tokens", {}).get(api_name, {}).get("refresh_token")
+        if not refresh_token:
+            raise Exception("Mevcut refresh token bulunamadı")
+
+        resolved_body = {
+            k: intent.resolve_placeholders(str(v), session, session.get("variables", {})) for k, v in refresh_body.items()
+        }
+
+        response = requests.post(refresh_endpoint, json=resolved_body, timeout=5)
+        response.raise_for_status()
+        json_resp = response.json()
+
+        token_parts = token_path.split(".")
+        token = json_resp
+        for part in token_parts:
+            token = token.get(part)
+            if token is None:
+                raise Exception(f"Token path çözülemedi: {token_path}")
+
+        new_refresh_token = json_resp.get("refresh_token", refresh_token)
+
+        session.setdefault("auth_tokens", {})[api_name] = {
+            "token": token,
+            "refresh_token": new_refresh_token
+        }
+
+        log(f"🔁 Token başarıyla yenilendi: {api_name}")
+        return token, session
+
+    except Exception as e:
+        log(f"❌ Token yenileme başarısız: {e}")
+        traceback.print_exc()
+        raise e
+
+def execute_intent(intent_name, user_input, session_dict, intent_definitions, data_formats, project_name, service_config):
+    try:
+        session = session_dict
+        intent_def = intent_definitions[intent_name]
+        action_api_name = intent_def.get("action")
+
+        if not action_api_name:
+            raise Exception(f"Intent '{intent_name}' için action tanımı eksik.")
+
+        api_def = service_config.get_api_config(action_api_name)
+        if not api_def:
+            raise Exception(f"API '{action_api_name}' tanımı bulunamadı.")
+
+        variables_raw = intent.extract_parameters(intent_def.get("variables", []), user_input)
+        variables = {item["key"]: item["value"] for item in variables_raw}
+
+        log(f"🚀 execute_intent('{intent_name}')")
+        log(f"🔍 Çıkarılan parametreler: {variables}")
+
+        variable_format_map = intent_def.get("variable_formats", {})
+        is_valid, validation_errors = intent.validate_variable_formats(variables, variable_format_map, data_formats)
+        if not is_valid:
+            log(f"⚠️ Validasyon hatası: {validation_errors}")
+            return {
+                "errors": validation_errors,
+                "awaiting_variable": list(validation_errors.keys())[0],
+                "session": session
+            }
+
+        headers = api_def.get("headers", [])
+        body = api_def.get("body", {})
+        method = api_def.get("method", "POST")
+        url = api_def["url"]
+        timeout = api_def.get("timeout", 5)
+        retry_count = api_def.get("retry_count", 0)
+        auth_config = api_def.get("auth")
+        tls = api_def.get("tls", {})
+        verify = tls.get("verify", True)
+        verify_path = tls.get("ca_bundle") if verify and tls.get("ca_bundle") else verify
+
+        # ✅ Düzeltilmiş auth çağrısı
+        if auth_config:
+            token, session = auth_token_handler(action_api_name, auth_config, session)
+        else:
+            token = None
+
+        resolved_headers = {
+            h["key"]: intent.resolve_placeholders(h["value"], session, variables)
+            for h in headers
+        }
+        resolved_body = {
+            k: intent.resolve_placeholders(str(v), session, variables)
+            for k, v in body.items()
+        }
+
+        for attempt in range(retry_count + 1):
+            try:
+                response = requests.request(
+                    method=method,
+                    url=url,
+                    headers=resolved_headers,
+                    json=resolved_body,
+                    timeout=timeout,
+                    verify=verify_path
+                )
+                if response.status_code == 401 and auth_config and attempt < retry_count:
+                    log("🔁 Token expired. Yenileniyor...")
+                    token, session = refresh_auth_token(action_api_name, auth_config, session)
+                    continue
+                response.raise_for_status()
+                break
+            except requests.HTTPError as e:
+                if response.status_code != 401 or attempt == retry_count:
+                    raise e
+
+        log("✅ API çağrısı başarılı")
+        json_resp = response.json()
+
+        field = api_def.get("response_parser", {}).get("field")
+        value = json_resp.get(field) if field else json_resp
+        template = api_def.get("reply_template", str(value))
+
+        merged_variables = {**session.get("variables", {}), **variables}
+        if field:
+            merged_variables[field] = str(value)
+
+        log(f"🧩 merged_variables: {merged_variables}")
+        log(f"🧩 reply_template: {template}")
+
+        reply = intent.resolve_placeholders(template, session, merged_variables)
+
+        log(f"🛠 Final reply: {reply}")
+
+        session.setdefault("variables", {}).update(merged_variables)
+        session["last_intent"] = intent_name
+
+        return {
+            "reply": reply,
+            "session": session
+        }
+
+    except Exception as e:
+        log(f"❌ execute_intent() hatası: {e}")
+        traceback.print_exc()
+        return {
+            "error": str(e),
+            "session": session
+        }

intent_test_runner.py

@@ -1,85 +1,85 @@
-import os
-import json
-import requests
-from log import log
-
-BASE_URL = os.environ.get("BASE_URL", "http://localhost:7860")
-SERVICE_CONFIG_PATH = os.environ.get("SERVICE_CONFIG_PATH", "service_config.json")
-
-with open(SERVICE_CONFIG_PATH, "r", encoding="utf-8") as f:
-    service_config = json.load(f)
-
-fallback_answers = service_config["projects"]["project1"]["llm"]["fallback_answers"]
-currency_options = service_config["config"]["data_formats"]["currency_format"]["valid_options"]
-city_options = service_config["config"]["data_formats"]["city_format"]["valid_options"]
-
-test_results = []
-
-def assert_test(name, actual, expected_substring, explanation=None):
-    if explanation:
-        log(f"🧪 TEST: {name} → {explanation}")
-    actual_str = str(actual)
-    passed = expected_substring in actual_str
-    if passed:
-        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")
-        if response.status_code != 200:
-            raise Exception(f"Start chat başarısız: {response.status_code}, {response.text}")
-
-        session_id = response.json().get("session_id")
-        if not session_id:
-            raise Exception("Session ID alınamadı.")
-
-        headers = {"X-Session-ID": session_id}
-
-        # === Test 1: LLM fallback
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "Mars'a bilet alabilir miyim?"}, headers=headers)
-        assert_test("LLM fallback", r.json(), "")
-
-        # === Test 2: Döviz kuru — başarılı
-        valid_currency = currency_options[0]
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{valid_currency} kuru nedir"}, headers=headers)
-        assert_test("Parametre tamamlandı — dolar", r.json(), f"{valid_currency} kuru şu an")
-
-        # === Test 3: Döviz kuru — geçersiz parametre
-        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 cinsi")
-
-        # === Test 4: Yol durumu — eksik parametreleri isteme
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yol durumu"}, headers=headers)
-        assert_test("Eksik parametre — from_location & to_location", r.json(), "Lütfen şu bilgileri sırayla belirtir misiniz")
-
-        # === Test 4b: Yol durumu — eksik parametreleri tamamlama ve doğrulama
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{city_options[0]} {city_options[1]}"}, headers=headers)
-        assert_test("Parametre tamamlandı — yol durumu", r.json(), "trafik açık")
-
-        # === Test 5: Hava durumu — eksik parametre isteme
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "hava durumu"}, headers=headers)
-        assert_test("Eksik parametre — city", r.json(), "Lütfen şu bilgileri sırayla belirtir misiniz")
-
-        # === Test 5b: Hava durumu — parametre tamamlama ve doğrulama
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{city_options[0]}"}, headers=headers)
-        assert_test("Parametre tamamlandı — hava durumu", r.json(), f"{city_options[0]} için hava güneşli")
-
-        summarize_tests()
-
-    except Exception as e:
-        log(f"❌ run_all_tests sırasında hata oluştu: {e}")
+import os
+import json
+import requests
+from log import log
+
+BASE_URL = os.environ.get("BASE_URL", "http://localhost:7860")
+SERVICE_CONFIG_PATH = os.environ.get("SERVICE_CONFIG_PATH", "service_config.json")
+
+with open(SERVICE_CONFIG_PATH, "r", encoding="utf-8") as f:
+    service_config = json.load(f)
+
+fallback_answers = service_config["projects"]["project1"]["llm"]["fallback_answers"]
+currency_options = service_config["config"]["data_formats"]["currency_format"]["valid_options"]
+city_options = service_config["config"]["data_formats"]["city_format"]["valid_options"]
+
+test_results = []
+
+def assert_test(name, actual, expected_substring, explanation=None):
+    if explanation:
+        log(f"🧪 TEST: {name} → {explanation}")
+    actual_str = str(actual)
+    passed = expected_substring in actual_str
+    if passed:
+        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")
+        if response.status_code != 200:
+            raise Exception(f"Start chat başarısız: {response.status_code}, {response.text}")
+
+        session_id = response.json().get("session_id")
+        if not session_id:
+            raise Exception("Session ID alınamadı.")
+
+        headers = {"X-Session-ID": session_id}
+
+        # === Test 1: LLM fallback
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "Mars'a bilet alabilir miyim?"}, headers=headers)
+        assert_test("LLM fallback", r.json(), "")
+
+        # === Test 2: Döviz kuru — başarılı
+        valid_currency = currency_options[0]
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{valid_currency} kuru nedir"}, headers=headers)
+        assert_test("Parametre tamamlandı — dolar", r.json(), f"{valid_currency} kuru şu an")
+
+        # === Test 3: Döviz kuru — geçersiz parametre
+        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 cinsi")
+
+        # === Test 4: Yol durumu — eksik parametreleri isteme
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "yol durumu"}, headers=headers)
+        assert_test("Eksik parametre — from_location & to_location", r.json(), "Lütfen şu bilgileri sırayla belirtir misiniz")
+
+        # === Test 4b: Yol durumu — eksik parametreleri tamamlama ve doğrulama
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{city_options[0]} {city_options[1]}"}, headers=headers)
+        assert_test("Parametre tamamlandı — yol durumu", r.json(), "trafik açık")
+
+        # === Test 5: Hava durumu — eksik parametre isteme
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "hava durumu"}, headers=headers)
+        assert_test("Eksik parametre — city", r.json(), "Lütfen şu bilgileri sırayla belirtir misiniz")
+
+        # === Test 5b: Hava durumu — parametre tamamlama ve doğrulama
+        r = requests.post(f"{BASE_URL}/chat", json={"user_input": f"{city_options[0]}"}, headers=headers)
+        assert_test("Parametre tamamlandı — hava durumu", r.json(), f"{city_options[0]} için hava güneşli")
+
+        summarize_tests()
+
+    except Exception as e:
+        log(f"❌ run_all_tests sırasında hata oluştu: {e}")

intent_utils.py

@@ -1,64 +1,174 @@
-import re
-
-def extract_parameters(variables_list, user_input):
-    extracted_params = []
-    for pattern in variables_list:
-        regex = re.sub(r"(\w+):\{(.+?)\}", r"(?P<\1>.+?)", pattern)
-        match = re.match(regex, user_input)
-        if match:
-            extracted_params = [{"key": k, "value": v} for k, v in match.groupdict().items()]
-            break
-
-    if not extracted_params:
-        city_pattern = r"(\bAnkara\b|\bİstanbul\b|\bİzmir\b)"
-        cities = re.findall(city_pattern, user_input)
-        if len(cities) >= 2:
-            extracted_params = [
-                {"key": "from_location", "value": cities[0]},
-                {"key": "to_location", "value": cities[1]}
-            ]
-    return extracted_params
-
-def resolve_placeholders(text: str, session: dict, variables: dict) -> str:
-    def replacer(match):
-        full = match.group(1)
-        try:
-            if full.startswith("variables."):
-                key = full.split(".", 1)[1]
-                return str(variables.get(key, f"{{{full}}}"))
-            elif full.startswith("session."):
-                key = full.split(".", 1)[1]
-                return str(session.get("variables", {}).get(key, f"{{{full}}}"))
-            elif full.startswith("auth_tokens."):
-                parts = full.split(".")
-                if len(parts) == 3:
-                    intent, token_type = parts[1], parts[2]
-                    return str(session.get("auth_tokens", {}).get(intent, {}).get(token_type, f"{{{full}}}"))
-                else:
-                    return f"{{{full}}}"
-            else:
-                return f"{{{full}}}"
-        except Exception:
-            return f"{{{full}}}"
-
-    return re.sub(r"\{([^{}]+)\}", replacer, text)
-
-def validate_variable_formats(variables, variable_format_map, data_formats):
-    errors = {}
-    for var_name, format_name in variable_format_map.items():
-        value = variables.get(var_name)
-        if value is None:
-            continue
-
-        format_def = data_formats.get(format_name)
-        if not format_def:
-            continue
-
-        if "valid_options" in format_def:
-            if value not in format_def["valid_options"]:
-                errors[var_name] = format_def.get("error_message", f"{var_name} değeri geçersiz.")
-        elif "pattern" in format_def:
-            if not re.fullmatch(format_def["pattern"], value):
-                errors[var_name] = format_def.get("error_message", f"{var_name} formatı geçersiz.")
-
-    return len(errors) == 0, errors
+import os
+import torch
+import json
+import shutil
+import re
+import traceback
+from datasets import Dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    AutoConfig,
+)
+from log import log
+from core import llm_models
+
+async def detect_intent(text, project_name):
+    llm_model_instance = llm_models.get(project_name)
+    if not llm_model_instance or not llm_model_instance.intent_model:
+        raise Exception(f"'{project_name}' için intent modeli yüklenmemiş.")
+
+    tokenizer = llm_model_instance.intent_tokenizer
+    model = llm_model_instance.intent_model
+    label2id = llm_model_instance.intent_label2id
+
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    outputs = model(**inputs)
+    predicted_id = outputs.logits.argmax(dim=-1).item()
+
+    detected_intent = [k for k, v in label2id.items() if v == predicted_id][0]
+    confidence = outputs.logits.softmax(dim=-1).max().item()
+
+    return detected_intent, confidence
+
+def background_training(project_name, intents, model_id, output_path, confidence_threshold):
+    try:
+        log(f"🔧 Intent eğitimi başlatıldı (proje: {project_name})")
+        texts, labels, label2id = [], [], {}
+        for idx, intent in enumerate(intents):
+            label2id[intent["name"]] = idx
+            for ex in intent["examples"]:
+                texts.append(ex)
+                labels.append(idx)
+
+        dataset = Dataset.from_dict({"text": texts, "label": labels})
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        config = AutoConfig.from_pretrained(model_id)
+        config.problem_type = "single_label_classification"
+        config.num_labels = len(label2id)
+        model = AutoModelForSequenceClassification.from_pretrained(model_id, config=config)
+
+        tokenized_data = {"input_ids": [], "attention_mask": [], "label": []}
+        for row in dataset:
+            out = tokenizer(row["text"], truncation=True, padding="max_length", max_length=128)
+            tokenized_data["input_ids"].append(out["input_ids"])
+            tokenized_data["attention_mask"].append(out["attention_mask"])
+            tokenized_data["label"].append(row["label"])
+
+        tokenized = Dataset.from_dict(tokenized_data)
+        tokenized.set_format(type="torch", columns=["input_ids", "attention_mask", "label"])
+
+        if os.path.exists(output_path):
+            shutil.rmtree(output_path)
+        os.makedirs(output_path, exist_ok=True)
+
+        trainer = Trainer(
+            model=model,
+            args=TrainingArguments(output_path, per_device_train_batch_size=4, num_train_epochs=3, logging_steps=10, save_strategy="no", report_to=[]),
+            train_dataset=tokenized,
+            data_collator=default_data_collator,
+        )
+        trainer.train()
+
+        log("🔧 Başarı raporu üretiliyor...")
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model.to(device)
+        input_ids_tensor = torch.tensor(tokenized["input_ids"]).to(device)
+        attention_mask_tensor = torch.tensor(tokenized["attention_mask"]).to(device)
+
+        with torch.no_grad():
+            outputs = model(input_ids=input_ids_tensor, attention_mask=attention_mask_tensor)
+            predictions = outputs.logits.argmax(dim=-1).tolist()
+
+        actuals = tokenized["label"]
+        counts, correct = {}, {}
+        for pred, actual in zip(predictions, actuals):
+            intent_name = list(label2id.keys())[list(label2id.values()).index(actual)]
+            counts[intent_name] = counts.get(intent_name, 0) + 1
+            if pred == actual:
+                correct[intent_name] = correct.get(intent_name, 0) + 1
+        for intent_name, total in counts.items():
+            accuracy = correct.get(intent_name, 0) / total
+            log(f"📊 Intent '{intent_name}' doğruluk: {accuracy:.2f} — {total} örnek")
+            if accuracy < confidence_threshold or total < 5:
+                log(f"⚠️ Yetersiz performanslı intent: '{intent_name}' — Doğruluk: {accuracy:.2f}, Örnek: {total}")
+
+        # Eğitim sonrası model ve tokenizer'ı diske kaydet
+        model.save_pretrained(output_path)
+        tokenizer.save_pretrained(output_path)
+        with open(os.path.join(output_path, "label2id.json"), "w") as f:
+            json.dump(label2id, f)
+
+        log(f"✅ Intent eğitimi tamamlandı ve '{project_name}' için model disk üzerinde hazır.")
+
+    except Exception as e:
+        log(f"❌ Intent eğitimi hatası: {e}")
+        traceback.print_exc()
+
+def extract_parameters(variables_list, user_input):
+    extracted_params = []
+    for pattern in variables_list:
+        # Örneğin: from_location:{Ankara} to_location:{İstanbul}
+        regex = re.sub(r"(\w+):\{(.+?)\}", r"(?P<\1>.+?)", pattern)
+        match = re.match(regex, user_input)
+        if match:
+            extracted_params = [{"key": k, "value": v} for k, v in match.groupdict().items()]
+            break
+
+    # Ek özel basit yakalama: iki şehir birden yazılırsa → sırayla atama
+    if not extracted_params:
+        city_pattern = r"(\bAnkara\b|\bİstanbul\b|\bİzmir\b)"
+        cities = re.findall(city_pattern, user_input)
+        if len(cities) >= 2:
+            extracted_params = [
+                {"key": "from_location", "value": cities[0]},
+                {"key": "to_location", "value": cities[1]}
+            ]
+    return extracted_params
+
+def resolve_placeholders(text: str, session: dict, variables: dict) -> str:
+    def replacer(match):
+        full = match.group(1)
+        try:
+            if full.startswith("variables."):
+                key = full.split(".", 1)[1]
+                return str(variables.get(key, f"{{{full}}}"))
+            elif full.startswith("session."):
+                key = full.split(".", 1)[1]
+                return str(session.get("variables", {}).get(key, f"{{{full}}}"))
+            elif full.startswith("auth_tokens."):
+                parts = full.split(".")
+                if len(parts) == 3:
+                    intent, token_type = parts[1], parts[2]
+                    return str(session.get("auth_tokens", {}).get(intent, {}).get(token_type, f"{{{full}}}"))
+                else:
+                    return f"{{{full}}}"
+            else:
+                return f"{{{full}}}"
+        except Exception:
+            return f"{{{full}}}"
+
+    return re.sub(r"\{([^{}]+)\}", replacer, text)
+
+def validate_variable_formats(variables, variable_format_map, data_formats):
+    errors = {}
+    for var_name, format_name in variable_format_map.items():
+        value = variables.get(var_name)
+        if value is None:
+            continue
+
+        format_def = data_formats.get(format_name)
+        if not format_def:
+            continue
+
+        if "valid_options" in format_def:
+            if value not in format_def["valid_options"]:
+                errors[var_name] = format_def.get("error_message", f"{var_name} değeri geçersiz.")
+        elif "pattern" in format_def:
+            if not re.fullmatch(format_def["pattern"], value):
+                errors[var_name] = format_def.get("error_message", f"{var_name} formatı geçersiz.")
+
+    return len(errors) == 0, errors

llm_model.py

@@ -1,65 +1,65 @@
-import torch
-import traceback
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from log import log
-from pydantic import BaseModel
-import os
-import json
-
-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, project_path):
-        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"]
-            token = s_config.get_auth_token()
-
-            if s_config.work_mode == "hfcloud":
-                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)
-            else:
-                log(f"📦 Model indiriliyor veya yükleniyor: {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)
-
-            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_with_messages(self, messages, project_config, system_prompt):
-        all_messages = [{"role": "system", "content": system_prompt}] + messages
-        encodeds = self.tokenizer.apply_chat_template(all_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=256,
-                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
-            )
-
-        decoded = self.tokenizer.decode(output.sequences[0], skip_special_tokens=True).strip()
-        return decoded
+import torch
+import traceback
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from log import log
+from pydantic import BaseModel
+import os
+import json
+
+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, project_path):
+        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"]
+            token = s_config.get_auth_token()
+
+            if s_config.work_mode == "hfcloud":
+                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)
+            else:
+                log(f"📦 Model indiriliyor veya yükleniyor: {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)
+
+            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_with_messages(self, messages, project_config, system_prompt):
+        all_messages = [{"role": "system", "content": system_prompt}] + messages
+        encodeds = self.tokenizer.apply_chat_template(all_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=256,
+                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
+            )
+
+        decoded = self.tokenizer.decode(output.sequences[0], skip_special_tokens=True).strip()
+        return decoded

log.py

@@ -1,11 +1,11 @@
-from datetime import datetime
-
-def log(message):
-    timestamp = datetime.now().strftime("%H:%M:%S")
-    line = f"[{timestamp}] {message}"
-    print(line, flush=True)
-    try:
-        with open("/tmp/logs.txt", "a", encoding="utf-8") as f:
-            f.write(line + "\n")
-    except Exception:
+from datetime import datetime
+
+def log(message):
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    line = f"[{timestamp}] {message}"
+    print(line, flush=True)
+    try:
+        with open("/tmp/logs.txt", "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
         pass  # dosya erişim hataları sessizce geçilir

parse_llm_blocks.py

@@ -1,25 +1,25 @@
-import re
-import json
-
-def parse_llm_blocks(response_text):
-    blocks = {
-        "intent": "NONE",
-        "params": {},
-        "missing": [],
-        "action_json": {}
-    }
-    intent_match = re.search(r"#INTENT:\s*(.+)", response_text)
-    params_match = re.search(r"#PARAMS:\s*(\{.*?\})", response_text)
-    missing_match = re.search(r"#MISSING:\s*(\[[^\]]*\])", response_text)
-    action_match = re.search(r"#ACTION_JSON:\s*(\{.*?\})", response_text)
-
-    if intent_match:
-        blocks["intent"] = intent_match.group(1).strip()
-    if params_match:
-        blocks["params"] = json.loads(params_match.group(1))
-    if missing_match:
-        blocks["missing"] = json.loads(missing_match.group(1))
-    if action_match:
-        blocks["action_json"] = json.loads(action_match.group(1))
-
-    return blocks
+import re
+import json
+
+def parse_llm_blocks(response_text):
+    blocks = {
+        "intent": "NONE",
+        "params": {},
+        "missing": [],
+        "action_json": {}
+    }
+    intent_match = re.search(r"#INTENT:\s*(.+)", response_text)
+    params_match = re.search(r"#PARAMS:\s*(\{.*?\})", response_text)
+    missing_match = re.search(r"#MISSING:\s*(\[[^\]]*\])", response_text)
+    action_match = re.search(r"#ACTION_JSON:\s*(\{.*?\})", response_text)
+
+    if intent_match:
+        blocks["intent"] = intent_match.group(1).strip()
+    if params_match:
+        blocks["params"] = json.loads(params_match.group(1))
+    if missing_match:
+        blocks["missing"] = json.loads(missing_match.group(1))
+    if action_match:
+        blocks["action_json"] = json.loads(action_match.group(1))
+
+    return blocks

service_config.json

@@ -1,113 +1,113 @@
-{
-    "config": {
-        "work_mode": "hfcloud",
-        "cloud_token": "",
-        "system_prompt": "Sen bir görev tabanlı asistan botsun ve kullanıcıyla doğal dilde sohbet edebilirsin. Ancak kullanıcı mesajlarında bir görev (intent) algılarsan, önce intent’i tespit et, sonra eksik parametreleri ve aksiyon json’unu hazırla. Eğer yeterli bilgi yoksa eksik parametreleri listele. Eğer konu değiştiyse veya yeni bir sohbet başladıysa, beklenen parametre modunu bırak. Cevaplarının içinde her zaman aşağıdaki işaretli blokları kullan: #INTENT: <intent_adı> (veya NONE) #PARAMS: {parametreler JSON} #MISSING: [eksik_parametreler listesi] #ACTION_JSON: {api çağrısı için JSON} Mevcut intent’ler: - doviz-kuru-intent → parametre: currency (\"dolar\", \"euro\", \"TL\") - yol-durumu-intent → parametreler: from_location, to_location (\"Ankara\", \"İstanbul\", \"İzmir\") - hava-durumu-intent → parametre: city (\"Ankara\", \"İstanbul\", \"İzmir\") Unutma: Kullanıcı mesajlarını doğal ve insani tut. Eğer bir görev varsa, üstteki blokları eksiksiz döndür. Eğer bir görev yoksa sadece #INTENT: NONE bloklarını döndür. Action JSON yalnızca tüm parametreler tamamlandığında dolu olur.",
-        "data_formats": {
-            "currency_format": {
-                "valid_options": ["dolar", "euro", "TL"],
-                "error_message": "Geçerli bir döviz cinsi belirtmelisiniz."
-            },
-            "city_format": {
-                "valid_options": ["Ankara", "İstanbul", "İzmir"],
-                "error_message": "Geçerli bir şehir adı belirtmelisiniz."
-            }
-        },
-        "apis": {
-            "currency_api": {
-                "url": "https://b9e2-176-88-34-20.ngrok-free.app/doviz",
-                "method": "POST",
-                "headers": [
-                    { "key": "Authorization", "value": "Bearer {auth_tokens.currency_api.token}" }
-                ],
-                "body": {
-                    "currency": "{variables.currency}"
-                },
-                "timeout": 5,
-                "retry_count": 1,
-                "auth": {
-                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
-                    "auth_body": { "username": "user", "password": "pass" },
-                    "auth_token_path": "token",
-                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
-                    "refresh_body": { "refresh_token": "{auth_tokens.currency_api.token}" }
-                },
-                "response_parser": {
-                    "field": "rate",
-                    "format": "{variables.currency} kuru: {rate} TL"
-                },
-                "reply_template": "{variables.currency} kuru şu an {rate} TL."
-            },
-            "traffic_api": {
-                "url": "https://b9e2-176-88-34-20.ngrok-free.app/yol",
-                "method": "POST",
-                "headers": [
-                    { "key": "Authorization", "value": "Bearer {auth_tokens.traffic_api.token}" }
-                ],
-                "body": {
-                    "from_location": "{variables.from_location}",
-                    "to_location": "{variables.to_location}"
-                },
-                "timeout": 5,
-                "retry_count": 1,
-                "auth": {
-                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
-                    "auth_body": { "username": "user", "password": "pass" },
-                    "auth_token_path": "token",
-                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
-                    "refresh_body": { "refresh_token": "{auth_tokens.traffic_api.token}" }
-                },
-                "response_parser": {
-                    "field": "status",
-                    "format": "{from_location} → {to_location} arası: {status}"
-                },
-                "reply_template": "{from_location} ile {to_location} arasındaki trafik durumu: {status}"
-            },
-            "weather_api": {
-                "url": "https://b9e2-176-88-34-20.ngrok-free.app/hava",
-                "method": "POST",
-                "headers": [
-                    { "key": "Authorization", "value": "Bearer {auth_tokens.weather_api.token}" }
-                ],
-                "body": {
-                    "city": "{variables.city}"
-                },
-                "timeout": 5,
-                "retry_count": 1,
-                "auth": {
-                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
-                    "auth_body": { "username": "user", "password": "pass" },
-                    "auth_token_path": "token",
-                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
-                    "refresh_body": { "refresh_token": "{auth_tokens.weather_api.token}" }
-                },
-                "response_parser": {
-                    "field": "status",
-                    "format": "{city} hava durumu: {status}"
-                },
-                "reply_template": "{city} için hava durumu: {status}"
-            }
-        }
-    },
-    "projects": {
-        "project1": {
-            "llm": {
-                "model_base": "TURKCELL/Turkcell-LLM-7b-v1",
-                "use_fine_tune": false,
-                "fine_tune_repo": "UcsTurkey/trained-zips",
-                "fine_tune_zip": "trained_model_000_009.zip",
-                "use_sampling": false,
-                "intent_confidence_treshold": 0.3,
-                "llm_confidence_treshold": 0.2,
-                "train_confidence_treshold": 0.7,
-                "intent_model_path": "/data/projects/project1/intent/trained_model",
-                "intent_model_id": "dbmdz/bert-base-turkish-cased",
-                "fallback_answers": [
-                    "Bu konuda maalesef bilgim yok.",
-                    "Ne demek istediğinizi tam anlayamadım.",
-                    "Bu soruya şu an yanıt veremiyorum."
-                ]
-            }
-        }
-    }
-}
+{
+    "config": {
+        "work_mode": "hfcloud",
+        "cloud_token": "",
+        "system_prompt": "Sen bir görev tabanlı asistan botsun ve kullanıcıyla doğal dilde sohbet edebilirsin. Ancak kullanıcı mesajlarında bir görev (intent) algılarsan, önce intent’i tespit et, sonra eksik parametreleri ve aksiyon json’unu hazırla. Eğer yeterli bilgi yoksa eksik parametreleri listele. Eğer konu değiştiyse veya yeni bir sohbet başladıysa, beklenen parametre modunu bırak. Cevaplarının içinde her zaman aşağıdaki işaretli blokları kullan: #INTENT: <intent_adı> (veya NONE) #PARAMS: {parametreler JSON} #MISSING: [eksik_parametreler listesi] #ACTION_JSON: {api çağrısı için JSON} Mevcut intent’ler: - doviz-kuru-intent → parametre: currency (\"dolar\", \"euro\", \"TL\") - yol-durumu-intent → parametreler: from_location, to_location (\"Ankara\", \"İstanbul\", \"İzmir\") - hava-durumu-intent → parametre: city (\"Ankara\", \"İstanbul\", \"İzmir\") Unutma: Kullanıcı mesajlarını doğal ve insani tut. Eğer bir görev varsa, üstteki blokları eksiksiz döndür. Eğer bir görev yoksa sadece #INTENT: NONE bloklarını döndür. Action JSON yalnızca tüm parametreler tamamlandığında dolu olur.",
+        "data_formats": {
+            "currency_format": {
+                "valid_options": ["dolar", "euro", "TL"],
+                "error_message": "Geçerli bir döviz cinsi belirtmelisiniz."
+            },
+            "city_format": {
+                "valid_options": ["Ankara", "İstanbul", "İzmir"],
+                "error_message": "Geçerli bir şehir adı belirtmelisiniz."
+            }
+        },
+        "apis": {
+            "currency_api": {
+                "url": "https://b9e2-176-88-34-20.ngrok-free.app/doviz",
+                "method": "POST",
+                "headers": [
+                    { "key": "Authorization", "value": "Bearer {auth_tokens.currency_api.token}" }
+                ],
+                "body": {
+                    "currency": "{variables.currency}"
+                },
+                "timeout": 5,
+                "retry_count": 1,
+                "auth": {
+                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
+                    "auth_body": { "username": "user", "password": "pass" },
+                    "auth_token_path": "token",
+                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
+                    "refresh_body": { "refresh_token": "{auth_tokens.currency_api.token}" }
+                },
+                "response_parser": {
+                    "field": "rate",
+                    "format": "{variables.currency} kuru: {rate} TL"
+                },
+                "reply_template": "{variables.currency} kuru şu an {rate} TL."
+            },
+            "traffic_api": {
+                "url": "https://b9e2-176-88-34-20.ngrok-free.app/yol",
+                "method": "POST",
+                "headers": [
+                    { "key": "Authorization", "value": "Bearer {auth_tokens.traffic_api.token}" }
+                ],
+                "body": {
+                    "from_location": "{variables.from_location}",
+                    "to_location": "{variables.to_location}"
+                },
+                "timeout": 5,
+                "retry_count": 1,
+                "auth": {
+                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
+                    "auth_body": { "username": "user", "password": "pass" },
+                    "auth_token_path": "token",
+                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
+                    "refresh_body": { "refresh_token": "{auth_tokens.traffic_api.token}" }
+                },
+                "response_parser": {
+                    "field": "status",
+                    "format": "{from_location} → {to_location} arası: {status}"
+                },
+                "reply_template": "{from_location} ile {to_location} arasındaki trafik durumu: {status}"
+            },
+            "weather_api": {
+                "url": "https://b9e2-176-88-34-20.ngrok-free.app/hava",
+                "method": "POST",
+                "headers": [
+                    { "key": "Authorization", "value": "Bearer {auth_tokens.weather_api.token}" }
+                ],
+                "body": {
+                    "city": "{variables.city}"
+                },
+                "timeout": 5,
+                "retry_count": 1,
+                "auth": {
+                    "auth_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/auth",
+                    "auth_body": { "username": "user", "password": "pass" },
+                    "auth_token_path": "token",
+                    "auth_refresh_endpoint": "https://b9e2-176-88-34-20.ngrok-free.app/refresh",
+                    "refresh_body": { "refresh_token": "{auth_tokens.weather_api.token}" }
+                },
+                "response_parser": {
+                    "field": "status",
+                    "format": "{city} hava durumu: {status}"
+                },
+                "reply_template": "{city} için hava durumu: {status}"
+            }
+        }
+    },
+    "projects": {
+        "project1": {
+            "llm": {
+                "model_base": "TURKCELL/Turkcell-LLM-7b-v1",
+                "use_fine_tune": false,
+                "fine_tune_repo": "UcsTurkey/trained-zips",
+                "fine_tune_zip": "trained_model_000_009.zip",
+                "use_sampling": false,
+                "intent_confidence_treshold": 0.3,
+                "llm_confidence_treshold": 0.2,
+                "train_confidence_treshold": 0.7,
+                "intent_model_path": "/data/projects/project1/intent/trained_model",
+                "intent_model_id": "dbmdz/bert-base-turkish-cased",
+                "fallback_answers": [
+                    "Bu konuda maalesef bilgim yok.",
+                    "Ne demek istediğinizi tam anlayamadım.",
+                    "Bu soruya şu an yanıt veremiyorum."
+                ]
+            }
+        }
+    }
+}

service_config.py

@@ -1,62 +1,62 @@
-import os
-import json
-from log import log
-
-class ServiceConfig:
-    def __init__(self):
-        self.work_mode = "cloud"
-        self.cloud_token = None
-        self.projects = {}
-        self.data_formats = {}
-        self.apis = {}
-        self.system_prompt = ""  # ✅ yeni eklendi
-
-    def load(self, is_reload=False):
-        try:
-            log("📥 service_config.json yükleniyor...")
-            with open("service_config.json", "r", encoding="utf-8") as f:
-                config_data = json.load(f)
-
-            general_config = config_data.get("config", {})
-            self.work_mode = general_config.get("work_mode", "cloud")
-            self.cloud_token = general_config.get("cloud_token")
-            self.system_prompt = general_config.get("system_prompt", "")  # ✅ yeni eklendi
-            self.data_formats = general_config.get("data_formats", {})
-            self.apis = general_config.get("apis", {})
-
-            projects = config_data.get("projects", {})
-            for project_name, project_info in projects.items():
-                llm_config = project_info.get("llm", {})
-
-                if project_name not in self.projects:
-                    self.projects[project_name] = {}
-
-                self.projects[project_name]["llm"] = llm_config
-
-                self._initialize_project(project_name, llm_config, is_reload)
-
-            log(f"✅ service_config.json yüklendi. Work mode: {self.work_mode}")
-
-        except Exception as e:
-            log(f"❌ ServiceConfig.load() hatası: {e}")
-            raise
-
-    def _initialize_project(self, project_name, llm_config, is_reload):
-        log(f"🔧 Proje '{project_name}' başlatılıyor (reload={is_reload})")
-
-    def get_project_llm_config(self, project_name):
-        return self.projects.get(project_name, {}).get("llm")
-
-    def get_data_format(self, format_name):
-        return self.data_formats.get(format_name)
-
-    def get_api_config(self, api_name):
-        return self.apis.get(api_name)
-
-    def get_auth_token(self):
-        if self.work_mode == "hfcloud":
-            return os.getenv("HF_TOKEN")
-        elif self.work_mode == "cloud":
-            return self.cloud_token
-        else:
-            return None
+import os
+import json
+from log import log
+
+class ServiceConfig:
+    def __init__(self):
+        self.work_mode = "cloud"
+        self.cloud_token = None
+        self.projects = {}
+        self.data_formats = {}
+        self.apis = {}
+        self.system_prompt = ""  # ✅ yeni eklendi
+
+    def load(self, is_reload=False):
+        try:
+            log("📥 service_config.json yükleniyor...")
+            with open("service_config.json", "r", encoding="utf-8") as f:
+                config_data = json.load(f)
+
+            general_config = config_data.get("config", {})
+            self.work_mode = general_config.get("work_mode", "cloud")
+            self.cloud_token = general_config.get("cloud_token")
+            self.system_prompt = general_config.get("system_prompt", "")  # ✅ yeni eklendi
+            self.data_formats = general_config.get("data_formats", {})
+            self.apis = general_config.get("apis", {})
+
+            projects = config_data.get("projects", {})
+            for project_name, project_info in projects.items():
+                llm_config = project_info.get("llm", {})
+
+                if project_name not in self.projects:
+                    self.projects[project_name] = {}
+
+                self.projects[project_name]["llm"] = llm_config
+
+                self._initialize_project(project_name, llm_config, is_reload)
+
+            log(f"✅ service_config.json yüklendi. Work mode: {self.work_mode}")
+
+        except Exception as e:
+            log(f"❌ ServiceConfig.load() hatası: {e}")
+            raise
+
+    def _initialize_project(self, project_name, llm_config, is_reload):
+        log(f"🔧 Proje '{project_name}' başlatılıyor (reload={is_reload})")
+
+    def get_project_llm_config(self, project_name):
+        return self.projects.get(project_name, {}).get("llm")
+
+    def get_data_format(self, format_name):
+        return self.data_formats.get(format_name)
+
+    def get_api_config(self, api_name):
+        return self.apis.get(api_name)
+
+    def get_auth_token(self):
+        if self.work_mode == "hfcloud":
+            return os.getenv("HF_TOKEN")
+        elif self.work_mode == "cloud":
+            return self.cloud_token
+        else:
+            return None

session.py

@@ -1,28 +1,28 @@
-import uuid
-
-class Session:
-    def __init__(self, project_name):
-        self.session_id = str(uuid.uuid4())
-        self.project_name = project_name
-        self.variables = {}
-        self.auth_tokens = {}
-        self.last_intent = None
-        self.awaiting_variable = None
-        self.chat_history = []
-
-class SessionStore:
-    def __init__(self):
-        self.sessions = {}
-
-    def create_session(self, project_name):
-        session = Session(project_name)
-        self.sessions[session.session_id] = session
-        return session
-
-    def get_session(self, session_id):
-        return self.sessions.get(session_id)
-
-    def remove_session(self, session_id):
-        if session_id in self.sessions:
-            del self.sessions[session_id]
-
+import uuid
+
+class Session:
+    def __init__(self, project_name):
+        self.session_id = str(uuid.uuid4())
+        self.project_name = project_name
+        self.variables = {}
+        self.auth_tokens = {}
+        self.last_intent = None
+        self.awaiting_variable = None
+        self.chat_history = []
+
+class SessionStore:
+    def __init__(self):
+        self.sessions = {}
+
+    def create_session(self, project_name):
+        session = Session(project_name)
+        self.sessions[session.session_id] = session
+        return session
+
+    def get_session(self, session_id):
+        return self.sessions.get(session_id)
+
+    def remove_session(self, session_id):
+        if session_id in self.sessions:
+            del self.sessions[session_id]
+