Spaces:

UcsTurkey
/

flare

Running

App Files Files Community

ciyidogan commited on May 23

Commit

4b9f7d2

1 Parent(s): 1f11b01

proje dosyaları yüklendi

Browse files

Files changed (11) hide show

Dockerfile +26 -0
app.py +1 -0
app_config.py +29 -0
inference_test.py +166 -0
intent.py +150 -0
intent_api.py +185 -0
intent_system_design.md +137 -0
intent_test_runner.py +130 -0
llm_model.py +70 -0
log.py +5 -0
requirements.txt +27 -0

Dockerfile ADDED Viewed

	@@ -0,0 +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
+CMD ["python", "app.py"]

app.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ from inference_test import app

app_config.py ADDED Viewed

	@@ -0,0 +1,29 @@

+import os
+class AppConfig:
+    def __init__(self):
+        self.HF_TOKEN = os.getenv("HF_TOKEN")
+        self.MODEL_BASE = "TURKCELL/Turkcell-LLM-7b-v1"
+        self.USE_FINE_TUNE = False
+        self.FINE_TUNE_REPO = "UcsTurkey/trained-zips"
+        self.FINE_TUNE_ZIP = "trained_model_000_009.zip"
+        self.USE_SAMPLING = False
+        self.INTENT_CONFIDENCE_THRESHOLD = 0.5
+        self.LLM_CONFIDENCE_THRESHOLD = 0.2
+        self.TRAIN_CONFIDENCE_THRESHOLD = 0.7
+        self.FALLBACK_ANSWERS = [
+            "Bu konuda maalesef bilgim yok.",
+            "Ne demek istediğinizi tam anlayamadım.",
+            "Bu soruya şu an yanıt veremiyorum."
+        ]
+        self.INTENT_MODEL_PATH = "intent_model"
+        self.INTENT_MODEL_ID = "dbmdz/bert-base-turkish-cased"
+        self.INTENT_MODEL = None
+        self.INTENT_TOKENIZER = None
+        self.LABEL2ID = {}
+        self.INTENT_DEFINITIONS = {}
+    def setup_environment():
+        os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "true"
+        os.environ["TORCH_HOME"] = "/app/.torch_cache"
+        os.makedirs("/app/.torch_cache", exist_ok=True)

inference_test.py ADDED Viewed

	@@ -0,0 +1,166 @@

