Deploy Ollama cyber security assistant

.dockerignore

@@ -0,0 +1,13 @@
+.git
+.gitignore
+.env
+.env.*
+!.env.example
+.venv
+__pycache__
+*.py[cod]
+.pytest_cache
+.ruff_cache
+.coverage
+tests
+uv.lock

.env.example

@@ -0,0 +1,23 @@
+# Yerel Ollama
+OLLAMA_BASE_URL=http://127.0.0.1:11434
+OLLAMA_MODEL=qwen3.6:latest
+OLLAMA_TIMEOUT_SECONDS=300
+OLLAMA_NUM_CTX=16384
+OLLAMA_TEMPERATURE=0.2
+# Yalnızca kimlik doğrulayan uzak bir Ollama geçidi kullanılıyorsa:
+# OLLAMA_API_KEY=
+
+# Harici veri kaynaklarının ağ toleransı ve haber önbelleği
+CYBER_API_CONNECT_TIMEOUT=20
+CYBER_API_READ_TIMEOUT=60
+GDELT_CONNECT_TIMEOUT=30
+GDELT_READ_TIMEOUT=75
+CYBER_NEWS_CACHE_SECONDS=300
+
+# İsteğe bağlı veri kaynakları
+# NEWSAPI_KEY=
+# NVD_API_KEY=
+# OTX_API_KEY=
+# MISP_BASE_URL=https://misp.example.org
+# MISP_API_KEY=
+# MISP_VERIFY_TLS=true

.gitignore

@@ -0,0 +1,7 @@
+.env
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.coverage

.python-version

@@ -0,0 +1 @@
+3.11

Dockerfile

@@ -0,0 +1,46 @@
+FROM ollama/ollama:latest
+
+# Ollama imajındaki varsayılan entrypoint, verilen her komutu `ollama ...`
+# olarak çalıştırır. Space başlangıç betiğini doğrudan çalıştırabilmek için sıfırla.
+ENTRYPOINT []
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/opt/venv/bin:${PATH}" \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_SERVER_PORT=7860 \
+    OLLAMA_BASE_URL=http://127.0.0.1:11434 \
+    OLLAMA_HOST=127.0.0.1:11434 \
+    OLLAMA_MODEL=qwen3.6:latest \
+    OLLAMA_NUM_PARALLEL=1 \
+    OLLAMA_MAX_LOADED_MODELS=1
+
+RUN apt-get update \
+    && apt-get install --yes --no-install-recommends \
+        python3 \
+        python3-pip \
+        python3-venv \
+        ca-certificates \
+    && python3 -m venv /opt/venv \
+    && /opt/venv/bin/pip install --no-cache-dir --upgrade pip \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN /opt/venv/bin/pip install --no-cache-dir -r /app/requirements.txt
+
+# Güncel Ollama image'ında UID 1000, `ubuntu` kullanıcısı olarak hazır gelir.
+RUN mkdir -p /home/ubuntu/.ollama \
+    && chown -R ubuntu:ubuntu /home/ubuntu /app
+
+COPY --chown=ubuntu:ubuntu . /app
+RUN chmod +x /app/start.sh
+
+USER ubuntu
+ENV HOME=/home/ubuntu
+
+EXPOSE 7860
+
+CMD ["/app/start.sh"]

README.md

@@ -1,12 +1,199 @@
 ---
-title: CI Assistani
-emoji: ⚡
-colorFrom: gray
-colorTo: green
+title: Siber Güvenlik Haber Asistanı
+emoji: 🛡️
+colorFrom: blue
+colorTo: indigo
 sdk: docker
