Upload 15 files

Dockerfile

@@ -1,26 +1,26 @@
-# === Hugging Face Spaces için temel imaj
-FROM python:3.10
-
-# === Hugging Face Spaces özel dizinleri
-RUN mkdir -p /data/chunks /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 ve izin tanımı
-ENV TORCH_HOME=/app/.torch_cache
-RUN mkdir -p /app/.torch_cache && chmod -R 777 /app/.torch_cache
-
-# === Gereken kütüphaneleri yükle
-COPY requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
-
-# === Uygulama dosyalarını kopyala
-COPY . /app
-WORKDIR /app
-
-# === Başlangıç komutu
+# === Hugging Face Spaces için temel imaj
+FROM python:3.10
+
+# === Hugging Face Spaces özel dizinleri
+RUN mkdir -p /data/chunks /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 ve izin tanımı
+ENV TORCH_HOME=/app/.torch_cache
+RUN mkdir -p /app/.torch_cache && chmod -R 777 /app/.torch_cache
+
+# === Gereken kütüphaneleri yükle
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# === Uygulama dosyalarını kopyala
+COPY . /app
+WORKDIR /app
+
+# === Başlangıç komutu
 CMD ["python", "app.py"]

README.md

@@ -1,10 +1,10 @@
----
-title: Inference Test
-emoji: 👁
-colorFrom: yellow
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Inference Test
+emoji: 👁
+colorFrom: yellow
+colorTo: pink
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1 +1,80 @@
-from inference_test import app
+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(model_base)
+            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(model_base)
+        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)

chat_handler debug.py

@@ -0,0 +1,136 @@
+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)
+

chat_handler.py

@@ -1,114 +1,105 @@
-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, model, tokenizer, Message
-from log import log
-
-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 model is None or tokenizer is None:
-            return {"error": "Model yüklenmedi."}
-
-        detected_intent, intent_conf = None, 0.0
-        if s_config.INTENT_MODEL:
-            detected_intent, intent_conf = await detect_intent(user_input)
-            log(f"🎯 Intent tespit edildi: {detected_intent} (conf={intent_conf:.2f})")
-
-        current_intent = session.get("last_intent")
-        awaiting_variable = session.get("awaiting_variable")
-
-        if (
-            awaiting_variable and
-            detected_intent and
-            detected_intent != current_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD
-        ):
-            log(f"🧹 Yeni intent: {detected_intent}, önceki: {current_intent} — awaiting sıfırlanıyor.")
-            session["awaiting_variable"] = None
-            session["variables"] = {}
-            session["last_intent"] = detected_intent
-            current_intent = detected_intent
-
-        if (
-            detected_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD and
-            detected_intent in s_config.INTENT_DEFINITIONS
-        ):
-            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)
-
-            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]
-                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 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?"}
-
-            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)}
-
-        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
+import random
+from intent import extract_parameters, validate_variable_formats, detect_intent
+from intent_api import execute_intent
+from log import log
+from llm_model import Message, LLMModel
+
+async def handle_chat(msg: Message, request: Request, app, service_config, session, llm_model: LLMModel):
+    try:
+        user_input = msg.user_input.strip()
+        project_name = session.project_name
+        project_config = service_config.get_project_llm_config(project_name)
+        project_intents = service_config.get_project_intents(project_name)
+
+        if llm_model.model is None or llm_model.tokenizer is None:
+            return {"error": f"{project_name} için model yüklenmedi."}
+
+        detected_intent, intent_conf = await detect_intent(user_input)
+        log(f"🎯 Intent tespit edildi: {detected_intent}, Confidence: {intent_conf:.2f}")
+
+        current_intent = session.last_intent
+        awaiting_variable = session.awaiting_variable
+
+        if (
+            awaiting_variable and
+            detected_intent and
+            detected_intent != current_intent and
+            intent_conf > project_config["intent_confidence_treshold"]
+        ):
+            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 > project_config["intent_confidence_treshold"] and
+            any(i["name"] == detected_intent for i in project_intents)
+        )
+        log(f"✅ Intent geçerli mi?: {intent_is_valid}")
+
+        if intent_is_valid:
+            session.last_intent = detected_intent
+            intent_def = next(i for i in project_intents if i["name"] == detected_intent)
+            pattern_list = intent_def.get("variables", [])
+            variable_format_map = intent_def.get("variable_formats", {})
+            data_formats = service_config.data_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.variables.update(variables)
+
+            is_valid, validation_errors = validate_variable_formats(session.variables, variable_format_map, data_formats)
+            log(f"📛 Validasyon hataları: {validation_errors}")
+
+            if not is_valid:
+                session.awaiting_variable = list(validation_errors.keys())[0]
+                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]
+            log(f"📌 Beklenen parametreler: {expected_vars}, Eksik: {missing_vars}")
+
+            if missing_vars:
+                session.awaiting_variable = missing_vars[0]
+                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.__dict__,
+                {i["name"]: i for i in project_intents},
+                data_formats
+            )
+            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"])}
+
+        log("🤖 execute_intent çağrılmadı → LLM fallback devrede")
+        session.awaiting_variable = None
+        session.variables = {}
+        response, response_conf = await llm_model.generate_response(user_input, project_config)
+        if response_conf is not None and response_conf < project_config["llm_confidence_treshold"]:
+            return {"response": random.choice(project_config["fallback_answers"])}
+        return {"response": response}
+
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(content={"error": str(e)}, status_code=500)