+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 app_config import AppConfig
+import intent, log, intent, llm_model
+app_config = AppConfig()
+app_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 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
+    intent.INTENT_DEFINITIONS = {intent["name"]: intent for intent in intents}
+    threading.Thread(target=lambda: intent.background_training(intents, app_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(app_config.INTENT_MODEL_PATH)
+        intent.INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(app_config.INTENT_MODEL_PATH)
+        with open(os.path.join(app_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):
+    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_info = {
+        "session_id": session_id,
+        "variables": {},
+        "auth_tokens": {},
+        "last_intent": None
+    }
+    session = session_store.get(session_id, session_info)
+    try:
+        if llm_model.model is None or llm_model.tokenizer is None:
+            return {"error": "Model yüklenmedi."}
+        if app_config.INTENT_MODEL:
+            intent_task = asyncio.create_task(intent.detect_intent(user_input))
+            response_task = asyncio.create_task(llm_model.generate_response(user_input, app_config))
+            intent, intent_conf = await intent_task
+            log(f"🎯 Intent: {intent} (conf={intent_conf:.2f})")
+            if intent_conf > app_config.INTENT_CONFIDENCE_THRESHOLD and intent in app_config.INTENT_DEFINITIONS:
+                result = intent.execute_intent(intent, user_input, session)
+                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(app_config.FALLBACK_ANSWERS)}
+            else:
+                response, response_conf = await response_task
+                if response_conf is not None and response_conf < app_config.LLM_CONFIDENCE_THRESHOLD:
+                    return {"response": random.choice(app_config.FALLBACK_ANSWERS)}
+                return {"response": response}
+        else:
+            response, response_conf = await llm_model.generate_response(user_input, app_config)
+            if response_conf is not None and response_conf < app_config.LLM_CONFIDENCE_THRESHOLD:
+                return {"response": random.choice(app_config.FALLBACK_ANSWERS)}
+            return {"response": response}
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+threading.Thread(target=llm_model.setup_model, kwargs={"app_config": app_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 ADDED Viewed

	@@ -0,0 +1,150 @@

+import os, torch, traceback, json, shutil, re
+from datasets import Dataset
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments, default_data_collator, AutoConfig
+import log
+from pydantic import BaseModel
+global INTENT_DEFINITIONS
+global INTENT_MODEL, INTENT_TOKENIZER, LABEL2ID
+class TrainInput(BaseModel):
+    intents: list
+def background_training(intents, app_config):
+    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(app_config.INTENT_MODEL_ID)
+        config = AutoConfig.from_pretrained(app_config.INTENT_MODEL_ID)
+        config.problem_type = "single_label_classification"
+        config.num_labels = len(label2id)
+        model = AutoModelForSequenceClassification.from_pretrained(app_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 < app_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(app_config.INTENT_MODEL_PATH):
+            shutil.rmtree(app_config.INTENT_MODEL_PATH)
+        model.save_pretrained(app_config.INTENT_MODEL_PATH)
+        tokenizer.save_pretrained(app_config.INTENT_MODEL_PATH)
+        with open(os.path.join(app_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

intent_api.py ADDED Viewed

	@@ -0,0 +1,185 @@

+import intent, requests, log, traceback
+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
+        }

intent_system_design.md ADDED Viewed

	@@ -0,0 +1,137 @@

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

intent_test_runner.py ADDED Viewed

	@@ -0,0 +1,130 @@

+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):
+    if expected_substring in str(actual):
+        log(f"[TEST] {name:<45} ✅")
+        test_results.append((name, True))
+    else:
+        log(f"[TEST] {name:<45} ❌ — Beklenen: {expected_substring}, Gelen: {actual}")
+        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": "lorem ipsum"}, headers=headers)
+        assert_test("LLM fallback", r.json(), "Bu konuda maalesef bilgim yok")
+        # 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(), "bir döviz cinsi")
+        # 4. Parametre tamamlanması
+        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. 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(), "hangi şehir")
+        # 6. Parametre tamamlanması — 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")
+        # 7. Konu değişikliği testi
+        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")
+        # 8. Geçersiz parametre — doviz
+        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")
+        summarize_tests()
+    except Exception as e:
+        log(f"❌ run_all_tests sırasında hata oluştu: {e}")

llm_model.py ADDED Viewed

	@@ -0,0 +1,70 @@

+import torch, traceback
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification
+import log
+from pydantic import BaseModel
+global model, tokenizer, eos_token_id
+model = None
+tokenizer = None
+eos_token_id = None
+class Message(BaseModel):
+    user_input: str
+def setup_model(app_config):
+    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(app_config.MODEL_BASE, use_fast=False)
+        log("📦 Tokenizer yüklendi. Ana model indiriliyor...")
+        model = AutoModelForCausalLM.from_pretrained(app_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: {app_config.INTENT_MODEL_ID}")
+        _ = AutoTokenizer.from_pretrained(app_config.INTENT_MODEL_ID)
+        _ = AutoModelForSequenceClassification.from_pretrained(app_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):
+    messages = [{"role": "user", "content": text}]
+    encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
+    eos_token = tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
+    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,
+            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

log.py ADDED Viewed

	@@ -0,0 +1,5 @@

+from datetime import datetime
+def log(message):
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    print(f"[{timestamp}] {message}", flush=True)

requirements.txt ADDED Viewed

	@@ -0,0 +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
+pyarrow==15.0.2