-pinned: false
-license: mit
-short_description: Cyber Inteligence için küçük bir model
+app_port: 7860
+fullWidth: true
+short_description: Ollama ve araç çağrılarıyla güncel CVE ve siber güvenlik haberleri
+tags:
+  - ollama
+  - cybersecurity
+  - tool-calling
+  - cve
+  - turkish
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Siber Güvenlik Haber Asistanı
+
+Yerel bir Ollama modelinin güncel siber güvenlik kaynaklarını araç çağrılarıyla
+sorguladığı Türkçe Gradio uygulaması. Arayüz; modelin çağırdığı aracı,
+parametrelerini, dönen sonucu, tur numarasını ve nihai yanıtı ayrı ayrı gösterir.
+Modelin gizli düşünce metni gösterilmez.
+
+## Veri kaynakları
+
+Anahtarsız kullanılabilen kaynaklar:
+
+- GDELT — güncel haber araması
+- CISA KEV — aktif istismar edildiği bilinen zafiyetler
+- NIST NVD — CVE arama ve ayrıntıları
+- CISA RSS ve CERT/CC Atom — resmi güvenlik duyuruları
+- MITRE ATT&CK TAXII 2.1 — Enterprise teknikleri
+
+İsteğe bağlı kaynaklar:
+
+- NewsAPI (`NEWSAPI_KEY`)
+- AlienVault OTX (`OTX_API_KEY`)
+- NVD yüksek istek limiti (`NVD_API_KEY`)
+- Kurumsal MISP (`MISP_BASE_URL`, `MISP_API_KEY`)
+
+API anahtarları hiçbir zaman kaynak koda veya model mesajına eklenmez; yalnızca
+sunucu tarafındaki ortam değişkenlerinden okunur.
+
+## Yerel çalıştırma
+
+Gereksinimler:
+
+- Python 3.11+
+- Çalışan bir [Ollama](https://docs.ollama.com/) sunucusu
+- Araç çağrısını destekleyen bir Ollama modeli
+
+```bash
+ollama serve
+ollama pull qwen3.6:latest
+cp .env.example .env
+uv sync
+uv run python app.py
+```
+
+`uv` kullanmıyorsanız:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+python app.py
+```
+
+Uygulama varsayılan olarak `http://127.0.0.1:11434` ve
+`qwen3.6:latest` kullanır. Ayarlar kabuktan verilebilir:
+
+```bash
+export OLLAMA_MODEL=qwen3.6:latest
+export NEWSAPI_KEY=...
+export NVD_API_KEY=...
+python app.py
+```
+
+`.env` dosyası örnek amaçlıdır; Python uygulaması bu dosyayı kendiliğinden
+yüklemez. Değerleri kabuğa aktarın veya dağıtım platformunun secret yönetimini
+kullanın.
+
+## Çalışma biçimi
+
+Örnek soru:
+
+> Son 7 günde yayımlanan kritik CVE'leri bul ve aktif istismar durumlarını kontrol et.
+
+Beklenen akış:
+
+1. Model `son_cve_kayitlarini_getir` aracını çağırır.
+2. Dönen CVE'lerden gerekli gördükleri için `cve_detayi_getir` veya
+   `aktif_istismar_edilenleri_ara` çağrısını yapar.
+3. Arayüz her çağrıyı ve sonucu tur bazında gösterir.
+4. Model, tarih ve kaynak bağlantıları içeren Türkçe nihai yanıtı üretir.
+
+Model en fazla altı araç turu çalıştırabilir. Bu sınır hatalı veya sonsuz araç
+döngülerini engeller.
+
+## Yapılandırma
+
+| Değişken | Varsayılan | Açıklama |
+|---|---:|---|
+| `OLLAMA_BASE_URL` | `http://127.0.0.1:11434` | Ollama veya uyumlu güvenli geçit |
+| `OLLAMA_MODEL` | `qwen3.6:latest` | Kullanılacak model |
+| `OLLAMA_API_KEY` | boş | Uzak geçit için Bearer anahtarı |
+| `OLLAMA_TIMEOUT_SECONDS` | `300` | Model yanıt zaman aşımı |
+| `OLLAMA_NUM_CTX` | `16384` | Bağlam penceresi |
+| `OLLAMA_TEMPERATURE` | `0.2` | Üretim sıcaklığı |
+| `CYBER_API_CONNECT_TIMEOUT` | `20` | Genel API bağlantı zaman aşımı |
+| `CYBER_API_READ_TIMEOUT` | `60` | Genel API okuma zaman aşımı |
+| `GDELT_CONNECT_TIMEOUT` | `30` | GDELT için bağlantı zaman aşımı |
+| `GDELT_READ_TIMEOUT` | `75` | GDELT için okuma zaman aşımı |
+| `CYBER_NEWS_CACHE_SECONDS` | `300` | Aynı haber sorgusunun önbellek süresi |
+| `NEWSAPI_KEY` | boş | NewsAPI erişimi |
+| `NVD_API_KEY` | boş | Daha yüksek NVD istek limiti |
+| `OTX_API_KEY` | boş | AlienVault OTX erişimi |
+| `MISP_BASE_URL` | boş | Kurumsal MISP kök adresi |
+| `MISP_API_KEY` | boş | MISP erişim anahtarı |
+| `MISP_VERIFY_TLS` | `true` | MISP TLS sertifika doğrulaması |
+
+## Hugging Face Docker Space
+
+Depo, Ollama ile Gradio'yu aynı container içinde çalıştıran Docker Space düzenine
+hazırdır. `start.sh` önce Ollama'yı başlatır, `OLLAMA_MODEL` ile seçilen modeli
+indirir ve ardından Gradio'yu `0.0.0.0:7860` üzerinde açar. Yalnızca Gradio portu
+dışarı açılır; Ollama container içinde `127.0.0.1:11434` adresinde kalır.
+
+Space oluşturma ve yükleme örneği:
+
+```bash
+hf auth login --add-to-git-credential
+hf repos create KULLANICI_ADI/siber-guvenlik-asistani --repo-type space --sdk docker
+git remote add space https://huggingface.co/spaces/KULLANICI_ADI/siber-guvenlik-asistani
+git push space main
+```
+
+Space secret değerlerini Hugging Face web arayüzündeki **Settings → Variables and
+secrets** bölümünden ekleyin. Her push sonrasında Space otomatik olarak yeniden
+oluşturulur.
+
+Önerilen Space değişkenleri:
+
+```text
+OLLAMA_MODEL=qwen3.6:latest
+OLLAMA_NUM_CTX=16384
+```
+
+`NEWSAPI_KEY`, `NVD_API_KEY`, `OTX_API_KEY` ve MISP erişim bilgilerini yalnızca
+Space secret olarak ekleyin. Bunları Dockerfile'a veya Git deposuna yazmayın.
+
+`qwen3.6:latest` yaklaşık 24 GB'tır. Model ağırlıkları ile çalışma belleğine yer
+kalması için 48 GB VRAM'li bir GPU güvenli tercihtir. Daha küçük donanım ve daha
+düşük maliyet için örneğin `OLLAMA_MODEL=qwen3.5:9b` kullanılabilir.
+
+Space diski geçiciyse model her yeniden oluşturmada tekrar indirilir. Bir Storage
+Bucket `/data` yoluna bağlanırsa Space değişkenini aşağıdaki gibi ayarlayarak model
+önbelleği kalıcı tutulabilir:
+
+```text
+OLLAMA_MODELS=/data/ollama-models
+```
+
+### Docker'ı yerelde sınama
+
+CPU ile yalnızca container başlangıcını sınamak için:
+
+```bash
+docker build -t siber-guvenlik-asistani .
+docker run --rm -p 7860:7860 \
+  -e OLLAMA_MODEL=qwen3.5:4b \
+  siber-guvenlik-asistani
+```
+
+NVIDIA Container Toolkit kurulu bir makinede GPU ile:
+
+```bash
+docker run --rm --gpus all -p 7860:7860 \
+  -e OLLAMA_MODEL=qwen3.6:latest \
+  siber-guvenlik-asistani
+```
+
+## Testler
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+Testler gerçek API veya Ollama bağlantısı kurmadan araç şemalarını, CVE
+normalizasyonunu ve çok turlu araç döngüsünü doğrular.
+
+## Güvenlik ve doğruluk
+
+- Uygulama savunma ve haber analizi amaçlıdır.
+- Güncel veri kaynakları gecikebilir veya geçici olarak hata verebilir.
+- CVSS puanı tek başına aktif istismar kanıtı değildir; KEV durumu ayrıca gösterilir.
+- Kritik operasyonel kararlar özgün CISA, NVD, CERT/CC veya üretici duyurusundan
+  doğrulanmalıdır.

app.py

@@ -0,0 +1,233 @@
+"""Gradio arayüzü ve Hugging Face Spaces giriş noktası."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import gradio as gr
+
+from ollama import OllamaLocalModelManagement
+
+
+MODEL = OllamaLocalModelManagement()
+
+CSS = """
+.gradio-container { max-width: 1120px !important; }
+.hero { text-align: center; margin: 0 auto 1rem; }
+.hero h1 { margin-bottom: .35rem; }
+.hero p { color: var(--body-text-color-subdued); }
+.status-card { border: 1px solid var(--border-color-primary); border-radius: 12px;
+               padding: 12px 16px; background: var(--background-fill-secondary); }
+"""
+
+
+def _json_block(value: Any, max_chars: int = 14_000) -> str:
+    text = json.dumps(value, ensure_ascii=False, indent=2, default=str)
+    if len(text) > max_chars:
+        text = f"{text[:max_chars]}\n… (arayüz için kısaltıldı)"
+    return f"```json\n{text}\n```"
+
+
+def _tool_message(event: dict[str, Any]) -> dict[str, Any]:
+    name = event["name"]
+    content = (
+        f"**Çağrı**\n\n`{name}`\n\n"
+        f"**Parametreler**\n\n{_json_block(event['arguments'])}\n\n"
+        f"**Sonuç**\n\n{_json_block(event['result'])}"
+    )
+    return {
+        "role": "assistant",
+        "content": content,
+        "metadata": {
+            "title": f"🛠️ Tur {event['turn']} · {name}",
+            "duration": event["duration_seconds"],
+            "status": "done",
+        },
+    }
+
+
+def respond(
+    message: str,
+    display_history: list[dict[str, Any]] | None,
+    conversation: list[dict[str, str]] | None,
+):
+    """Kullanıcı sorusunu işle ve her araç eyleminden sonra arayüzü güncelle."""
+    display = list(display_history or [])
+    state = list(conversation or [])
+    if not message or not message.strip():
+        yield "", display, state
+        return
+
+    user_text = message.strip()
+    display.append({"role": "user", "content": user_text})
+    yield "", display, state
+
+    final_text: str | None = None
+    for event in MODEL.run(user_text, state):
+        if event["type"] == "tool":
+            display.append(_tool_message(event))
+        elif event["type"] == "note":
+            display.append(
+                {
+                    "role": "assistant",
+                    "content": event["content"],
+                    "metadata": {
+                        "title": f"ℹ️ Tur {event['turn']} · Model notu",
+                        "status": "done",
+                    },
+                }
+            )
+        elif event["type"] == "final":
+            final_text = event["content"]
+            metrics = event.get("metrics", {})
+            metric_text = " · ".join(
+                part
+                for part in [
+                    f"girdi: {metrics.get('prompt_tokens')} token"
+                    if metrics.get("prompt_tokens") is not None
+                    else "",
+                    f"çıktı: {metrics.get('response_tokens')} token"
+                    if metrics.get("response_tokens") is not None
+                    else "",
+                    f"{metrics.get('total_duration_seconds')} sn"
+                    if metrics.get("total_duration_seconds")
+                    else "",
+                ]
+                if part
+            )
+            display.append(
+                {
+                    "role": "assistant",
+                    "content": final_text,
+                    "metadata": (
+                        {"title": f"✅ Nihai yanıt · Tur {event['turn']}", "log": metric_text}
+                        if metric_text
+                        else {"title": f"✅ Nihai yanıt · Tur {event['turn']}"}
+                    ),
+                }
+            )
+        elif event["type"] == "error":
+            final_text = f"⚠️ {event['content']}"
+            display.append(
+                {
+                    "role": "assistant",
+                    "content": final_text,
+                    "metadata": {"title": "Hata", "status": "done"},
+                }
+            )
+        yield "", display, state
+
+    if final_text:
+        state.extend(
+            [
+                {"role": "user", "content": user_text},
+                {"role": "assistant", "content": final_text},
+            ]
+        )
+        state = state[-20:]
+    yield "", display, state
+
+
+def clear_chat():
+    return [], []
+
+
+def configuration_text() -> str:
+    optional = {
+        "NewsAPI": bool(os.getenv("NEWSAPI_KEY")),
+        "NVD API anahtarı": bool(os.getenv("NVD_API_KEY")),
+        "AlienVault OTX": bool(os.getenv("OTX_API_KEY")),
+        "MISP": bool(os.getenv("MISP_BASE_URL") and os.getenv("MISP_API_KEY")),
+    }
+    lines = [
+        f"**Model:** `{MODEL.model_name}`",
+        f"**Ollama:** `{MODEL.base_url}`",
+        "**Anahtarsız kaynaklar:** GDELT, CISA KEV, NVD, CISA RSS, CERT/CC, MITRE ATT&CK",
+        "**İsteğe bağlı kaynaklar:** "
+        + ", ".join(f"{name} {'✅' if enabled else '—'}" for name, enabled in optional.items()),
+    ]
+    return "\n\n".join(lines)
+
+
+with gr.Blocks(title="Siber Güvenlik Haber Asistanı") as demo:
+    gr.HTML(
+        """
+        <div class="hero">
+          <h1>🛡️ Siber Güvenlik Haber Asistanı</h1>
+          <p>Yerel Ollama modeli · Güncel CVE, KEV, haber ve tehdit istihbaratı</p>
+        </div>
+        """
+    )
+    conversation_state = gr.State([])
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(
+                height=650,
+                layout="panel",
+                placeholder=(
+                    "Bir soru sorun. Modelin yaptığı araç çağrıları ve aldığı sonuçlar "
+                    "burada adım adım görünecek."
+                ),
+                show_label=False,
+                buttons=["copy", "copy_all"],
+            )
+            with gr.Row():
+                prompt = gr.Textbox(
+                    placeholder="Örn. Son 24 saatteki önemli siber güvenlik haberleri neler?",
+                    show_label=False,
+                    lines=2,
+                    max_lines=6,
+                    scale=8,
+                )
+                send = gr.Button("Gönder", variant="primary", scale=1)
+            clear = gr.Button("Sohbeti temizle", variant="secondary")
+        with gr.Column(scale=1, min_width=260):
+            gr.Markdown("### Yapılandırma")
+            gr.Markdown(configuration_text(), elem_classes=["status-card"])
+            gr.Markdown(
+                """
+                ### Örnek sorular
+
+                - Son 24 saatteki önemli fidye yazılımı haberlerini özetle.
+                - Son 7 günde yayımlanan kritik CVE'leri bul ve KEV durumlarını kontrol et.
+                - CVE-2025-XXXX hakkında ne biliniyor?
+                - Credential dumping için MITRE ATT&CK tekniklerini getir.
+
+                > Kaynak sonuçları güncel olsa da kritik kararları özgün kaynaklardan doğrulayın.
+                """
+            )
+
+    submit_event = prompt.submit(
+        respond,
+        inputs=[prompt, chatbot, conversation_state],
+        outputs=[prompt, chatbot, conversation_state],
+        api_name="sor",
+    )
+    send.click(
+        respond,
+        inputs=[prompt, chatbot, conversation_state],
+        outputs=[prompt, chatbot, conversation_state],
+        api_name=False,
+    )
+    clear.click(
+        clear_chat,
+        outputs=[chatbot, conversation_state],
+        api_name=False,
+        cancels=[submit_event],
+    )
+
+
+def launch_demo() -> None:
+    """Yerel ve Docker Space ortamlarında Gradio sunucusunu başlat."""
+    demo.queue(default_concurrency_limit=4).launch(
+        css=CSS,
+        theme=gr.themes.Soft(),
+        server_name=os.getenv("GRADIO_SERVER_NAME", "127.0.0.1"),
+        server_port=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
+    )
+
+
+if __name__ == "__main__":
+    launch_demo()

main.py

@@ -0,0 +1,7 @@
+"""Yerel çalıştırma giriş noktası."""
+
+from app import launch_demo
+
+
+if __name__ == "__main__":
+    launch_demo()

ollama/__init__.py

@@ -0,0 +1,5 @@
+"""Yerel Ollama siber güvenlik asistanı."""
+
+from .ollama_local_model_managment_code import OllamaLocalModelManagement
+
+__all__ = ["OllamaLocalModelManagement"]

ollama/cyber_security_tools.py

@@ -0,0 +1,673 @@
+"""Siber güvenlik veri kaynakları ve Ollama araç şemaları."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from datetime import UTC, datetime, timedelta
+from typing import Any
+from urllib.parse import urljoin
+from xml.etree import ElementTree
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+USER_AGENT = "SiberGuvenlikAsistani/1.0"
+CVE_PATTERN = re.compile(r"^CVE-\d{4}-\d{4,}$", re.IGNORECASE)
+
+
+def _clamp(value: int, lower: int = 1, upper: int = 50) -> int:
+    return max(lower, min(int(value), upper))
+
+
+def _compact(value: Any, limit: int = 700) -> str:
+    text = re.sub(r"\s+", " ", str(value or "")).strip()
+    return text if len(text) <= limit else f"{text[: limit - 1]}…"
+
+
+class CyberSecurityTools:
+    """Harici kaynakları küçük, modele uygun JSON sonuçlarına dönüştürür."""
+
+    def __init__(self, session: requests.Session | None = None) -> None:
+        self.session = session or requests.Session()
+        self.session.headers.update({"User-Agent": USER_AGENT})
+        retry = Retry(
+            total=2,
+            connect=2,
+            read=1,
+            status=2,
+            backoff_factor=3,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=frozenset({"GET"}),
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        self.session.mount("https://", HTTPAdapter(max_retries=retry))
+        self.session.mount("http://", HTTPAdapter(max_retries=retry))
+        self._news_cache: dict[tuple[str, int, int], tuple[float, dict[str, Any]]] = {}
+
+    @property
+    def schemas(self) -> list[dict[str, Any]]:
+        return [
+            self._schema(
+                "siber_haberlerini_ara",
+                "GDELT ve yapılandırılmışsa NewsAPI üzerinde güncel "
+                "siber güvenlik haberlerini ara.",
+                {
+                    "sorgu": {
+                        "type": "string",
+                        "description": "Örn. ransomware, veri ihlali veya belirli bir şirket.",
+                    },
+                    "son_saat": {
+                        "type": "integer",
+                        "description": "Kaç saat geriye gidileceği (1-168).",
+                        "default": 24,
+                    },
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Döndürülecek en fazla sonuç (1-20).",
+                        "default": 10,
+                    },
+                },
+                ["sorgu"],
+            ),
+            self._schema(
+                "son_cve_kayitlarini_getir",
+                "NVD'den yakın zamanda yayımlanan CVE kayıtlarını getir; "
+                "anahtar kelimeyle daraltılabilir.",
+                {
+                    "son_gun": {
+                        "type": "integer",
+                        "description": "Kaç gün geriye gidileceği (1-120).",
+                        "default": 7,
+                    },
+                    "anahtar_kelime": {
+                        "type": "string",
+                        "description": "İsteğe bağlı ürün, üretici veya zafiyet anahtar kelimesi.",
+                        "default": "",
+                    },
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Döndürülecek en fazla sonuç (1-20).",
+                        "default": 10,
+                    },
+                },
+            ),
+            self._schema(
+                "cve_detayi_getir",
+                "Bir CVE'yi NVD, CISA KEV ve yapılandırılmışsa OTX verileriyle ayrıntılandır.",
+                {
+                    "cve_id": {
+                        "type": "string",
+                        "description": "CVE-2025-12345 biçimindeki kimlik.",
+                    }
+                },
+                ["cve_id"],
+            ),
+            self._schema(
+                "aktif_istismar_edilenleri_ara",
+                "CISA Known Exploited Vulnerabilities (KEV) kataloğunda "
+                "aktif istismar edilen CVE'leri ara.",
+                {
+                    "sorgu": {
+                        "type": "string",
+                        "description": "CVE, üretici veya ürün; boş bırakılırsa en yeni kayıtlar.",
+                        "default": "",
+                    },
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Döndürülecek en fazla sonuç (1-20).",
+                        "default": 10,
+                    },
+                },
+            ),
+            self._schema(
+                "guvenlik_duyurularini_getir",
+                "CISA ve CERT/CC kaynaklarındaki en güncel güvenlik duyurularını getir.",
+                {
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Her kaynaktan alınacak en fazla sonuç (1-20).",
+                        "default": 8,
+                    }
+                },
+            ),
+            self._schema(
+                "tehdit_istihbarati_ara",
+                "Yapılandırılmış AlienVault OTX ve MISP kaynaklarında tehdit istihbaratı ara.",
+                {
+                    "sorgu": {
+                        "type": "string",
+                        "description": (
+                            "Tehdit aktörü, zararlı yazılım, CVE, alan adı veya kampanya."
+                        ),
+                    },
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Döndürülecek en fazla sonuç (1-20).",
+                        "default": 10,
+                    },
+                },
+                ["sorgu"],
+            ),
+            self._schema(
+                "mitre_attack_tekniklerini_ara",
+                "MITRE ATT&CK Enterprise koleksiyonunda teknik adı, "
+                "açıklaması veya kimliğiyle ara.",
+                {
+                    "sorgu": {
+                        "type": "string",
+                        "description": "Örn. phishing, credential dumping veya T1059.",
+                    },
+                    "sonuc_sayisi": {
+                        "type": "integer",
+                        "description": "Döndürülecek en fazla sonuç (1-20).",
+                        "default": 10,
+                    },
+                },
+                ["sorgu"],
+            ),
+        ]
+
+    @property
+    def available_functions(self) -> dict[str, Any]:
+        return {
+            "siber_haberlerini_ara": self.siber_haberlerini_ara,
+            "son_cve_kayitlarini_getir": self.son_cve_kayitlarini_getir,
+            "cve_detayi_getir": self.cve_detayi_getir,
+            "aktif_istismar_edilenleri_ara": self.aktif_istismar_edilenleri_ara,
+            "guvenlik_duyurularini_getir": self.guvenlik_duyurularini_getir,
+            "tehdit_istihbarati_ara": self.tehdit_istihbarati_ara,
+            "mitre_attack_tekniklerini_ara": self.mitre_attack_tekniklerini_ara,
+        }
+
+    @staticmethod
+    def _schema(
+        name: str,
+        description: str,
+        properties: dict[str, Any],
+        required: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": description,
+                "parameters": {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required or [],
+                },
+            },
+        }
+
+    @staticmethod
+    def _default_timeout() -> tuple[int, int]:
+        return (
+            int(os.getenv("CYBER_API_CONNECT_TIMEOUT", "20")),
+            int(os.getenv("CYBER_API_READ_TIMEOUT", "60")),
+        )
+
+    def _get(
+        self, url: str, timeout: tuple[int, int] | None = None, **kwargs: Any
+    ) -> requests.Response:
+        response = self.session.get(
+            url, timeout=timeout or self._default_timeout(), **kwargs
+        )
+        response.raise_for_status()
+        return response
+
+    def _post(self, url: str, **kwargs: Any) -> requests.Response:
+        response = self.session.post(
+            url, timeout=self._default_timeout(), **kwargs
+        )
+        response.raise_for_status()
+        return response
+
+    @staticmethod
+    def _error(source: str, exc: Exception) -> dict[str, Any]:
+        return {"kaynak": source, "hata": _compact(exc, 300)}
+
+    def siber_haberlerini_ara(
+        self, sorgu: str, son_saat: int = 24, sonuc_sayisi: int = 10
+    ) -> dict[str, Any]:
+        limit = _clamp(sonuc_sayisi, upper=20)
+        hours = _clamp(son_saat, upper=168)
+        query = sorgu.strip() or "cybersecurity"
+        cache_key = (query.casefold(), hours, limit)
+        cached = self._news_cache.get(cache_key)
+        cache_seconds = int(os.getenv("CYBER_NEWS_CACHE_SECONDS", "300"))
+        if cached and time.monotonic() - cached[0] < cache_seconds:
+            return {**cached[1], "onbellekten": True}
+
+        results: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+
+        try:
+            data = self._get(
+                "https://api.gdeltproject.org/api/v2/doc/doc",
+                timeout=(
+                    int(os.getenv("GDELT_CONNECT_TIMEOUT", "30")),
+                    int(os.getenv("GDELT_READ_TIMEOUT", "75")),
+                ),
+                params={
+                    "query": query,
+                    "mode": "ArtList",
+                    "format": "json",
+                    "maxrecords": limit,
+                    "sort": "DateDesc",
+                    "timespan": f"{hours}h",
+                },
+            ).json()
+            for article in data.get("articles", [])[:limit]:
+                results.append(
+                    {
+                        "kaynak": "GDELT",
+                        "baslik": _compact(article.get("title"), 250),
+                        "yayinci": article.get("domain"),
+                        "tarih": article.get("seendate"),
+                        "dil": article.get("language"),
+                        "url": article.get("url"),
+                    }
+                )
+        except (requests.RequestException, ValueError) as exc:
+            errors.append(self._error("GDELT", exc))
+
+        news_key = os.getenv("NEWSAPI_KEY")
+        if news_key:
+            try:
+                data = self._get(
+                    "https://newsapi.org/v2/everything",
+                    headers={"X-Api-Key": news_key},
+                    params={
+                        "q": query,
+                        "language": "en",
+                        "sortBy": "publishedAt",
+                        "pageSize": limit,
+                    },
+                ).json()
+                if data.get("status") == "error":
+                    raise ValueError(data.get("message", "NewsAPI hatası"))
+                for article in data.get("articles", [])[:limit]:
+                    results.append(
+                        {
+                            "kaynak": "NewsAPI",
+                            "baslik": _compact(article.get("title"), 250),
+                            "yayinci": (article.get("source") or {}).get("name"),
+                            "tarih": article.get("publishedAt"),
+                            "ozet": _compact(article.get("description"), 400),
+                            "url": article.get("url"),
+                        }
+                    )
+            except (requests.RequestException, ValueError) as exc:
+                errors.append(self._error("NewsAPI", exc))
+
+        results.sort(key=lambda item: item.get("tarih") or "", reverse=True)
+        response_data = {
+            "sorgu": query,
+            "zaman_araligi_saat": hours,
+            "sonuclar": results[:limit],
+            "hatalar": errors,
+            "not": None if news_key else "NEWSAPI_KEY tanımlı olmadığı için NewsAPI atlandı.",
+        }
+        if not results:
+            response_data["alternatif_resmi_duyurular"] = self.guvenlik_duyurularini_getir(
+                min(limit, 8)
+            )
+            response_data["uyari"] = (
+                "Haber kaynakları sonuç vermedi. Aşağıdaki kayıtlar haber değil, "
+                "CISA ve CERT/CC resmi güvenlik duyurularıdır."
+            )
+        else:
+            self._news_cache[cache_key] = (time.monotonic(), response_data)
+        return response_data
+
+    def son_cve_kayitlarini_getir(
+        self, son_gun: int = 7, anahtar_kelime: str = "", sonuc_sayisi: int = 10
+    ) -> dict[str, Any]:
+        days = _clamp(son_gun, upper=120)
+        limit = _clamp(sonuc_sayisi, upper=20)
+        end = datetime.now(UTC)
+        start = end - timedelta(days=days)
+        params: dict[str, Any] = {
+            "pubStartDate": start.isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+            "pubEndDate": end.isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+            "resultsPerPage": limit,
+        }
+        if anahtar_kelime.strip():
+            params["keywordSearch"] = anahtar_kelime.strip()
+        try:
+            data = self._get(
+                "https://services.nvd.nist.gov/rest/json/cves/2.0",
+                headers=self._nvd_headers(),
+                params=params,
+            ).json()
+            return {
+                "kaynak": "NVD",
+                "sorgu_zamani_utc": end.isoformat(),
+                "toplam_eslesme": data.get("totalResults", 0),
+                "sonuclar": [
+                    self._normalize_nvd(item.get("cve", {}))
+                    for item in data.get("vulnerabilities", [])[:limit]
+                ],
+            }
+        except (requests.RequestException, ValueError) as exc:
+            return self._error("NVD", exc)
+
+    def cve_detayi_getir(self, cve_id: str) -> dict[str, Any]:
+        cve = cve_id.strip().upper()
+        if not CVE_PATTERN.fullmatch(cve):
+            return {"hata": "Geçersiz CVE kimliği.", "beklenen_bicim": "CVE-YYYY-NNNN"}
+        result: dict[str, Any] = {"cve_id": cve}
+        try:
+            data = self._get(
+                "https://services.nvd.nist.gov/rest/json/cves/2.0",
+                headers=self._nvd_headers(),
+                params={"cveId": cve},
+            ).json()
+            items = data.get("vulnerabilities", [])
+            result["nvd"] = (
+                self._normalize_nvd(items[0].get("cve", {}))
+                if items
+                else {"bulundu": False}
+            )
+        except (requests.RequestException, ValueError) as exc:
+            result["nvd"] = self._error("NVD", exc)
+
+        kev = self.aktif_istismar_edilenleri_ara(cve, 1)
+        result["cisa_kev"] = (kev.get("sonuclar") or [{"bulundu": False}])[0]
+
+        otx_key = os.getenv("OTX_API_KEY")
+        if otx_key:
+            try:
+                data = self._get(
+                    f"https://otx.alienvault.com/api/v1/indicators/cve/{cve}/general",
+                    headers={"X-OTX-API-KEY": otx_key},
+                ).json()
+                result["otx"] = {
+                    "pulse_sayisi": (data.get("pulse_info") or {}).get("count", 0),
+                    "pulses": [
+                        {
+                            "ad": _compact(pulse.get("name"), 250),
+                            "olusturulma": pulse.get("created"),
+                            "degistirilme": pulse.get("modified"),
+                            "etiketler": pulse.get("tags", [])[:12],
+                        }
+                        for pulse in (data.get("pulse_info") or {}).get("pulses", [])[:5]
+                    ],
+                }
+            except (requests.RequestException, ValueError) as exc:
+                result["otx"] = self._error("AlienVault OTX", exc)
+        else:
+            result["otx"] = {"not": "OTX_API_KEY tanımlı değil; OTX sorgusu atlandı."}
+        return result
+
+    def aktif_istismar_edilenleri_ara(
+        self, sorgu: str = "", sonuc_sayisi: int = 10
+    ) -> dict[str, Any]:
+        limit = _clamp(sonuc_sayisi, upper=20)
+        try:
+            data = self._get(
+                "https://www.cisa.gov/sites/default/files/feeds/"
+                "known_exploited_vulnerabilities.json"
+            ).json()
+            needle = sorgu.casefold().strip()
+            matches = []
+            for item in data.get("vulnerabilities", []):
+                haystack = " ".join(
+                    str(item.get(key, ""))
+                    for key in ("cveID", "vendorProject", "product", "vulnerabilityName")
+                ).casefold()
+                if needle and needle not in haystack:
+                    continue
+                matches.append(
+                    {
+                        "cve_id": item.get("cveID"),
+                        "uretici": item.get("vendorProject"),
+                        "urun": item.get("product"),
+                        "zafiyet": item.get("vulnerabilityName"),
+                        "kataloga_eklenme": item.get("dateAdded"),
+                        "aksiyon_son_tarihi": item.get("dueDate"),
+                        "bilinen_fidye_yazilimi_kullanimi": item.get(
+                            "knownRansomwareCampaignUse"
+                        ),
+                        "gerekli_aksiyon": _compact(item.get("requiredAction"), 400),
+                        "notlar": _compact(item.get("notes"), 400),
+                    }
+                )
+            matches.sort(key=lambda item: item.get("kataloga_eklenme") or "", reverse=True)
+            return {
+                "kaynak": "CISA KEV",
+                "katalog_surumu": data.get("version"),
+                "katalog_tarihi": data.get("dateReleased"),
+                "sonuclar": matches[:limit],
+            }
+        except (requests.RequestException, ValueError) as exc:
+            return self._error("CISA KEV", exc)
+
+    def guvenlik_duyurularini_getir(self, sonuc_sayisi: int = 8) -> dict[str, Any]:
+        limit = _clamp(sonuc_sayisi, upper=20)
+        sources = [
+            ("CISA", "https://www.cisa.gov/cybersecurity-advisories/all.xml"),
+            ("CERT/CC", "https://www.kb.cert.org/vuls/atomfeed/"),
+        ]
+        results: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+        for source, url in sources:
+            try:
+                root = ElementTree.fromstring(self._get(url).content)
+                entries = root.findall(".//item") or root.findall(
+                    ".//{http://www.w3.org/2005/Atom}entry"
+                )
+                for entry in entries[:limit]:
+                    title = self._xml_text(entry, "title")
+                    published = (
+                        self._xml_text(entry, "pubDate")
+                        or self._xml_text(entry, "updated")
+                        or self._xml_text(entry, "published")
+                    )
+                    link = self._xml_text(entry, "link")
+                    if not link:
+                        link_node = entry.find("{http://www.w3.org/2005/Atom}link")
+                        link = link_node.get("href") if link_node is not None else None
+                    results.append(
+                        {
+                            "kaynak": source,
+                            "baslik": _compact(title, 250),
+                            "tarih": published,
+                            "url": link,
+                        }
+                    )
+            except (requests.RequestException, ElementTree.ParseError) as exc:
+                errors.append(self._error(source, exc))
+        return {"sonuclar": results, "hatalar": errors}
+
+    def tehdit_istihbarati_ara(
+        self, sorgu: str, sonuc_sayisi: int = 10
+    ) -> dict[str, Any]:
+        query = sorgu.strip()
+        if not query:
+            return {"hata": "Sorgu boş olamaz."}
+        limit = _clamp(sonuc_sayisi, upper=20)
+        results: dict[str, Any] = {}
+
+        otx_key = os.getenv("OTX_API_KEY")
+        if otx_key:
+            try:
+                data = self._get(
+                    "https://otx.alienvault.com/api/v1/search/pulses",
+                    headers={"X-OTX-API-KEY": otx_key},
+                    params={"q": query, "sort": "modified", "limit": limit},
+                ).json()
+                results["otx"] = [
+                    {
+                        "id": item.get("id"),
+                        "ad": _compact(item.get("name"), 250),
+                        "aciklama": _compact(item.get("description"), 500),
+                        "degistirilme": item.get("modified"),
+                        "etiketler": item.get("tags", [])[:12],
+                    }
+                    for item in data.get("results", [])[:limit]
+                ]
+            except (requests.RequestException, ValueError) as exc:
+                results["otx"] = self._error("AlienVault OTX", exc)
+        else:
+            results["otx"] = {"not": "OTX_API_KEY tanımlı değil."}
+
+        misp_url, misp_key = os.getenv("MISP_BASE_URL"), os.getenv("MISP_API_KEY")
+        if misp_url and misp_key:
+            try:
+                data = self._post(
+                    urljoin(misp_url.rstrip("/") + "/", "events/restSearch"),
+                    headers={
+                        "Authorization": misp_key,
+                        "Accept": "application/json",
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "returnFormat": "json",
+                        "searchall": query,
+                        "published": True,
+                        "limit": limit,
+                        "page": 1,
+                    },
+                    verify=os.getenv("MISP_VERIFY_TLS", "true").lower() != "false",
+                ).json()
+                events = data.get("response", data if isinstance(data, list) else [])
+                results["misp"] = [
+                    {
+                        "id": (item.get("Event") or item).get("id"),
+                        "bilgi": _compact((item.get("Event") or item).get("info"), 350),
+                        "tarih": (item.get("Event") or item).get("date"),
+                        "tehdit_seviyesi": (item.get("Event") or item).get(
+                            "threat_level_id"
+                        ),
+                    }
+                    for item in events[:limit]
+                ]
+            except (requests.RequestException, ValueError) as exc:
+                results["misp"] = self._error("MISP", exc)
+        else:
+            results["misp"] = {
+                "not": "MISP_BASE_URL ve MISP_API_KEY birlikte tanımlı değil."
+            }
+        return {"sorgu": query, "kaynaklar": results}
+
+    def mitre_attack_tekniklerini_ara(
+        self, sorgu: str, sonuc_sayisi: int = 10
+    ) -> dict[str, Any]:
+        query = sorgu.casefold().strip()
+        if not query:
+            return {"hata": "Sorgu boş olamaz."}
+        limit = _clamp(sonuc_sayisi, upper=20)
+        url = (
+            "https://attack-taxii.mitre.org/api/v21/collections/"
+            "x-mitre-collection--1f5f1533-f617-4ca8-9ab4-6a02367fa019/objects"
+        )
+        try:
+            data = self._get(
+                url,
+                headers={"Accept": "application/taxii+json;version=2.1"},
+                params={"match[type]": "attack-pattern"},
+            ).json()
+            matches = []
+            for item in data.get("objects", []):
+                external = (item.get("external_references") or [{}])[0]
+                haystack = " ".join(
+                    [
+                        str(item.get("name", "")),
+                        str(item.get("description", "")),
+                        str(external.get("external_id", "")),
+                    ]
+                ).casefold()
+                if query not in haystack:
+                    continue
+                matches.append(
+                    {
+                        "attack_id": external.get("external_id"),
+                        "ad": item.get("name"),
+                        "aciklama": _compact(item.get("description"), 600),
+                        "platformlar": item.get("x_mitre_platforms", []),
+                        "url": external.get("url"),
+                    }
+                )
+                if len(matches) >= limit:
+                    break
+            return {"kaynak": "MITRE ATT&CK TAXII 2.1", "sonuclar": matches}
+        except (requests.RequestException, ValueError) as exc:
+            return self._error("MITRE ATT&CK", exc)
+
+    @staticmethod
+    def _xml_text(entry: ElementTree.Element, name: str) -> str | None:
+        node = entry.find(name)
+        if node is None:
+            node = entry.find(f"{{http://www.w3.org/2005/Atom}}{name}")
+        return node.text.strip() if node is not None and node.text else None
+
+    @staticmethod
+    def _nvd_headers() -> dict[str, str]:
+        key = os.getenv("NVD_API_KEY")
+        return {"apiKey": key} if key else {}
+
+    @staticmethod
+    def _normalize_nvd(cve: dict[str, Any]) -> dict[str, Any]:
+        descriptions = cve.get("descriptions", [])
+        description = next(
+            (item.get("value") for item in descriptions if item.get("lang") == "en"),
+            descriptions[0].get("value") if descriptions else "",
+        )
+        metrics = cve.get("metrics", {})
+        metric = next(
+            (
+                entries[0]
+                for name in ("cvssMetricV40", "cvssMetricV31", "cvssMetricV30", "cvssMetricV2")
+                if (entries := metrics.get(name))
+            ),
+            {},
+        )
+        cvss = metric.get("cvssData", {})
+        weaknesses = [
+            desc.get("value")
+            for weakness in cve.get("weaknesses", [])
+            for desc in weakness.get("description", [])
+            if desc.get("lang") == "en"
+        ]
+        references = [
+            {"url": ref.get("url"), "etiketler": ref.get("tags", [])}
+            for ref in cve.get("references", [])[:8]
+        ]
+        return {
+            "cve_id": cve.get("id"),
+            "yayim_tarihi": cve.get("published"),
+            "degistirilme_tarihi": cve.get("lastModified"),
+            "durum": cve.get("vulnStatus"),
+            "aciklama": _compact(description, 900),
+            "cvss_puani": cvss.get("baseScore"),
+            "cvss_seviyesi": cvss.get("baseSeverity") or metric.get("baseSeverity"),
+            "cvss_vektoru": cvss.get("vectorString"),
+            "cwe": list(dict.fromkeys(filter(None, weaknesses)))[:8],
+            "referanslar": references,
+            "nvd_url": f"https://nvd.nist.gov/vuln/detail/{cve.get('id')}",
+        }
+
+    def execute(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        function = self.available_functions.get(name)
+        if not function:
+            return {"hata": f"Bilinmeyen araç: {name}"}
+        try:
+            return function(**arguments)
+        except TypeError as exc:
+            return {"hata": "Araç parametreleri geçersiz.", "ayrinti": _compact(exc, 300)}
+        except Exception as exc:  # Aracın bir hatası ajan döngüsünü sonlandırmamalı.
+            return {
+                "hata": "Araç çalıştırılırken beklenmeyen hata oluştu.",
+                "ayrinti": _compact(exc, 300),
+            }
+
+    @staticmethod
+    def to_json(result: dict[str, Any]) -> str:
+        return json.dumps(result, ensure_ascii=False, default=str)

ollama/ollama_local_model_managment_code.py

@@ -0,0 +1,234 @@
+"""Ollama üzerinde çok adımlı, araç kullanan siber güvenlik asistanı."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from copy import deepcopy
+from collections.abc import Generator
+from datetime import UTC, datetime
+from typing import Any
+
+import requests
+
+from .cyber_security_tools import CyberSecurityTools
+
+
+SYSTEM_PROMPT = """Sen güncel siber güvenlik haberleri ve zafiyetleri konusunda çalışan,
+Türkçe yanıt veren bir analiz asistanısın.
+
+Kurallar:
+1. Güncellik içeren sorularda belleğine güvenme; uygun aracı mutlaka kullan.
+2. Gerekirse birden fazla aracı ve birden fazla turu kullan. Örneğin önce son CVE'leri
+   bul, sonra önemli bir CVE için ayrıntı aracını çağır.
+3. Araç sonucu olmayan güncel bir iddiayı kesin bilgi gibi sunma.
+4. Kaynakların tarihini, kaynak adını ve varsa doğrudan URL'sini nihai yanıtta belirt.
+5. CVSS puanı ile aktif istismarı birbirine karıştırma. CISA KEV kaydı aktif istismar
+   açısından daha güçlü bir göstergedir.
+6. Veri bulunamazsa veya kaynak hata verirse bunu açıkça söyle; bilgi uydurma.
+7. Yanıtı Türkçe, öz ve okunaklı yaz. CVE kimliklerini aynen koru.
+8. Kullanıcı savunma ve risk azaltma önerileri isterse uygulanabilir öneriler sun.
+9. Zararlı veya yetkisiz eylemleri kolaylaştıran operasyonel talimatlar verme.
+10. Araç çağrılarının kullanıcı arayüzünde ayrıca gösterildiğini bil; nihai cevapta
+    ham JSON'u tekrar etme, bulguları sentezle.
+"""
+
+
+class OllamaConnectionError(RuntimeError):
+    """Ollama sunucusuna erişilemediğinde kullanılır."""
+
+
+class OllamaLocalModelManagement:
+    """Ollama `/api/chat` uç noktası için sınırlı bir ajan döngüsü."""
+
+    def __init__(
+        self,
+        model_name: str | None = None,
+        base_url: str | None = None,
+        tools: CyberSecurityTools | None = None,
+        session: requests.Session | None = None,
+        max_tool_rounds: int = 6,
+    ) -> None:
+        self.model_name = model_name or os.getenv("OLLAMA_MODEL", "qwen3.6:latest")
+        self.base_url = (base_url or os.getenv("OLLAMA_BASE_URL", "http://127.0.0.1:11434")).rstrip(
+            "/"
+        )
+        self.session = session or requests.Session()
+        self.tools = tools or CyberSecurityTools()
+        self.max_tool_rounds = max(1, min(max_tool_rounds, 10))
+
+    def _system_message(self) -> dict[str, str]:
+        now = datetime.now(UTC).isoformat(timespec="seconds")
+        return {
+            "role": "system",
+            "content": f"{SYSTEM_PROMPT}\nŞu anki UTC zaman: {now}",
+        }
+
+    def _chat_request(self, messages: list[dict[str, Any]]) -> dict[str, Any]:
+        payload = {
+            "model": self.model_name,
+            # Ajan döngüsü `messages` listesini daha sonra büyütür; istek anındaki
+            # denetlenebilir görüntüyü korumak için kopyala.
+            "messages": deepcopy(messages),
+            "tools": self.tools.schemas,
+            "stream": False,
+            "think": False,
+            "options": {
+                "temperature": float(os.getenv("OLLAMA_TEMPERATURE", "0.2")),
+                "num_ctx": int(os.getenv("OLLAMA_NUM_CTX", "16384")),
+            },
+            "keep_alive": os.getenv("OLLAMA_KEEP_ALIVE", "10m"),
+        }
+        headers = {}
+        if api_key := os.getenv("OLLAMA_API_KEY"):
+            headers["Authorization"] = f"Bearer {api_key}"
+        try:
+            response = self.session.post(
+                f"{self.base_url}/api/chat",
+                json=payload,
+                headers=headers,
+                timeout=(10, int(os.getenv("OLLAMA_TIMEOUT_SECONDS", "300"))),
+            )
+            response.raise_for_status()
+            data = response.json()
+        except requests.ConnectionError as exc:
+            raise OllamaConnectionError(
+                f"Ollama sunucusuna ulaşılamadı ({self.base_url}). "
+                "`ollama serve` komutuyla sunucuyu başlatın."
+            ) from exc
+        except requests.Timeout as exc:
+            raise OllamaConnectionError("Ollama yanıt süresini aştı.") from exc
+        except (requests.HTTPError, ValueError) as exc:
+            detail = ""
+            if "response" in locals():
+                detail = response.text[:500]
+            raise OllamaConnectionError(
+                f"Ollama isteği başarısız oldu: {detail or exc}"
+            ) from exc
+        if not isinstance(data.get("message"), dict):
+            raise OllamaConnectionError("Ollama geçerli bir `message` alanı döndürmedi.")
+        return data
+
+    @staticmethod
+    def _conversation_messages(history: list[dict[str, Any]] | None) -> list[dict[str, str]]:
+        clean: list[dict[str, str]] = []
+        for item in history or []:
+            role, content = item.get("role"), item.get("content")
+            if role in {"user", "assistant"} and isinstance(content, str) and content.strip():
+                clean.append({"role": role, "content": content})
+        return clean[-20:]
+
+    def run(
+        self, user_message: str, history: list[dict[str, Any]] | None = None
+    ) -> Generator[dict[str, Any], None, None]:
+        """Araç ve nihai yanıt olaylarını sırayla üretir."""
+        if not user_message or not user_message.strip():
+            yield {"type": "error", "content": "Lütfen bir soru yazın."}
+            return
+
+        messages: list[dict[str, Any]] = [
+            self._system_message(),
+            *self._conversation_messages(history),
+            {"role": "user", "content": user_message.strip()},
+        ]
+
+        for turn in range(1, self.max_tool_rounds + 2):
+            try:
+                response = self._chat_request(messages)
+            except OllamaConnectionError as exc:
+                yield {"type": "error", "content": str(exc)}
+                return
+
+            assistant_message = response["message"]
+            messages.append(assistant_message)
+            tool_calls = assistant_message.get("tool_calls") or []
+
+            if not tool_calls:
+                content = (assistant_message.get("content") or "").strip()
+                if not content:
+                    content = "Model boş bir yanıt döndürdü."
+                yield {
+                    "type": "final",
+                    "turn": turn,
+                    "content": content,
+                    "metrics": {
+                        "prompt_tokens": response.get("prompt_eval_count"),
+                        "response_tokens": response.get("eval_count"),
+                        "total_duration_seconds": round(
+                            (response.get("total_duration") or 0) / 1_000_000_000, 2
+                        ),
+                    },
+                }
+                return
+
+            if turn > self.max_tool_rounds:
+                yield {
+                    "type": "error",
+                    "content": (
+                        f"Güvenlik sınırı nedeniyle {self.max_tool_rounds} araç turundan "
+                        "sonra işlem durduruldu."
+                    ),
+                }
+                return
+
+            visible_note = (assistant_message.get("content") or "").strip()
+            if visible_note:
+                yield {"type": "note", "turn": turn, "content": visible_note}
+
+            for index, call in enumerate(tool_calls, start=1):
+                function = call.get("function") or {}
+                name = function.get("name", "")
+                arguments = function.get("arguments") or {}
+                if isinstance(arguments, str):
+                    try:
+                        arguments = json.loads(arguments)
+                    except json.JSONDecodeError:
+                        arguments = {"_gecersiz_ham_parametre": arguments}
+                if not isinstance(arguments, dict):
+                    arguments = {"_gecersiz_parametre": arguments}
+
+                started = time.monotonic()
+                result = self.tools.execute(name, arguments)
+                duration = round(time.monotonic() - started, 2)
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_name": name,
+                        "content": self.tools.to_json(result),
+                    }
+                )
+                yield {
+                    "type": "tool",
+                    "turn": turn,
+                    "index": index,
+                    "name": name,
+                    "arguments": arguments,
+                    "result": result,
+                    "duration_seconds": duration,
+                }
+
+        yield {"type": "error", "content": "Beklenmeyen ajan döngüsü sonu."}
+
+    def health(self) -> dict[str, Any]:
+        try:
+            headers = {}
+            if api_key := os.getenv("OLLAMA_API_KEY"):
+                headers["Authorization"] = f"Bearer {api_key}"
+            response = self.session.get(
+                f"{self.base_url}/api/tags", headers=headers, timeout=(3, 10)
+            )
+            response.raise_for_status()
+            models = [item.get("name") for item in response.json().get("models", [])]
+            return {
+                "ok": self.model_name in models,
+                "model": self.model_name,
+                "available_models": models,
+                "base_url": self.base_url,
+            }
+        except (requests.RequestException, ValueError) as exc:
+            return {"ok": False, "model": self.model_name, "error": str(exc)}
+
+
+# Eski dosyayı kullanan kodlar için geriye dönük uyumluluk.
+ollama_local_model_managment = OllamaLocalModelManagement

pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "local-models-make-tc-and-so"
+version = "0.1.0"
+description = "Araç çağrıları kullanan yerel Ollama siber güvenlik haber asistanı"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio>=6.0,<7",
+    "requests>=2.32,<3",
+]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.12",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=6.0,<7
+requests>=2.32,<3

start.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+MODEL_NAME="${OLLAMA_MODEL:-qwen3.6:latest}"
+MODEL_DIR="${OLLAMA_MODELS:-${HOME}/.ollama/models}"
+
+export OLLAMA_HOST="${OLLAMA_HOST:-127.0.0.1:11434}"
+export OLLAMA_BASE_URL="${OLLAMA_BASE_URL:-http://127.0.0.1:11434}"
+export OLLAMA_MODELS="${MODEL_DIR}"
+
+mkdir -p "${OLLAMA_MODELS}"
+
+echo "Ollama sunucusu başlatılıyor: ${OLLAMA_HOST}"
+ollama serve &
+OLLAMA_PID=$!
+
+READY=false
+for _ in $(seq 1 120); do
+    if ollama list >/dev/null 2>&1; then
+        READY=true
+        break
+    fi
+    if ! kill -0 "${OLLAMA_PID}" >/dev/null 2>&1; then
+        echo "Hata: Ollama sunucusu beklenmedik şekilde kapandı." >&2
+        exit 1
+    fi
+    sleep 1
+done
+
+if [[ "${READY}" != "true" ]]; then
+    echo "Hata: Ollama sunucusu 120 saniye içinde hazır olmadı." >&2
+    exit 1
+fi
+
+if ollama show "${MODEL_NAME}" >/dev/null 2>&1; then
+    echo "Model hazır: ${MODEL_NAME}"
+else
+    echo "Model indiriliyor: ${MODEL_NAME}"
+    ollama pull "${MODEL_NAME}"
+fi
+
+echo "Gradio başlatılıyor: ${GRADIO_SERVER_NAME:-0.0.0.0}:${GRADIO_SERVER_PORT:-7860}"
+exec python /app/app.py

tests/test_agent.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+from unittest.mock import Mock
+
+import requests
+
+from ollama.cyber_security_tools import CyberSecurityTools
+from ollama.ollama_local_model_managment_code import OllamaLocalModelManagement
+
+
+class FakeResponse:
+    def __init__(self, payload, status_code=200):
+        self._payload = payload
+        self.status_code = status_code
+        self.text = str(payload)
+
+    def json(self):
+        return self._payload
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise RuntimeError(self.text)
+
+
+class ToolTests(unittest.TestCase):
+    def test_all_schemas_have_registered_function(self):
+        tools = CyberSecurityTools()
+        names = {item["function"]["name"] for item in tools.schemas}
+        self.assertEqual(names, set(tools.available_functions))
+
+    def test_invalid_cve_is_rejected_without_network(self):
+        tools = CyberSecurityTools(session=Mock())
+        result = tools.cve_detayi_getir("not-a-cve")
+        self.assertIn("hata", result)
+        tools.session.get.assert_not_called()
+
+    def test_nvd_normalization(self):
+        result = CyberSecurityTools._normalize_nvd(
+            {
+                "id": "CVE-2026-1234",
+                "published": "2026-01-01T00:00:00Z",
+                "descriptions": [{"lang": "en", "value": "Example flaw"}],
+                "metrics": {
+                    "cvssMetricV31": [
+                        {
+                            "cvssData": {
+                                "baseScore": 9.8,
+                                "baseSeverity": "CRITICAL",
+                                "vectorString": "CVSS:3.1/AV:N",
+                            }
+                        }
+                    ]
+                },
+            }
+        )
+        self.assertEqual(result["cve_id"], "CVE-2026-1234")
+        self.assertEqual(result["cvss_puani"], 9.8)
+
+    @patch.dict("os.environ", {}, clear=True)
+    def test_news_failure_returns_official_advisory_fallback(self):
+        session = Mock()
+        session.get.side_effect = requests.Timeout("test timeout")
+        tools = CyberSecurityTools(session=session)
+        tools.guvenlik_duyurularini_getir = Mock(
+            return_value={"sonuclar": [{"kaynak": "CISA"}], "hatalar": []}
+        )
+
+        result = tools.siber_haberlerini_ara("ransomware", 24, 5)
+
+        self.assertEqual(
+            result["alternatif_resmi_duyurular"]["sonuclar"][0]["kaynak"], "CISA"
+        )
+        self.assertIn("haber değil", result["uyari"])
+
+
+class AgentLoopTests(unittest.TestCase):
+    def test_multi_round_tool_call_and_final_answer(self):
+        session = Mock()
+        session.post.side_effect = [
+            FakeResponse(
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "",
+                        "tool_calls": [
+                            {
+                                "function": {
+                                    "name": "ornek_arac",
+                                    "arguments": {"sorgu": "CVE"},
+                                }
+                            }
+                        ],
+                    }
+                }
+            ),
+            FakeResponse(
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Türkçe nihai yanıt.",
+                    },
+                    "prompt_eval_count": 42,
+                    "eval_count": 8,
+                }
+            ),
+        ]
+        tools = Mock()
+        tools.schemas = []
+        tools.execute.return_value = {"sonuclar": ["CVE-2026-1234"]}
+        tools.to_json.side_effect = CyberSecurityTools.to_json
+        agent = OllamaLocalModelManagement(
+            session=session, tools=tools, model_name="test-model"
+        )
+
+        events = list(agent.run("En son CVE nedir?"))
+
+        self.assertEqual([event["type"] for event in events], ["tool", "final"])
+        self.assertEqual(events[0]["name"], "ornek_arac")
+        self.assertEqual(events[1]["content"], "Türkçe nihai yanıt.")
+        second_messages = session.post.call_args_list[1].kwargs["json"]["messages"]
+        self.assertEqual(second_messages[-1]["role"], "tool")
+        self.assertEqual(second_messages[-1]["tool_name"], "ornek_arac")
+
+
+if __name__ == "__main__":
+    unittest.main()