inference_test.py

@@ -1,133 +1,133 @@
-import os, threading, uvicorn, time, traceback, random, json, asyncio, uuid
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, JSONResponse
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import intent_test_runner
-from service_config import ServiceConfig
-import intent, intent, llm_model
-from log import log
-from chat_handler_debug import handle_chat
-from llm_model import get_model, get_tokenizer
-
-s_config = ServiceConfig()
-s_config.setup_environment()
-
-# === FastAPI
-app = FastAPI()
-chat_history = []
-
-@app.get("/")
-def health():
-    return {"status": "ok"}
-
-import uuid  # yukarıda zaten eklendiğini varsayıyoruz
-
-@app.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ı."}
-
-@app.get("/start", response_class=HTMLResponse)
-def root():
-    # Yeni session ID üret
-    session_id = str(uuid.uuid4())
-    session_info = {
-        "session_id": session_id,
-        "variables": {},
-        "auth_tokens": {},
-        "last_intent": None,
-        "awaiting_variable": None
-    }
-
-    # Session store başlatıldıysa ekle
-    if not hasattr(app.state, "session_store"):
-        app.state.session_store = {}
-    app.state.session_store[session_id] = session_info
-
-    log(f"🌐 /start ile yeni session başlatıldı: {session_id}")
-
-    # HTML + session_id gömülü
-    return f"""
-    <html><body>
-        <h2>Turkcell LLM Chat</h2>
-        <textarea id='input' rows='4' cols='60'></textarea><br>
-        <button onclick='send()'>Gönder</button><br><br>
-        <label>Model Cevabı:</label><br>
-        <textarea id='output' rows='10' cols='80' readonly style='white-space: pre-wrap;'></textarea>
-        <script>
-        const sessionId = "{session_id}";
-        localStorage.setItem("session_id", sessionId);
-        async function send() {{
-            const input = document.getElementById("input").value;
-            const res = await fetch('/chat', {{
-                method: 'POST',
-                headers: {{
-                    'Content-Type': 'application/json',
-                    'X-Session-ID': sessionId
-                }},
-                body: JSON.stringify({{ user_input: input }})
-            }});
-            const data = await res.json();
-            document.getElementById('output').value = data.reply || data.response || data.error || 'Hata oluştu.';
-        }}
-        </script>
-    </body></html>
-    """
-
-@app.post("/start_chat")
-def start_chat():
-    if get_model() is None or get_tokenizer() is None:
-        return {"error": "Model yüklenmedi."}
-
-    if not hasattr(app.state, "session_store"):
-        app.state.session_store = {}
-
-    session_id = str(uuid.uuid4())
-    session_info = {
-        "session_id": session_id,
-        "variables": {},
-        "auth_tokens": {},
-        "last_intent": None,
-        "awaiting_variable": None
-    }
-    app.state.session_store[session_id] = session_info
-    log(f"🆕 Yeni session başlatıldı: {session_id}")
-    return {"session_id": session_id}
-
-@app.post("/train_intents", status_code=202)
-def train_intents(train_input: intent.TrainInput):
-    log("📥 POST /train_intents çağrıldı.")
-
-    intents = train_input.intents
-    data_formats = getattr(train_input, "data_formats", [])
-
-    s_config.INTENT_DEFINITIONS = {intent["name"]: intent for intent in intents}
-    s_config.DATA_FORMATS = data_formats  # 🔧 DATA_FORMATS burada set ediliyor
-
-    threading.Thread(
-        target=lambda: intent.background_training(intents, s_config),
-        daemon=True
-    ).start()
-
-    return {"status": "accepted", "message": "Intent eğitimi arka planda başlatıldı."}
-
-@app.post("/load_intent_model")
-def load_intent_model():
-    try:
-        intent.INTENT_TOKENIZER = AutoTokenizer.from_pretrained(s_config.INTENT_MODEL_PATH)
-        intent.INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(s_config.INTENT_MODEL_PATH)
-        with open(os.path.join(s_config.INTENT_MODEL_PATH, "label2id.json")) as f:
-            intent.LABEL2ID = json.load(f)
-        return {"status": "ok", "message": "Intent modeli yüklendi."}
-    except Exception as e:
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-
-@app.post("/chat")
-async def chat(msg: llm_model.Message, request: Request):
-    return await handle_chat(msg, request, app, s_config)
-
-threading.Thread(target=llm_model.setup_model, kwargs={"s_config": s_config}, daemon=True).start()
-threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=7860), daemon=True).start()
-while True:
+import os, threading, uvicorn, time, traceback, random, json, asyncio, uuid
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import intent_test_runner
+from service_config import ServiceConfig
+import intent, intent, llm_model
+from log import log
+from chat_handler_debug import handle_chat
+from llm_model import get_model, get_tokenizer
+
+s_config = ServiceConfig()
+s_config.setup_environment()
+
+# === FastAPI
+app = FastAPI()
+chat_history = []
+
+@app.get("/")
+def health():
+    return {"status": "ok"}
+
+import uuid  # yukarıda zaten eklendiğini varsayıyoruz
+
+@app.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ı."}
+
+@app.get("/start", response_class=HTMLResponse)
+def root():
+    # Yeni session ID üret
+    session_id = str(uuid.uuid4())
+    session_info = {
+        "session_id": session_id,
+        "variables": {},
+        "auth_tokens": {},
+        "last_intent": None,
+        "awaiting_variable": None
+    }
+
+    # Session store başlatıldıysa ekle
+    if not hasattr(app.state, "session_store"):
+        app.state.session_store = {}
+    app.state.session_store[session_id] = session_info
+
+    log(f"🌐 /start ile yeni session başlatıldı: {session_id}")
+
+    # HTML + session_id gömülü
+    return f"""
+    <html><body>
+        <h2>Turkcell LLM Chat</h2>
+        <textarea id='input' rows='4' cols='60'></textarea><br>
+        <button onclick='send()'>Gönder</button><br><br>
+        <label>Model Cevabı:</label><br>
+        <textarea id='output' rows='10' cols='80' readonly style='white-space: pre-wrap;'></textarea>
+        <script>
+        const sessionId = "{session_id}";
+        localStorage.setItem("session_id", sessionId);
+        async function send() {{
+            const input = document.getElementById("input").value;
+            const res = await fetch('/chat', {{
+                method: 'POST',
+                headers: {{
+                    'Content-Type': 'application/json',
+                    'X-Session-ID': sessionId
+                }},
+                body: JSON.stringify({{ user_input: input }})
+            }});
+            const data = await res.json();
+            document.getElementById('output').value = data.reply || data.response || data.error || 'Hata oluştu.';
+        }}
+        </script>
+    </body></html>
+    """
+
+@app.post("/start_chat")
+def start_chat():
+    if get_model() is None or get_tokenizer() is None:
+        return {"error": "Model yüklenmedi."}
+
+    if not hasattr(app.state, "session_store"):
+        app.state.session_store = {}
+
+    session_id = str(uuid.uuid4())
+    session_info = {
+        "session_id": session_id,
+        "variables": {},
+        "auth_tokens": {},
+        "last_intent": None,
+        "awaiting_variable": None
+    }
+    app.state.session_store[session_id] = session_info
+    log(f"🆕 Yeni session başlatıldı: {session_id}")
+    return {"session_id": session_id}
+
+@app.post("/train_intents", status_code=202)
+def train_intents(train_input: intent.TrainInput):
+    log("📥 POST /train_intents çağrıldı.")
+
+    intents = train_input.intents
+    data_formats = getattr(train_input, "data_formats", [])
+
+    s_config.INTENT_DEFINITIONS = {intent["name"]: intent for intent in intents}
+    s_config.DATA_FORMATS = data_formats  # 🔧 DATA_FORMATS burada set ediliyor
+
+    threading.Thread(
+        target=lambda: intent.background_training(intents, s_config),
+        daemon=True
+    ).start()
+
+    return {"status": "accepted", "message": "Intent eğitimi arka planda başlatıldı."}
+
+@app.post("/load_intent_model")
+def load_intent_model():
+    try:
+        intent.INTENT_TOKENIZER = AutoTokenizer.from_pretrained(s_config.INTENT_MODEL_PATH)
+        intent.INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(s_config.INTENT_MODEL_PATH)
+        with open(os.path.join(s_config.INTENT_MODEL_PATH, "label2id.json")) as f:
+            intent.LABEL2ID = json.load(f)
+        return {"status": "ok", "message": "Intent modeli yüklendi."}
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+@app.post("/chat")
+async def chat(msg: llm_model.Message, request: Request):
+    return await handle_chat(msg, request, app, s_config)
+
+threading.Thread(target=llm_model.setup_model, kwargs={"s_config": s_config}, daemon=True).start()
+threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=7860), daemon=True).start()
+while True:
     time.sleep(60)

intent.py

@@ -1,153 +1,146 @@
-import os, torch, traceback, json, shutil, re
-from datasets import Dataset
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, default_data_collator, AutoConfig
-from log import log
-from pydantic import BaseModel
-
-INTENT_MODEL = None
-INTENT_TOKENIZER = None
-LABEL2ID = None
-
-class TrainInput(BaseModel):
-    intents: list
-    data_formats: list = []
-    
-def background_training(intents, s_config):
-    global INTENT_MODEL, INTENT_TOKENIZER, LABEL2ID
-    try:
-        log("🔧 Intent eğitimi başlatıldı...")
-        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(s_config.INTENT_MODEL_ID)
-        config = AutoConfig.from_pretrained(s_config.INTENT_MODEL_ID)
-        config.problem_type = "single_label_classification"
-        config.num_labels = len(label2id)
-        model = AutoModelForSequenceClassification.from_pretrained(s_config.INTENT_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"])
-
-        output_dir = "/app/intent_train_output"
-        os.makedirs(output_dir, exist_ok=True)
-        trainer = Trainer(
-            model=model,
-            args=TrainingArguments(output_dir, 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()
-
-        # ✅ Başarı raporu üret
-        log("🔧 Başarı raporu üretiliyor...")
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        model.to(device)
-        input_ids_tensor = tokenized["input_ids"].to(device)
-        attention_mask_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 = list(label2id.keys())[list(label2id.values()).index(actual)]
-            counts[intent] = counts.get(intent, 0) + 1
-            if pred == actual:
-                correct[intent] = correct.get(intent, 0) + 1
-        for intent, total in counts.items():
-            accuracy = correct.get(intent, 0) / total
-            log(f"📊 Intent '{intent}' doğruluk: {accuracy:.2f} — {total} örnek")
-            if accuracy < s_config.TRAIN_CONFIDENCE_THRESHOLD or total < 5:
-                log(f"⚠️ Yetersiz performanslı intent: '{intent}' — Doğruluk: {accuracy:.2f}, Örnek: {total}")
-
-        log("📦 Intent modeli eğitimi kaydediliyor...")
-        if os.path.exists(s_config.INTENT_MODEL_PATH):
-            shutil.rmtree(s_config.INTENT_MODEL_PATH)
-        model.save_pretrained(s_config.INTENT_MODEL_PATH)
-        tokenizer.save_pretrained(s_config.INTENT_MODEL_PATH)
-        with open(os.path.join(s_config.INTENT_MODEL_PATH, "label2id.json"), "w") as f:
-            json.dump(label2id, f)
-
-        log("✅ Intent eğitimi tamamlandı ve model kaydedildi.")
-
-    except Exception as e:
-        log(f"❌ Intent eğitimi hatası: {e}")
-        traceback.print_exc()
-
-async def detect_intent(text):
-    inputs = INTENT_TOKENIZER(text, return_tensors="pt")
-    outputs = INTENT_MODEL(**inputs)
-    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    confidence, pred_id = torch.max(probs, dim=-1)
-    id2label = {v: k for k, v in LABEL2ID.items()}
-    return id2label[pred_id.item()], confidence.item()
-
-def extract_parameters(variables_list, user_input):
-    for pattern in variables_list:
-        regex = re.sub(r"(\w+):\{(.+?)\}", r"(?P<\1>.+?)", pattern)
-        match = re.match(regex, user_input)
-        if match:
-            return [{"key": k, "value": v} for k, v in match.groupdict().items()]
-    return []
-
-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}}}"))  # session.variables içinden
-            elif full.startswith("auth_tokens."):
-                # auth_tokens.intent.token veya refresh_token
-                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}}}"  # bilinmeyen yapı
-        except Exception as e:
-            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  # eksik parametre kontrolü zaten başka yerde yapılacak
-
-        format_def = next((fmt for fmt in data_formats if fmt["name"] == format_name), None)
-        if not format_def:
-            continue  # tanımsız format
-
-        # valid_options kontrolü
-        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.")
-        # pattern kontrolü
-        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
+
+INTENT_MODELS = {}  # project_name -> (model, tokenizer, label2id)
+
+async def detect_intent(text):
+    # Bu fonksiyon bir örnek; çağırırken ilgili proje için model alınmalı
+    raise NotImplementedError("detect_intent çağrısı, proje bazlı model ile yapılmalıdır.")
+
+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()
+
+        # Başarı raporu
+        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}")
+
+        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)
+
+        INTENT_MODELS[project_name] = {
+            "model": model,
+            "tokenizer": tokenizer,
+            "label2id": label2id
+        }
+        log(f"✅ Intent eğitimi tamamlandı ve '{project_name}' modeli yüklendi.")
+
+    except Exception as e:
+        log(f"❌ Intent eğitimi hatası: {e}")
+        traceback.print_exc()
+
+def extract_parameters(variables_list, user_input):
+    for pattern in variables_list:
+        regex = re.sub(r"(\w+):\{(.+?)\}", r"(?P<\1>.+?)", pattern)
+        match = re.match(regex, user_input)
+        if match:
+            return [{"key": k, "value": v} for k, v in match.groupdict().items()]
+    return []
+
+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

intent_api.py

@@ -1,186 +1,181 @@
-import intent, requests, traceback
-from log import log
-
-def auth_token_handler(intent_name, auth_config, session):
-    try:
-        token_info = session.get("auth_tokens", {}).get(intent_name)
-        if token_info and "token" in token_info:
-            return token_info["token"], session  # Token zaten mevcut
-
-        # Auth token alınmamışsa:
-        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")
-
-        # Placeholder çözümü (auth_body içinde {session.xxx} varsa çözülür)
-        resolved_body = {
-            k: intent.resolve_placeholders(str(v), session, {}) 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 path (örnek: "token" → json_resp["token"], "data.access_token" → json_resp["data"]["access_token"])
-        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 varsa
-        refresh_token = json_resp.get("refresh_token")
-
-        # Session’a kaydet
-        session.setdefault("auth_tokens", {})[intent_name] = {
-            "token": token,
-            "refresh_token": refresh_token
-        }
-
-        return token, session
-
-    except Exception as e:
-        log(f"❌ Auth token alınamadı: {e}")
-        raise e
-
-def refresh_auth_token(intent_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 mevcut mu?
-        refresh_token = session.get("auth_tokens", {}).get(intent_name, {}).get("refresh_token")
-        if not refresh_token:
-            raise Exception("Mevcut refresh token bulunamadı")
-
-        # Refresh body içinde placeholder varsa çöz
-        resolved_body = {
-            k: intent.resolve_placeholders(str(v), session, {}) 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()
-
-        # Yeni token çıkar
-        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}")
-
-        # Yeni refresh_token varsa onu da al
-        new_refresh_token = json_resp.get("refresh_token", refresh_token)
-
-        # Güncelle
-        session["auth_tokens"][intent_name] = {
-            "token": token,
-            "refresh_token": new_refresh_token
-        }
-
-        log(f"🔁 Token başarıyla yenilendi: {intent_name}")
-        return token, session
-
-    except Exception as e:
-        log(f"❌ Token yenileme başarısız: {e}")
-        raise e
-
-def execute_intent(intent_name, user_input, session, intent_definitions, data_formats):
-    try:
-        definition = intent_definitions[intent_name]
-        variables_raw = intent.extract_parameters(definition.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}")
-
-        # Validasyon
-        variable_format_map = definition.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
-            }
-
-        # Auth
-        headers = definition["action"].get("headers", [])
-        body = definition["action"].get("body", {})
-        method = definition["action"].get("method", "POST")
-        url = definition["action"]["url"]
-        timeout = definition["action"].get("timeout", 5)
-        retry_count = definition["action"].get("retry_count", 0)
-        auth_config = definition["action"].get("auth", None)
-        tls = definition["action"].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(intent_name, auth_config, session)
-
-        # Header ve Body placeholder çöz
-        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()
-        }
-
-        # API çağrısı
-        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(intent_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()
-
-        # Yanıtı parse et
-        field = definition["action"].get("response_parser", {}).get("field")
-        rate = json_resp.get(field) if field else json_resp
-        template = definition["action"].get("reply_template", str(rate))
-        reply = intent.resolve_placeholders(template, session, {**variables, field: str(rate)})
-
-        # Session güncelle
-        session.setdefault("variables", {}).update(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
+import requests
+import traceback
+from log import log
+
+def auth_token_handler(api_name, auth_config, session):
+    try:
+        token_info = session.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.__dict__, session.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.auth_tokens[api_name] = {
+            "token": token,
+            "refresh_token": refresh_token
+        }
+
+        return token, session
+
+    except Exception as e:
+        log(f"❌ Auth token alınamadı: {e}")
+        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.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.__dict__, session.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.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}")
+        raise e
+
+def execute_intent(intent_name, user_input, session_dict, intent_definitions, data_formats):
+    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 = session["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
+
+        if auth_config:
+            token, session = auth_token_handler(action_api_name, auth_config, session)
+
+        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))
+        reply = intent.resolve_placeholders(template, session, {**variables, field: str(value)})
+
+        session.setdefault("variables", {}).update(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,133 +1,70 @@
-import os, requests, time
-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 wait_for_intent_training(timeout_sec=60):
-    log("⏳ Intent eğitimi tamamlanıyor mu kontrol ediliyor...")
-    for _ in range(timeout_sec // 3):
-        logs = open("/tmp/logs.txt").read() if os.path.exists("/tmp/logs.txt") else ""
-        if "✅ Intent eğitimi tamamlandı" in logs:
-            return True
-        time.sleep(3)
-    return False
-
-def run_all_tests():
-    try:
-        log("🚀 Test süreci başlatıldı.")
-        session_id = requests.post(f"{BASE_URL}/start_chat").json().get("session_id")
-        headers = {"X-Session-ID": session_id}
-
-        # 1. LLM fallback testi
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "zzzzzzzzzzzzz"}, headers=headers)
-        assert_test("LLM fallback", r.json(), "Bu konuda maalesef")
-
-        # 2. Intent eğitimi (doviz + yol intentleri)
-        intents = {
-            "intents": [
-                {
-                    "name": "doviz-kuru",
-                    "examples": ["dolar kuru nedir", "euro kuru nedir"],
-                    "variables": ["currency:{dolar} kuru nedir", "currency:{euro} kuru nedir"],
-                    "variable_formats": {"currency": "currency_format"},
-                    "action": {
-                        "url": f"{MOCK_BASE}/doviz",
-                        "method": "POST",
-                        "headers": [{"key": "Authorization", "value": "Bearer {auth_tokens.doviz-kuru.token}"}],
-                        "body": {"currency": "{variables.currency}"},
-                        "auth": {
-                            "auth_endpoint": f"{MOCK_BASE}/auth",
-                            "auth_body": {"username": "user", "password": "pass"},
-                            "auth_token_path": "token",
-                            "auth_refresh_endpoint": f"{MOCK_BASE}/refresh",
-                            "refresh_body": {"refresh_token": "{auth_tokens.doviz-kuru.refresh_token}"}
-                        },
-                        "response_parser": {"field": "rate"},
-                        "reply_template": "{variables.currency} kuru şu an {rate} TL."
-                    }
-                },
-                {
-                    "name": "yol-durumu",
-                    "examples": ["Ankara'dan İstanbul'a yol durumu"],
-                    "variables": ["from_location:{Ankara} to_location:{İstanbul} yol durumu"],
-                    "action": {
-                        "url": f"{MOCK_BASE}/yol",
-                        "method": "POST",
-                        "headers": [{"key": "Authorization", "value": "Bearer {auth_tokens.yol-durumu.token}"}],
-                        "body": {
-                            "from_location": "{variables.from_location}",
-                            "to_location": "{variables.to_location}"
-                        },
-                        "auth": {
-                            "auth_endpoint": f"{MOCK_BASE}/auth",
-                            "auth_body": {"username": "user", "password": "pass"},
-                            "auth_token_path": "token",
-                            "auth_refresh_endpoint": f"{MOCK_BASE}/refresh",
-                            "refresh_body": {"refresh_token": "{auth_tokens.yol-durumu.refresh_token}"}
-                        },
-                        "response_parser": {"field": "status"},
-                        "reply_template": "{status}"
-                    }
-                }
-            ]
-        }
-        requests.post(f"{BASE_URL}/train_intents", json=intents)
-        if not wait_for_intent_training():
-            assert_test("Intent eğitimi zamanında tamamlandı", "False", "True")
-            summarize_tests()
-            return
-
-        r = requests.post(f"{BASE_URL}/load_intent_model")
-        assert_test("Intent modeli yüklendi", r.json(), "ok")
-
-        # 3. Eksik parametre — doviz-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")
-
-        # 4. Parametre tamamlandı — euro
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "euro"}, headers=headers)
-        assert_test("Parametre tamamlandı — euro", r.json(), "euro kuru şu an")
-
-        # 5. Geçersiz parametre — currency
-        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")
-
-        # 6. Eksik parametre — yol durumu
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "Ankara'dan yol durumu"}, headers=headers)
-        assert_test("Eksik parametre — to_location", r.json(), "Lütfen to_location")
-
-        # 7. Parametre tamamlandı — yol
-        r = requests.post(f"{BASE_URL}/chat", json={"user_input": "İstanbul"}, headers=headers)
-        assert_test("Parametre tamamlandı — yol durumu", r.json(), "trafik açık")
-
-        # 8. 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(), "Bu konuda maalesef")
-
-        summarize_tests()
-
-    except Exception as e:
-        log(f"❌ run_all_tests sırasında hata oluştu: {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,81 +1,84 @@
-import torch, traceback
-from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification
-from log import log
-from pydantic import BaseModel
-
-_model = None
-_tokenizer = None
-_eos_token_id = None
-
-def get_model():
-    return _model
-
-def get_tokenizer():
-    return _tokenizer
-
-def get_eos_token_id():
-    return _eos_token_id
-
-class Message(BaseModel):
-    user_input: str
-
-def setup_model(s_config):
-    global _model, _tokenizer, _eos_token_id
-    try:
-        log("🧠 setup_model() başladı")
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        log(f"📡 Kullanılan cihaz: {device}")
-        _tokenizer = AutoTokenizer.from_pretrained(s_config.MODEL_BASE, use_fast=False)
-        log("📦 Tokenizer yüklendi. Ana model indiriliyor...")
-        _model = AutoModelForCausalLM.from_pretrained(s_config.MODEL_BASE, torch_dtype=torch.float32).to(device)
-        log("📦 Ana model indirildi ve yüklendi. eval() çağırılıyor...")
-        _tokenizer.pad_token = _tokenizer.pad_token or _tokenizer.eos_token
-        _model.config.pad_token_id = _tokenizer.pad_token_id
-        _eos_token_id = _tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
-        _model.eval()
-        log("✅ Ana model eval() çağrıldı")
-        log(f"📦 Intent modeli indiriliyor: {s_config.INTENT_MODEL_ID}")
-        _ = AutoTokenizer.from_pretrained(s_config.INTENT_MODEL_ID)
-        _ = AutoModelForSequenceClassification.from_pretrained(s_config.INTENT_MODEL_ID)
-        log("✅ Intent modeli önbelleğe alındı.")
-        log("✔️ Model başarıyla yüklendi ve sohbet için hazır.")
-    except Exception as e:
-        log(f"❌ setup_model() hatası: {e}")
-        traceback.print_exc()
-
-async def generate_response(text, app_config):
-    model = get_model()
-    tokenizer = get_tokenizer()
-    eos_token_id = get_eos_token_id()
-
-    messages = [{"role": "user", "content": text}]
-    encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
-    input_ids = encodeds.to(model.device)
-    attention_mask = (input_ids != tokenizer.pad_token_id).long()
-
-    with torch.no_grad():
-        output = model.generate(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            max_new_tokens=128,
-            do_sample=app_config.USE_SAMPLING,
-            eos_token_id=eos_token_id,
-            pad_token_id=tokenizer.pad_token_id,
-            return_dict_in_generate=True,
-            output_scores=True
-        )
-
-    if not app_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 = 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, use_auth_token=token, use_fast=False)
+                self.model = AutoModelForCausalLM.from_pretrained(model_base, use_auth_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

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

requirements.txt

@@ -1,27 +1,27 @@
-# === FastAPI ve sunucu ===
-fastapi==0.110.1
-uvicorn==0.29.0
-
-# === Transformers ve NLP araçları ===
-transformers==4.40.1
-datasets==2.19.1
-peft==0.10.0
-accelerate==0.29.3
-sentence-transformers==2.6.1
-sentencepiece==0.1.99
-
-# === FAISS ve numpy/pandas ===
-faiss-cpu==1.7.4
-numpy==1.26.4
-pandas==2.2.2
-
-# === Diğer yardımcılar ===
-scikit-learn==1.4.2
-torch==2.2.2
-tokenizers==0.19.1
-
-# === Hugging Face Hub entegrasyonu ===
-huggingface_hub==0.23.0
-
-# === Parquet desteği için
+# === FastAPI ve sunucu ===
+fastapi==0.110.1
+uvicorn==0.29.0
+
+# === Transformers ve NLP araçları ===
+transformers==4.40.1
+datasets==2.19.1
+peft==0.10.0
+accelerate==0.29.3
+sentence-transformers==2.6.1
+sentencepiece==0.1.99
+
+# === FAISS ve numpy/pandas ===
+faiss-cpu==1.7.4
+numpy==1.26.4
+pandas==2.2.2
+
+# === Diğer yardımcılar ===
+scikit-learn==1.4.2
+torch==2.2.2
+tokenizers==0.19.1
+
+# === Hugging Face Hub entegrasyonu ===
+huggingface_hub==0.23.0
+
+# === Parquet desteği için
 pyarrow==15.0.2