CRANE AI ZeroGPU Space yüklendi

README.md

@@ -1,289 +1,98 @@
----
-title: Teknova Nova AI
-emoji: 🚀
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 4.26.0
-app_file: gradio_app.py
-pinned: false
-license: mit
-language:
-- tr
-- en
-tags:
-- text-generation
-- conversational
-- turkish
-- teknova
-- nova-ai
-- chat
-- assistant
-pipeline_tag: text-generation
-library_name: transformers
----
-
-# 🚀 Teknova Nova AI
-
-**Teknova** tarafından geliştirilen **özgün** Türkçe yapay zeka modeli - Hugging Face ZeroGPU ile hızlandırılmış!
-
-## ✨ Özellikler
-
-- 🧠 **Özgün Model**: Teknova tarafından sıfırdan geliştirilen yapay zeka modeli
-- 🇹🇷 **Türkçe Optimizasyonu**: Türkçe dil yapısına özel olarak eğitilmiş
-- ⚡ **ZeroGPU Hızlı**: Hugging Face ZeroGPU teknolojisi ile hızlandırılmış
-- 💬 **Akıllı Sohbet**: Doğal dil işleme ile akıllı konuşma
-- 🎯 **Kullanıcı Dostu**: Kolay kullanım için tasarlanmış arayüz
-
-## 🚀 Nasıl Kullanılır?
-
-1. **Sohbet Başlat**: Aşağıdaki chat arayüzünde mesajınızı yazın
-2. **Gönder**: 🚀 Gönder butonuna tıklayın  
-3. **Yanıt Al**: Nova AI'dan anlık yanıt alın
-4. **Devam Edin**: Konuşmaya devam ederek daha detaylı bilgi alın
-
-## 💡 Örnek Sorular
-
-- "Merhaba Nova AI, nasılsın?"
-- "Yapay zeka nedir?"
-- "Teknova hakkında bilgi ver"
-- "Bana bir hikaye anlat"
-- "Python programlama hakkında bilgi ver"
-
-## 🛠️ Teknik Bilgiler
-
-- **Model**: Teknova Nova AI (Özgün)
-- **Framework**: Transformers, PyTorch
-- **UI**: Gradio 4.36.1
-- **Hızlandırma**: Hugging Face ZeroGPU
-- **Dil**: Türkçe odaklı çok dilli destek
-
-## 📄 Lisans
-
-Bu proje MIT lisansı ile lisanslanmıştır.
-
-## 🔗 Bağlantılar
-
-- **Geliştirici**: Teknova Innovation
-- **Model**: Nova AI (Özgün)
-- **Platform**: Hugging Face Spaces
-
----
-
-🌟 **Teknova Nova AI** - Tamamen özgün Türkçe dil modeli ile güçlendirilmiş yapay zeka deneyimi!
-
----
-
-## 🌟 **Model Özellikleri**
-
-### ✨ **Özgün Teknova Teknolojisi**
-- 🧠 **Türkçe Optimizasyonu** - Türkçe dil yapısına özel eğitim
-- 💬 **Doğal Konuşma** - İnsan benzeri etkileşim yetenekleri
-- 🎯 **Bağlamsal Anlama** - Gelişmiş anlam çıkarma
-- ⚡ **Hızlı Yanıt** - Optimize edilmiş performans
-- 🔧 **Çok Amaçlı** - Sohbet, yazma, analiz yetenekleri
-
-### 🛠️ **Teknik Detaylar**
-- **Temel Model:** Mistral-7B mimarisi
-- **Parametre Sayısı:** 7.24 milyar
-- **Eğitim Dili:** Türkçe + İngilizce
-- **Bağlam Uzunluğu:** 8192 token
-- **Model Formatı:** SafeTensors + PyTorch
-
----
-
-## 🚀 **Kullanım**
-
-### 💻 **Transformers ile**
-```python
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-
-# Nova AI modelini yükle
-model_name = "Teknova/NovaAI"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    torch_dtype=torch.float16,
-    device_map="auto"
-)
-
-# Sohbet örneği
-def chat_with_nova(message):
-    conversation = f"Kullanıcı: {message}\nNova AI:"
-    inputs = tokenizer(conversation, return_tensors="pt")
-    
-    with torch.no_grad():
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=512,
-            temperature=0.7,
-            top_p=0.9,
-            do_sample=True,
-            pad_token_id=tokenizer.eos_token_id
-        )
-    
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return response[len(conversation):].strip()
-
-# Örnek kullanım
-response = chat_with_nova("Merhaba Nova AI, nasılsın?")
-print(response)
-```
-
-### 🌐 **API ile Kullanım**
-```python
-import requests
-
-API_URL = "https://api-inference.huggingface.co/models/Teknova/NovaAI"
-headers = {"Authorization": "Bearer YOUR_HF_TOKEN"}
-
-def query_nova_ai(payload):
-    response = requests.post(API_URL, headers=headers, json=payload)
-    return response.json()
-
-# Örnek sorgu
-output = query_nova_ai({
-    "inputs": "Yapay zeka teknolojileri hakkında bilgi ver",
-    "parameters": {
-        "max_new_tokens": 256,
-        "temperature": 0.7,
-        "top_p": 0.9
-    }
-})
-print(output)
-```
-
----
-
-## 💡 **Örnek Kullanım Alanları**
-
-### 🎯 **Sohbet ve Asistan**
-- Müşteri hizmetleri chatbotu
-- Kişisel asistan uygulamaları
-- Eğitim ve öğretim desteği
-
-### 📝 **İçerik Üretimi**
-- Blog yazısı ve makale yazımı
-- Sosyal medya içeriği
-- Yaratıcı yazım desteği
-
-### 🔍 **Analiz ve Özetleme**
-- Metin analizi ve özetleme
-- Duygu analizi
-- Bilgi çıkarma
-
----
-
-## ⚙️ **Model Parametreleri**
-
-| Parametre | Değer | Açıklama |
-|-----------|-------|----------|
-| `temperature` | 0.7 | Yaratıcılık seviyesi (0.1-1.5) |
-| `top_p` | 0.9 | Nucleus sampling |
-| `max_new_tokens` | 512 | Maksimum yanıt uzunluğu |
-| `repetition_penalty` | 1.1 | Tekrar önleme |
-
----
-
-## 🎨 **Demo ve Uygulamalar**
-
-### 🌐 **Web Arayüzü**
-- **Gradio Demo:** [Nova AI Chat](https://huggingface.co/spaces/Teknova/NovaAI-Chat)
-- **HTML Arayüz:** Kendi web sitenizde kullanabilirsiniz
-
-### 📱 **Entegrasyon**
-```javascript
-// Web sitesinde kullanım örneği
-const API_URL = 'https://api-inference.huggingface.co/models/Teknova/NovaAI';
-
-async function queryNovaAI(text) {
-    const response = await fetch(API_URL, {
-        headers: { 
-            'Authorization': 'Bearer YOUR_TOKEN',
-            'Content-Type': 'application/json'
-        },
-        method: 'POST',
-        body: JSON.stringify({
-            inputs: text,
-            parameters: {
-                max_new_tokens: 256,
-                temperature: 0.7
-            }
-        })
-    });
-    
-    return await response.json();
-}
-```
-
----
-
-## 📊 **Performans**
-
-### 🚀 **Hız ve Verimlilik**
-- **CPU Modunda:** ~2-3 saniye yanıt süresi
-- **GPU Modunda:** ~0.5-1 saniye yanıt süresi
-- **Bellek Kullanımı:** ~14.5GB model boyutu
-- **Optimizasyon:** 4-bit quantization desteği
-
-### 🎯 **Kalite Metrikleri**
-- **Türkçe Doğruluk:** Yüksek seviyede Türkçe anlama
-- **Bağlamsal Tutarlılık:** Uzun konuşmalarda tutarlı yanıtlar
-- **Yaratıcılık:** Özgün ve çeşitli içerik üretimi
-
----
-
-## 🔧 **Sistem Gereksinimleri**
-
-### 💻 **Minimum Gereksinimler**
-- **RAM:** 16GB (4-bit quantization ile)
-- **GPU:** 8GB VRAM (RTX 3070 veya üzeri)
-- **CPU:** 4 çekirdek, 2.5GHz+
-- **Depolama:** 20GB boş alan
-
-### 🚀 **Önerilen Gereksinimler**
-- **RAM:** 32GB
-- **GPU:** 16GB+ VRAM (RTX 4080/4090)
-- **CPU:** 8+ çekirdek, 3.0GHz+
-- **Depolama:** SSD, 50GB+ boş alan
-
----
-
-## 📜 **Lisans ve Kullanım**
-
-Bu model **Apache 2.0** lisansı altında yayınlanmıştır. Ticari ve akademik kullanım için serbesttir.
-
-### ⚠️ **Önemli Notlar**
-- Model özgün Teknova teknolojisi içermektedir
-- Türkçe optimizasyonları Teknova tarafından geliştirilmiştir
-- Responsible AI ilkelerine uygun olarak kullanılmalıdır
-
----
-
-## 🏢 **Teknova Hakkında**
-
-**Teknova**, Türkiye'nin öncü yapay zeka teknoloji şirketidir. Özgün AI çözümleri geliştirerek teknoloji dünyasında fark yaratmayı hedefliyoruz.
-
-### 🎯 **Misyonumuz**
-Yapay zeka teknolojilerini Türkçe konuşan kullanıcılar için optimize etmek ve erişilebilir kılmak.
-
-### 🚀 **Vizyonumuz**
-Türkiye'den dünyaya özgün yapay zeka teknolojileri ihraç etmek.
-
----
-
-## 📞 **İletişim ve Destek**
-
-- **🌐 Website:** [teknova.ai](https://teknova.ai)
-- **📧 E-posta:** info@teknova.ai
-- **💬 Destek:** [GitHub Issues](https://github.com/teknova-ai/nova-ai/issues)
-- **📱 Sosyal Medya:** [@TeknovaAI](https://twitter.com/TeknovaAI)
-
----
-
-## 🙏 **Teşekkürler**
-
-Nova AI'yi kullandığınız için teşekkürler! Geri bildirimleriniz bizim için değerlidir.
-
-**Teknova Nova AI** - *Türkiye'nin Özgün Yapay Zeka Teknolojisi* 🚀
+---
+title: CRANE AI ZeroGPU
+emoji: 🏗️
+colorFrom: red
+colorTo: blue
+sdk: gradio
+sdk_version: 4.29.0
+app_file: app.py
+pinned: false
+license: mit
+hardware: zero-gpu
+tags:
+- ai
+- multi-model
+- zero-gpu
+- crane
+- turkish
+- code-generation
+- chat
+- reasoning
+language:
+- tr
+- en
+short_description: CRANE AI Hibrit Yapay Zeka Sistemi - ZeroGPU Powered
+---
+
+# 🏗️ CRANE AI - ZeroGPU Powered
+
+**Hibrit Yapay Zeka Sistemi** - HuggingFace ZeroGPU ile güçlendirilmiş
+
+## 🔥 ZeroGPU Features
+
+- **Ücretsiz GPU Erişimi**: HuggingFace'in ücretsiz GPU kaynaklarını kullanır
+- **Hızlı Model Yükleme**: GPU'da optimize edilmiş model başlatma
+- **Akıllı Router Sistemi**: Görevlere göre en uygun modeli seçer
+- **Hibrit Mimari**: Birden fazla küçük model birlikte çalışır
+
+## 🧠 Sistem Mimarisi
+
+### MicroModule System
+- **FastModule**: TinyLlama (hızlı yanıt)
+- **CodeModule**: DeepSeek-Coder (kod yazma) 
+- **ChatModule**: Qwen2.5 (sohbet)
+- **ReasonModule**: Phi-3 (mantık yürütme)
+
+### ZeroGPU Optimizasyonları
+- `@spaces.GPU` dekoratörleri
+- GPU memory management
+- Efficient model loading
+- Concurrent request handling
+
+## 🚀 Kullanım
+
+### Desteklenen Görevler:
+- 💬 **Genel sohbet**: Doğal dil işleme
+- 🔧 **Kod yazma**: Python, JavaScript, vb.
+- 🤔 **Problem çözme**: Mantık yürütme
+- ⚡ **Hızlı sorular**: Kısa yanıtlar
+
+### Örnek Kullanımlar:
+```
+"Python'da bir hesap makinesi yaz"
+"Fibonacci dizisi algoritması"
+"Web development hakkında bilgi ver"
+"Bugün nasıl bir gün?"
+```
+
+## ⚡ Performans
+
+- **GPU**: NVIDIA A100/T4 (ZeroGPU)
+- **Memory**: ~4GB VRAM
+- **Response Time**: ~2-5 saniye
+- **Concurrent Users**: 2 kullanıcı
+
+## 🔧 Teknik Detaylar
+
+### Model Specifications:
+- **TinyLlama**: 1.1B parametreli chat modeli
+- **DeepSeek-Coder**: 1.3B kod üretim modeli
+- **Qwen2.5**: 1.5B sohbet modeli
+- **Phi-3**: Mini reasoning modeli
+
+### ZeroGPU Configuration:
+- Duration: 30-60 saniye GPU slots
+- Concurrency: 2 eşzamanlı kullanıcı
+- Auto-shutdown: Idle durumda otomatik kapanma
+
+## 📄 Lisans
+
+MIT Lisansı - Açık kaynak
+
+## 👨‍💻 Geliştirici
+
+[@veteroner](https://huggingface.co/veteroner)
+
+---
+
+🔥 **ZeroGPU ile ücretsiz GPU gücünden yararlanın!**

app.py

@@ -1,360 +1,170 @@
+#!/usr/bin/env python3
 """
-🚀 Nova AI - Hugging Face Spaces ZeroGPU
-Teknova tarafından geliştirilen özgün yapay zeka modeli
-ZeroGPU ile hızlandırılmış
+CRANE AI - ZeroGPU Space Demo
+HuggingFace ZeroGPU ile çalışır
 """
 
 import gradio as gr
+import spaces
 import torch
-import os
+import asyncio
 import logging
+import os
+from typing import Dict, Any
 import time
-from typing import List, Tuple
 
-# Spaces import - sadece Hugging Face Spaces'te mevcut
-try:
-    import spaces
-    HAS_SPACES = True
-except ImportError:
-    HAS_SPACES = False
-    # Spaces decorator'ı için dummy fonksiyon
-    def spaces_gpu(func):
-        return func
-    spaces = type('spaces', (), {'GPU': spaces_gpu})()
-
-# Logging setup
+# Logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Global variables
-model = None
-tokenizer = None
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-def load_demo_responses():
-    """
-    Demo yanıtları - model yokken kullanılacak
-    """
-    demo_responses = {
-        "merhaba": "Merhaba! Ben Nova AI, Teknova'nın özgün yapay zeka teknolojisi. Size nasıl yardımcı olabilirim?",
-        "nasılsın": "Ben Nova AI'yım ve harika hissediyorum! Sizinle sohbet etmek için buradayım. Ne konuşmak istersiniz?",
-        "nova ai nedir": "Nova AI, Teknova tarafından geliştirilen özgün bir yapay zeka modelidir. Türkçe konuşabilir ve çeşitli konularda yardımcı olabilirim.",
-        "teknova": "Teknova, Türkiye'nin öncü yapay zeka teknoloji şirketidir. Özgün AI çözümleri geliştiriyoruz.",
-        "yapay zeka": "Yapay zeka, bilgisayarların insan benzeri düşünme ve öğrenme yetenekleri göstermesidir. Ben de bir yapay zeka örneğiyim!",
-        "projeler": "Size yenilikçi proje fikirleri önerebilirim: AI chatbot, veri analizi, web uygulaması, mobil uygulama gibi...",
-        "gelecek": "Gelecekte yapay zeka, otonom araçlar, akıllı şehirler ve personalize eğitim gibi alanlarda devrim yaratacak!"
-    }
-    return demo_responses
+# ZeroGPU için import'lar
+from config.settings import MODELS, HF_TOKEN
+from modules.code_module import CodeModule
+from modules.chat_module import ChatModule  
+from modules.reason_module import ReasonModule
+from modules.fast_module import FastModule
+from router.intelligent_router import IntelligentRouter
 
-def generate_demo_response(message: str) -> str:
-    """
-    Demo yanıt oluştur (model olmadığında)
-    """
-    message_lower = message.lower().strip()
-    demo_responses = load_demo_responses()
-    
-    # Exact match
-    if message_lower in demo_responses:
-        return demo_responses[message_lower]
-    
-    # Partial match
-    for key, response in demo_responses.items():
-        if key in message_lower:
-            return response
-    
-    # Default responses
-    if "?" in message:
-        return f"'{message}' hakkında çok ilginç bir soru sordunuz! Nova AI olarak elimden geldiğince yardımcı olmaya çalışırım. Bu konuda daha spesifik sorular sorabilirsiniz."
-    
-    return f"Nova AI burada! '{message}' konusunda konuşmak güzel. Size nasıl yardımcı olabilirim? Daha detaylı sorular sorabilirsiniz."
-
-def chat_response(message: str, history: List[List[str]], max_length: int, temperature: float) -> Tuple[str, List[List[str]]]:
-    """
-    Chat response function
-    """
-    if not message.strip():
-        return "", history
-    
-    # Simulate thinking time
-    time.sleep(0.5)
-    
-    # Generate response
-    if model and tokenizer:
-        # Gerçek model ile yanıt (model yüklü ise)
+class CRANEZeroGPU:
+    """CRANE AI ZeroGPU Wrapper"""
+    
+    def __init__(self):
+        self.modules = {}
+        self.router = None
+        self.is_initialized = False
+        
+    @spaces.GPU(duration=60)  # 60 saniye GPU
+    async def initialize_models(self):
+        """Modelleri GPU'da başlatır"""
+        if self.is_initialized:
+            return
+            
+        logger.info("🔥 ZeroGPU'da modeller yükleniyor...")
+        
+        # GPU cihazını ayarla
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"🖥️ Cihaz: {device}")
+        
+        # Modelleri yükle
+        for name, cfg in MODELS.items():
+            try:
+                config = {**cfg, "device": device, "hf_token": os.getenv("HF_TOKEN", "")}
+                
+                if name == "fast_module":  # Sadece hızlı modeli yükle (GPU sınırlaması için)
+                    module = FastModule(config)
+                    await module.load_model()
+                    self.modules[name] = module
+                    logger.info(f"  ✅ {name} GPU'da yüklendi")
+                    break  # Sadece bir model yükle
+                    
+            except Exception as e:
+                logger.error(f"  ❌ {name} yükleme hatası: {e}")
+        
+        # Router'ı başlat
+        if self.modules:
+            self.router = IntelligentRouter(self.modules, {
+                "confidence_threshold": 0.6,
+                "max_concurrent_requests": 1,
+                "timeout": 30,
+                "fallback_model": "fast_module"
+            })
+            
+        self.is_initialized = True
+        logger.info("🔥 ZeroGPU başlatma tamamlandı")
+    
+    @spaces.GPU(duration=30)
+    async def process_query(self, message: str, history: list) -> str:
+        """Mesajı ZeroGPU'da işler"""
         try:
-            response = generate_real_response(message, max_length, temperature)
+            # Modelleri başlat
+            await self.initialize_models()
+            
+            if not self.router or not self.modules:
+                return "⚠️ Sistem başlatılamadı. Lütfen tekrar deneyin."
+            
+            # Hızlı yanıt için basit kontrol
+            message_lower = message.lower()
+            
+            # Basit selamlaşma
+            greetings = ["merhaba", "selam", "hi", "hello", "hey"]
+            if any(greeting in message_lower for greeting in greetings):
+                return "🏗️ Merhaba! Ben CRANE AI. Size nasıl yardımcı olabilirim?"
+            
+            # Kod talebi kontrolü
+            code_keywords = ["kod", "code", "python", "javascript", "function", "def"]
+            if any(keyword in message_lower for keyword in code_keywords):
+                response = "🔧 Kod yazma modülü aktif... "
+            else:
+                response = "💬 "
+            
+            # Modeli çalıştır
+            start_time = time.time()
+            result = await self.router.route_query(message, {"history": history})
+            duration = time.time() - start_time
+            
+            if result and "response" in result:
+                response += result["response"]
+                response += f"\n\n⚡ İşlem süresi: {duration:.2f}s"
+            else:
+                response += "Üzgünüm, şu anda yanıt veremiyorum. Lütfen tekrar deneyin."
+            
+            return response
+            
         except Exception as e:
-            response = f"Model hatası: {str(e)} - Demo moduna geçiliyor..."
-            response += "\n\n" + generate_demo_response(message)
-    else:
-        # Demo yanıt
-        response = generate_demo_response(message)
-        response += "\n\n💡 *Not: Bu demo modunda çalışıyor. Gerçek Nova AI modeli yüklendiğinde daha gelişmiş yanıtlar alacaksınız.*"
-    
-    # Add to history
-    history.append([message, response])
-    return "", history
+            logger.error(f"ZeroGPU işlem hatası: {e}")
+            return f"❌ Hata oluştu: {str(e)}"
 
-@spaces.GPU
-def generate_real_response(message: str, max_length: int, temperature: float) -> str:
-    """
-    Gerçek model ile yanıt oluştur - ZeroGPU destekli
-    """
-    if not model or not tokenizer:
-        return generate_demo_response(message)
-    
-    try:
-        inputs = tokenizer.encode(message, return_tensors="pt")
-        if device == "cuda":
-            inputs = inputs.to(device)
-        
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs,
-                max_length=max_length,
-                temperature=temperature,
-                do_sample=True,
-                pad_token_id=tokenizer.eos_token_id,
-                no_repeat_ngram_size=3,
-                top_p=0.9
-            )
-        
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        if message in response:
-            response = response.replace(message, "").strip()
-        
-        return response if response else generate_demo_response(message)
-        
-    except Exception as e:
-        logger.error(f"Model generation error: {e}")
-        return generate_demo_response(message)
+# Global instance
+crane_gpu = CRANEZeroGPU()
 
-@spaces.GPU
-def load_model():
-    """
-    Teknova Nova AI modelini yükle - ZeroGPU destekli
-    """
-    global model, tokenizer
-    
-    try:
-        from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-        
-        # Model path - Hugging Face Hub'dan yükle
-        model_path = "veteroner/NovaAI"
-        
-        logger.info(f"🚀 Teknova Nova AI modeli Hub'dan yükleniyor: {model_path}")
-        
-        # Tokenizer yükle
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_path, 
-            trust_remote_code=True,
-            use_fast=True
-        )
-        
-        # Pad token ayarla
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        # Model yükle - ZeroGPU optimizasyonu
-        model = AutoModelForCausalLM.from_pretrained(
-            model_path,
-            device_map="auto",
-            trust_remote_code=True,
-            torch_dtype=torch.float16,
-            low_cpu_mem_usage=True
-        )
-        
-        logger.info(f"✅ Nova AI model yüklendi ({device})")
-        return f"✅ Teknova Nova AI hazır! ({device})"
-        
-    except Exception as e:
-        logger.error(f"Model yükleme hatası: {e}")
-        return f"❌ Model yüklenemedi: {str(e)} - Demo modunda çalışacak"
+async def chat_interface(message, history):
+    """Gradio chat interface"""
+    return await crane_gpu.process_query(message, history)
 
-@spaces.GPU
-def chat_with_nova(message: str, history: List[Tuple[str, str]]) -> str:
-    """
-    Nova AI ile sohbet et - ZeroGPU destekli
-    """
-    global model, tokenizer
-    
-    if model is None or tokenizer is None:
-        # Demo yanıt ver
-        return generate_demo_response(message) + "\n\n💡 *Not: Demo modunda çalışıyor.*"
-    
-    if not message.strip():
-        return "❓ Lütfen bir mesaj yazın."
-    
+def sync_chat_interface(message, history):
+    """Senkron wrapper"""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
     try:
-        # Konuşma geçmişini hazırla
-        conversation = ""
-        for user_msg, bot_msg in history:
-            if user_msg and bot_msg:
-                conversation += f"Kullanıcı: {user_msg}\nNova AI: {bot_msg}\n"
-        
-        # Yeni mesajı ekle
-        conversation += f"Kullanıcı: {message}\nNova AI:"
-        
-        # Tokenize et
-        inputs = tokenizer(
-            conversation, 
-            return_tensors="pt", 
-            truncation=True, 
-            max_length=2048,
-            padding=True
-        )
-        
-        # GPU'ya taşı
-        if torch.cuda.is_available():
-            inputs = {k: v.to(model.device) for k, v in inputs.items()}
-        
-        # Yanıt üret
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=256,
-                temperature=0.7,
-                top_p=0.9,
-                do_sample=True,
-                pad_token_id=tokenizer.pad_token_id,
-                eos_token_id=tokenizer.eos_token_id,
-                repetition_penalty=1.1
-            )
-        
-        # Yanıtı decode et
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Sadece yeni üretilen kısmı al
-        new_response = response[len(conversation):].strip()
-        
-        return new_response if new_response else "Üzgünüm, yanıt üretemedi."
-        
-    except Exception as e:
-        logger.error(f"Chat hatası: {e}")
-        return f"❌ Yanıt üretirken hata: {str(e)}"
-
-# Model yüklemeyi başlat
-logger.info("Model yükleme başlatılıyor...")
-load_status = load_model()
-logger.info(f"Model durumu: {load_status}")
+        return loop.run_until_complete(chat_interface(message, history))
+    finally:
+        loop.close()
 
 # Gradio arayüzü
-with gr.Blocks(
+demo = gr.ChatInterface(
+    fn=sync_chat_interface,
+    type="messages",
+    title="🏗️ CRANE AI - ZeroGPU Powered",
+    description="""
+    **CRANE AI Hibrit Yapay Zeka Sistemi** - HuggingFace ZeroGPU ile güçlendirilmiş
+    
+    🔥 **ZeroGPU Features:**
+    - Ücretsiz GPU erişimi
+    - Hızlı model yükleme
+    - Optimize edilmiş performans
+    
+    🧠 **Desteklenen Görevler:**
+    - 💬 Genel sohbet
+    - 🔧 Kod yazma
+    - 🤔 Problem çözme
+    - ⚡ Hızlı sorular
+    """,
     theme=gr.themes.Soft(),
-    title="Teknova Nova AI - ZeroGPU",
-    css="""
-    .gradio-container {
-        max-width: 900px;
-        margin: 0 auto;
-    }
-    .header-text {
-        text-align: center;
-        padding: 20px;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        border-radius: 15px;
-        margin-bottom: 20px;
-    }
-    """
-) as demo:
-    
-    # Header
-    gr.HTML("""
-    <div class="header-text">
-        <h1 style="font-size: 2.5rem; margin: 0; font-weight: bold;">
-            🚀 Teknova Nova AI
-        </h1>
-        <p style="font-size: 1.2rem; margin: 10px 0; opacity: 0.9;">
-            Türkiye'nin Özgün Yapay Zeka Modeli
-        </p>
-        <div style="background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 20px; display: inline-block; font-size: 0.9rem;">
-            🧠 Nova AI • 🇹�� Türkçe Optimize • ⚡ ZeroGPU Hızlı
-        </div>
-    </div>
-    """)
-    
-    # Chat interface
-    chatbot = gr.Chatbot(
-        height=500,
-        show_label=False,
-        show_share_button=True,
-        show_copy_button=True,
-        avatar_images=[None, "🤖"],
-        bubble_full_width=False
-    )
-    
-    with gr.Row():
-        msg = gr.Textbox(
-            placeholder="Nova AI'ya mesajınızı yazın... (Örn: Merhaba, nasılsın?)",
-            show_label=False,
-            scale=4,
-            container=False
-        )
-        submit = gr.Button("🚀 Gönder", scale=1, variant="primary")
-    
-    with gr.Row():
-        clear = gr.Button("🗑️ Temizle", scale=1)
-        retry = gr.Button("🔄 Tekrar Dene", scale=1)
-    
-    # Examples
-    gr.Examples(
-        examples=[
-            "Merhaba Nova AI, nasılsın?",
-            "Yapay zeka nedir?",
-            "Teknova hakkında bilgi ver",
-            "Bana bir hikaye anlat",
-            "Python programlama hakkında bilgi ver"
-        ],
-        inputs=msg,
-        label="💡 Örnek Sorular"
-    )
-    
-    # Footer
-    gr.HTML("""
-    <div style="text-align: center; padding: 15px; color: #666; font-size: 0.9rem;">
-        <p>🌟 <strong>Teknova Nova AI</strong> - Tamamen özgün Türkçe dil modeli</p>
-        <p>🚀 ZeroGPU teknolojisi ile hızlandırılmış</p>
-        <p style="color: #999;">⚡ Teknova Innovation ile güçlendirilmiştir</p>
-    </div>
-    """)
-    
-    # Event handlers
-    def user_message(message, history):
-        return "", history + [[message, None]]
-    
-    @spaces.GPU
-    def bot_message(history):
-        """Bot yanıtı oluştur - ZeroGPU destekli"""
-        if history and history[-1][1] is None:
-            user_msg = history[-1][0]
-            bot_response = chat_with_nova(user_msg, history[:-1])
-            history[-1][1] = bot_response
-        return history
-    
-    @spaces.GPU
-    def retry_last(history):
-        """Son mesajı yeniden dene - ZeroGPU destekli"""
-        if history and history[-1][1] is not None:
-            user_msg = history[-1][0]
-            bot_response = chat_with_nova(user_msg, history[:-1])
-            history[-1][1] = bot_response
-        return history
-    
-    # Event bindings
-    msg.submit(user_message, [msg, chatbot], [msg, chatbot], queue=False).then(
-        bot_message, chatbot, chatbot
-    )
-    submit.click(user_message, [msg, chatbot], [msg, chatbot], queue=False).then(
-        bot_message, chatbot, chatbot
-    )
-    clear.click(lambda: None, None, chatbot, queue=False)
-    retry.click(retry_last, chatbot, chatbot)
+    examples=[
+        "Merhaba! CRANE AI nasıl çalışır?",
+        "Python'da bir hesap makinesi yaz",
+        "Fibonacci dizisi algoritması",
+        "Web development hakkında bilgi ver",
+        "Bugün nasıl bir gün?",
+    ],
+    cache_examples=False,  # ZeroGPU için
+    concurrency_limit=2,   # Eşzamanlı kullanıcı sınırı
+)
 
-# Launch
 if __name__ == "__main__":
     demo.launch(
+        share=False,
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
         show_error=True
-    ) 
+    )

config/__init__.py

@@ -0,0 +1,16 @@
+"""
+CRANE AI - Configuration Package
+"""
+
+from .settings import *
+
+__all__ = [
+    'MODELS',
+    'ROUTER_CONFIG',
+    'MEMORY_CONFIG',
+    'API_CONFIG',
+    'SYSTEM_LIMITS',
+    'LOGGING_CONFIG',
+    'HF_TOKEN',
+    'DEVICE'
+] 

config/settings.py

@@ -0,0 +1,97 @@
+"""
+CRANE AI Sistem Yapılandırması
+"""
+
+import os
+from typing import Dict, Any
+
+# Hugging Face Token güvenlik için ortam değişkeninden okunur
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# Model Yapılandırması
+MODELS = {
+    "code_module": {
+        "model_id": "deepseek-ai/deepseek-coder-1.3b-instruct",
+        "task": "code_generation",
+        "max_tokens": 2048,
+        "temperature": 0.1,
+        "priority": 1
+    },
+    "chat_module": {
+        "model_id": "Qwen/Qwen2.5-1.5B-Instruct",
+        "task": "chat",
+        "max_tokens": 1024,
+        "temperature": 0.7,
+        "priority": 2
+    },
+    "reason_module": {
+        "model_id": "microsoft/Phi-3-mini-4k-instruct",
+        "task": "reasoning",
+        "max_tokens": 1024,
+        "temperature": 0.3,
+        "priority": 3
+    },
+    "fast_module": {
+        "model_id": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        "task": "quick_response",
+        "max_tokens": 512,
+        "temperature": 0.8,
+        "priority": 4
+    }
+}
+
+# Router Yapılandırması
+ROUTER_CONFIG = {
+    "confidence_threshold": 0.6,
+    "max_concurrent_requests": 4,
+    "timeout": 30,
+    "fallback_model": "fast_module"
+}
+
+# Memory Yapılandırması
+MEMORY_CONFIG = {
+    "max_slots": 10,
+    "slot_size": 1024,
+    "cleanup_interval": 300  # 5 dakika
+}
+
+# API Yapılandırması
+API_CONFIG = {
+    "host": "0.0.0.0",
+    "port": 8000,
+    "workers": 1
+}
+
+# Sistem Limitleri
+SYSTEM_LIMITS = {
+    "max_input_length": 4096,
+    "max_output_length": 2048,
+    "max_concurrent_users": 10
+}
+
+# Logging
+LOGGING_CONFIG = {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "file": "logs/crane_ai.log"
+}
+
+def get_model_config(model_name: str) -> Dict[str, Any]:
+    """Belirli bir model için yapılandırma döndürür"""
+    return MODELS.get(model_name, MODELS["fast_module"])
+
+def get_device():
+    """Kullanılacak cihazı belirler"""
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return "cuda"
+        elif torch.backends.mps.is_available():
+            return "mps"
+        else:
+            return "cpu"
+    except ImportError:
+        return "cpu"
+
+# Cihaz yapılandırması
+DEVICE = get_device() 

core/__init__.py

@@ -0,0 +1,12 @@
+"""
+CRANE AI - Core Modülleri
+"""
+
+from .base_module import BaseMicroModule
+from .token_capsule import TokenCapsuleLayer, TokenCapsule
+
+__all__ = [
+    'BaseMicroModule',
+    'TokenCapsuleLayer',
+    'TokenCapsule'
+] 

core/base_module.py

@@ -0,0 +1,177 @@
+"""
+CRANE AI - Temel MicroModule Sınıfı
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel, PeftConfig
+import os
+import logging
+import asyncio
+from threading import Lock
+
+logger = logging.getLogger(__name__)
+
+class BaseMicroModule(ABC):
+    """Tüm MicroModule'lar için temel sınıf"""
+    
+    def __init__(self, model_id: str, config: Dict[str, Any]):
+        self.model_id = model_id
+        self.config = config
+        self.device = config.get("device", "cpu")
+        self.max_tokens = config.get("max_tokens", 1024)
+        self.temperature = config.get("temperature", 0.7)
+        self.priority = config.get("priority", 1)
+        
+        # Model ve tokenizer
+        self.model = None
+        self.tokenizer = None
+        self.is_loaded = False
+        self.load_lock = Lock()
+        
+        # İstatistikler
+        self.request_count = 0
+        self.total_tokens = 0
+        self.avg_response_time = 0
+        
+    async def load_model(self):
+        """Modeli yükler"""
+        if self.is_loaded:
+            return
+            
+        with self.load_lock:
+            if self.is_loaded:
+                return
+                
+            try:
+                logger.info(f"Loading model: {self.model_id}")
+                
+                # Tokenizer yükleme
+                self.tokenizer = AutoTokenizer.from_pretrained(
+                    self.model_id,
+                    trust_remote_code=True,
+                    token=self.config.get("hf_token")
+                )
+                
+                # Model yükleme
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    self.model_id,
+                    trust_remote_code=True,
+                    torch_dtype=torch.float16 if self.device != "cpu" else torch.float32,
+                    device_map="auto" if self.device != "cpu" else None,
+                    token=self.config.get("hf_token")
+                )
+                
+                # LoRA adaptörü kontrolü
+                adapter_dir = os.path.join("model_cache", self.model_id.replace("/", "_"), "adapter")
+                if os.path.isdir(adapter_dir):
+                    try:
+                        self.model = PeftModel.from_pretrained(self.model, adapter_dir, is_trainable=False)
+                        self.model = self.model.merge_and_unload()
+                        logger.info(f"LoRA adaptörü yüklendi: {adapter_dir}")
+                    except Exception as adp_err:
+                        logger.warning(f"Adaptör yüklenemedi ({adapter_dir}): {adp_err}")
+
+                # Pad token ayarı
+                if self.tokenizer.pad_token is None:
+                    self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+                self.is_loaded = True
+                logger.info(f"Model loaded successfully: {self.model_id}")
+                
+            except Exception as e:
+                logger.error(f"Error loading model {self.model_id}: {str(e)}")
+                raise
+    
+    @abstractmethod
+    def can_handle(self, query: str, context: Dict[str, Any]) -> float:
+        """Bu modülün sorguyu ne kadar iyi işleyebileceğini belirler (0-1)"""
+        pass
+    
+    @abstractmethod
+    async def process(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Ana işleme fonksiyonu"""
+        pass
+    
+    async def generate_response(self, prompt: str, **kwargs) -> str:
+        """Metin üretimi"""
+        if not self.is_loaded:
+            await self.load_model()
+        
+        try:
+            # Tokenlara çevir
+            inputs = self.tokenizer(
+                prompt,
+                return_tensors="pt",
+                max_length=self.max_tokens,
+                truncation=True,
+                padding=True
+            )
+
+            # Tenzile cihaz aktarımı
+            if self.device != "cpu":
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            # Üretim parametreleri
+            generation_config = {
+                "max_new_tokens": kwargs.get("max_tokens", self.max_tokens),
+                "temperature": kwargs.get("temperature", self.temperature),
+                "do_sample": True,
+                "top_p": 0.9,
+                "top_k": 50,
+                "pad_token_id": self.tokenizer.pad_token_id,
+                "eos_token_id": self.tokenizer.eos_token_id,
+                "no_repeat_ngram_size": 3
+            }
+            
+            # Üretim
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    **generation_config
+                )
+            
+            # Metne çevir
+            response = self.tokenizer.decode(
+                outputs[0][inputs["input_ids"].shape[1]:],
+                skip_special_tokens=True
+            )
+            
+            # İstatistikleri güncelle
+            self.request_count += 1
+            self.total_tokens += len(outputs[0])
+            
+            return response.strip()
+            
+        except Exception as e:
+            logger.error(f"Generation error in {self.model_id}: {str(e)}")
+            raise
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Modül istatistiklerini döndürür"""
+        return {
+            "model_id": self.model_id,
+            "is_loaded": self.is_loaded,
+            "request_count": self.request_count,
+            "total_tokens": self.total_tokens,
+            "avg_response_time": self.avg_response_time,
+            "priority": self.priority
+        }
+    
+    def unload_model(self):
+        """Modeli bellekten kaldırır"""
+        if self.model:
+            del self.model
+            self.model = None
+        if self.tokenizer:
+            del self.tokenizer
+            self.tokenizer = None
+        self.is_loaded = False
+        
+        # GPU belleğini temizle
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        logger.info(f"Model unloaded: {self.model_id}") 

core/token_capsule.py

@@ -0,0 +1,316 @@
+"""
+CRANE AI - Token Capsule Layer
+"""
+
+from typing import Dict, Any, List, Optional, Tuple
+import torch
+import numpy as np
+from transformers import AutoTokenizer
+import logging
+from dataclasses import dataclass
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class TokenCapsule:
+    """Token kapsülü veri yapısı"""
+    tokens: List[int]
+    attention_mask: List[int]
+    token_type_ids: List[int]
+    embeddings: Optional[torch.Tensor] = None
+    metadata: Dict[str, Any] = None
+
+class TokenCapsuleLayer:
+    """Token işleme ve optimizasyon katmanı"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.max_length = config.get("max_length", 2048)
+        self.device = config.get("device", "cpu")
+        
+        # Token cache
+        self.token_cache = {}
+        self.cache_size = config.get("cache_size", 1000)
+        
+        # Token istatistikleri
+        self.token_stats = {
+            "total_processed": 0,
+            "cache_hits": 0,
+            "cache_misses": 0,
+            "avg_token_length": 0
+        }
+        
+        # Tokenizer havuzu
+        self.tokenizer_pool = {}
+        
+    async def process_input(self, text: str, model_id: str, context: Dict[str, Any] = None) -> TokenCapsule:
+        """Giriş metnini token kapsülüne çevirir"""
+        try:
+            # Cache kontrolü
+            cache_key = f"{model_id}:{hash(text)}"
+            if cache_key in self.token_cache:
+                self.token_stats["cache_hits"] += 1
+                return self.token_cache[cache_key]
+            
+            # Tokenizer al
+            tokenizer = await self._get_tokenizer(model_id)
+            
+            # Tokenize et
+            encoding = tokenizer(
+                text,
+                max_length=self.max_length,
+                padding=True,
+                truncation=True,
+                return_tensors="pt"
+            )
+            
+            # Token kapsülü oluştur
+            capsule = TokenCapsule(
+                tokens=encoding["input_ids"].squeeze().tolist(),
+                attention_mask=encoding["attention_mask"].squeeze().tolist(),
+                token_type_ids=encoding.get("token_type_ids", []).squeeze().tolist() if encoding.get("token_type_ids") is not None else [],
+                metadata={
+                    "model_id": model_id,
+                    "original_text": text[:100],  # İlk 100 karakter
+                    "token_count": len(encoding["input_ids"].squeeze()),
+                    "context": context
+                }
+            )
+            
+            # Cache'e ekle
+            self._add_to_cache(cache_key, capsule)
+            
+            # İstatistikleri güncelle
+            self.token_stats["total_processed"] += 1
+            self.token_stats["cache_misses"] += 1
+            self._update_avg_length(len(capsule.tokens))
+            
+            return capsule
+            
+        except Exception as e:
+            logger.error(f"Token processing error: {str(e)}")
+            raise
+    
+    async def optimize_tokens(self, capsule: TokenCapsule, optimization_type: str = "standard") -> TokenCapsule:
+        """Token optimizasyonu yapar"""
+        try:
+            if optimization_type == "compress":
+                return await self._compress_tokens(capsule)
+            elif optimization_type == "expand":
+                return await self._expand_tokens(capsule)
+            elif optimization_type == "filter":
+                return await self._filter_tokens(capsule)
+            else:
+                return capsule
+                
+        except Exception as e:
+            logger.error(f"Token optimization error: {str(e)}")
+            return capsule
+    
+    async def merge_capsules(self, capsules: List[TokenCapsule], strategy: str = "concat") -> TokenCapsule:
+        """Birden fazla kapsülü birleştirir"""
+        try:
+            if strategy == "concat":
+                return await self._concat_capsules(capsules)
+            elif strategy == "interleave":
+                return await self._interleave_capsules(capsules)
+            elif strategy == "priority":
+                return await self._priority_merge_capsules(capsules)
+            else:
+                return capsules[0] if capsules else None
+                
+        except Exception as e:
+            logger.error(f"Capsule merging error: {str(e)}")
+            return capsules[0] if capsules else None
+    
+    async def extract_embeddings(self, capsule: TokenCapsule, model: Any) -> TokenCapsule:
+        """Token embedding'lerini çıkarır"""
+        try:
+            if capsule.embeddings is not None:
+                return capsule
+            
+            # Model'den embedding'leri al
+            input_ids = torch.tensor([capsule.tokens]).to(self.device)
+            attention_mask = torch.tensor([capsule.attention_mask]).to(self.device)
+            
+            with torch.no_grad():
+                outputs = model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    output_hidden_states=True
+                )
+                
+                # Son katman hidden state'ini al
+                embeddings = outputs.hidden_states[-1]
+                capsule.embeddings = embeddings.squeeze()
+            
+            return capsule
+            
+        except Exception as e:
+            logger.error(f"Embedding extraction error: {str(e)}")
+            return capsule
+    
+    async def _get_tokenizer(self, model_id: str) -> AutoTokenizer:
+        """Model için tokenizer alır"""
+        if model_id not in self.tokenizer_pool:
+            try:
+                tokenizer = AutoTokenizer.from_pretrained(
+                    model_id,
+                    trust_remote_code=True,
+                    token=self.config.get("hf_token")
+                )
+                
+                # Pad token ayarı
+                if tokenizer.pad_token is None:
+                    tokenizer.pad_token = tokenizer.eos_token
+                
+                self.tokenizer_pool[model_id] = tokenizer
+                
+            except Exception as e:
+                logger.error(f"Tokenizer loading error for {model_id}: {str(e)}")
+                raise
+        
+        return self.tokenizer_pool[model_id]
+    
+    async def _compress_tokens(self, capsule: TokenCapsule) -> TokenCapsule:
+        """Token sıkıştırma"""
+        # Önemli token'ları tespit et ve gereksizleri çıkar
+        important_tokens = []
+        attention_mask = []
+        
+        for i, token in enumerate(capsule.tokens):
+            # Özel tokenları koru
+            if token in [0, 1, 2, 3]:  # [PAD], [UNK], [CLS], [SEP]
+                important_tokens.append(token)
+                attention_mask.append(capsule.attention_mask[i])
+            # Çok tekrarlanan tokenları atla
+            elif token not in important_tokens[-5:]:  # Son 5 token içinde yoksa
+                important_tokens.append(token)
+                attention_mask.append(capsule.attention_mask[i])
+        
+        compressed_capsule = TokenCapsule(
+            tokens=important_tokens,
+            attention_mask=attention_mask,
+            token_type_ids=capsule.token_type_ids[:len(important_tokens)],
+            embeddings=capsule.embeddings,
+            metadata={**capsule.metadata, "compressed": True}
+        )
+        
+        return compressed_capsule
+    
+    async def _expand_tokens(self, capsule: TokenCapsule) -> TokenCapsule:
+        """Token genişletme"""
+        # Context token'ları ekle
+        expanded_tokens = [1] + capsule.tokens + [2]  # [CLS] + tokens + [SEP]
+        expanded_attention = [1] + capsule.attention_mask + [1]
+        
+        expanded_capsule = TokenCapsule(
+            tokens=expanded_tokens,
+            attention_mask=expanded_attention,
+            token_type_ids=capsule.token_type_ids,
+            embeddings=capsule.embeddings,
+            metadata={**capsule.metadata, "expanded": True}
+        )
+        
+        return expanded_capsule
+    
+    async def _filter_tokens(self, capsule: TokenCapsule) -> TokenCapsule:
+        """Token filtreleme"""
+        # Gereksiz token'ları filtrele
+        filtered_tokens = []
+        filtered_attention = []
+        
+        for i, token in enumerate(capsule.tokens):
+            # Padding token'ları atla
+            if token != 0:
+                filtered_tokens.append(token)
+                filtered_attention.append(capsule.attention_mask[i])
+        
+        filtered_capsule = TokenCapsule(
+            tokens=filtered_tokens,
+            attention_mask=filtered_attention,
+            token_type_ids=capsule.token_type_ids[:len(filtered_tokens)],
+            embeddings=capsule.embeddings,
+            metadata={**capsule.metadata, "filtered": True}
+        )
+        
+        return filtered_capsule
+    
+    async def _concat_capsules(self, capsules: List[TokenCapsule]) -> TokenCapsule:
+        """Kapsülleri ardışık olarak birleştirir"""
+        if not capsules:
+            return None
+        
+        merged_tokens = []
+        merged_attention = []
+        merged_metadata = {"merged": True, "source_count": len(capsules)}
+        
+        for capsule in capsules:
+            merged_tokens.extend(capsule.tokens)
+            merged_attention.extend(capsule.attention_mask)
+            
+            # Metadata birleştir
+            if capsule.metadata:
+                for key, value in capsule.metadata.items():
+                    if key not in merged_metadata:
+                        merged_metadata[key] = []
+                    merged_metadata[key].append(value)
+        
+        # Maksimum uzunluk kontrolü
+        if len(merged_tokens) > self.max_length:
+            merged_tokens = merged_tokens[:self.max_length]
+            merged_attention = merged_attention[:self.max_length]
+        
+        return TokenCapsule(
+            tokens=merged_tokens,
+            attention_mask=merged_attention,
+            token_type_ids=[],
+            metadata=merged_metadata
+        )
+    
+    async def _interleave_capsules(self, capsules: List[TokenCapsule]) -> TokenCapsule:
+        """Kapsülleri aralarında birleştirir"""
+        # Implement interleaving logic
+        return await self._concat_capsules(capsules)
+    
+    async def _priority_merge_capsules(self, capsules: List[TokenCapsule]) -> TokenCapsule:
+        """Öncelik sırasına göre birleştirir"""
+        # Öncelik skoruna göre sırala
+        sorted_capsules = sorted(capsules, key=lambda x: x.metadata.get("priority", 0), reverse=True)
+        return await self._concat_capsules(sorted_capsules)
+    
+    def _add_to_cache(self, key: str, capsule: TokenCapsule):
+        """Cache'e ekler"""
+        if len(self.token_cache) >= self.cache_size:
+            # En eski entry'yi sil
+            oldest_key = next(iter(self.token_cache))
+            del self.token_cache[oldest_key]
+        
+        self.token_cache[key] = capsule
+    
+    def _update_avg_length(self, length: int):
+        """Ortalama token uzunluğunu günceller"""
+        current_avg = self.token_stats["avg_token_length"]
+        total_processed = self.token_stats["total_processed"]
+        
+        # Yeni ortalama hesapla
+        new_avg = ((current_avg * (total_processed - 1)) + length) / total_processed
+        self.token_stats["avg_token_length"] = new_avg
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Token layer istatistikleri"""
+        cache_hit_rate = self.token_stats["cache_hits"] / max(self.token_stats["total_processed"], 1)
+        
+        return {
+            "total_processed": self.token_stats["total_processed"],
+            "cache_hit_rate": cache_hit_rate,
+            "cache_size": len(self.token_cache),
+            "avg_token_length": self.token_stats["avg_token_length"],
+            "tokenizer_pool_size": len(self.tokenizer_pool)
+        }
+    
+    def clear_cache(self):
+        """Cache'i temizler"""
+        self.token_cache.clear()
+        logger.info("Token cache cleared") 

download_models.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+CRANE AI - Model İndirme Script'i
+HuggingFace'den modelleri önceden indirir
+"""
+
+import os
+import sys
+import logging
+from typing import Dict, Any
+import asyncio
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from huggingface_hub import login
+import gc
+
+# Logging ayarları
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# HuggingFace Token
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# İndirilecek modeller
+MODELS_TO_DOWNLOAD = {
+    "deepseek-coder": {
+        "model_id": "deepseek-ai/deepseek-coder-1.3b-instruct",
+        "description": "Kod yazımı için DeepSeek Coder 1.3B",
+        "task": "code_generation"
+    },
+    "qwen-chat": {
+        "model_id": "Qwen/Qwen2.5-1.5B-Instruct",
+        "description": "Sohbet için Qwen2.5 1.5B",
+        "task": "chat"
+    },
+    "phi-reason": {
+        "model_id": "microsoft/Phi-3-mini-4k-instruct",
+        "description": "Mantık için Phi-3 Mini",
+        "task": "reasoning"
+    },
+    "tinyllama-fast": {
+        "model_id": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        "description": "Hızlı yanıt için TinyLlama 1.1B",
+        "task": "quick_response"
+    }
+}
+
+def get_device():
+    """Cihaz tipini belirler"""
+    if torch.cuda.is_available():
+        return "cuda"
+    elif torch.backends.mps.is_available():
+        return "mps"
+    else:
+        return "cpu"
+
+def setup_cache_dir():
+    """Model cache dizinini ayarlar"""
+    cache_dir = os.path.join(os.getcwd(), "model_cache")
+    os.makedirs(cache_dir, exist_ok=True)
+    os.environ["TRANSFORMERS_CACHE"] = cache_dir
+    return cache_dir
+
+def login_huggingface():
+    """HuggingFace'e login ol"""
+    try:
+        login(token=HF_TOKEN)
+        logger.info("✅ HuggingFace login başarılı")
+        return True
+    except Exception as e:
+        logger.error(f"❌ HuggingFace login hatası: {str(e)}")
+        return False
+
+def download_model(model_info: Dict[str, Any]) -> bool:
+    """Tek bir modeli indir"""
+    model_id = model_info["model_id"]
+    description = model_info["description"]
+    
+    try:
+        logger.info(f"📥 İndiriliyor: {description}")
+        logger.info(f"    Model ID: {model_id}")
+        
+        # Önce tokenizer'ı indir
+        logger.info("    🔤 Tokenizer indiriliyor...")
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_id,
+            trust_remote_code=True,
+            token=HF_TOKEN
+        )
+        logger.info("    ✅ Tokenizer indirildi")
+        
+        # Sonra modeli indir
+        logger.info("    🤖 Model indiriliyor...")
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            trust_remote_code=True,
+            torch_dtype=torch.float16 if get_device() != "cpu" else torch.float32,
+            token=HF_TOKEN
+        )
+        logger.info("    ✅ Model indirildi")
+        
+        # Belleği temizle
+        del model
+        del tokenizer
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        logger.info(f"✅ {description} başarıyla indirildi!\n")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ {description} indirme hatası: {str(e)}\n")
+        return False
+
+def main():
+    """Ana fonksiyon"""
+    logger.info("🚀 CRANE AI Model İndirme Başlatılıyor...")
+    logger.info(f"🔧 Cihaz: {get_device()}")
+    
+    # Cache dizini ayarla
+    cache_dir = setup_cache_dir()
+    logger.info(f"📁 Cache dizini: {cache_dir}")
+    
+    # HuggingFace login
+    if not login_huggingface():
+        logger.error("❌ HuggingFace login başarısız. Çıkılıyor...")
+        sys.exit(1)
+    
+    # Modelleri indir
+    logger.info(f"📦 {len(MODELS_TO_DOWNLOAD)} model indirilecek...\n")
+    
+    successful_downloads = 0
+    failed_downloads = 0
+    
+    for model_name, model_info in MODELS_TO_DOWNLOAD.items():
+        if download_model(model_info):
+            successful_downloads += 1
+        else:
+            failed_downloads += 1
+    
+    # Özet
+    logger.info("="*50)
+    logger.info("📊 İNDİRME ÖZETİ")
+    logger.info("="*50)
+    logger.info(f"✅ Başarılı: {successful_downloads}")
+    logger.info(f"❌ Başarısız: {failed_downloads}")
+    logger.info(f"📁 Cache dizini: {cache_dir}")
+    
+    if successful_downloads == len(MODELS_TO_DOWNLOAD):
+        logger.info("🎉 Tüm modeller başarıyla indirildi!")
+    else:
+        logger.warning("⚠️ Bazı modeller indirilemedi.")
+    
+    logger.info("="*50)
+
+if __name__ == "__main__":
+    main() 

memory/__init__.py

@@ -0,0 +1,7 @@
+"""
+CRANE AI - Memory Package
+"""
+
+from .local_memory import LocalMemoryManager, MemorySlot
+
+__all__ = ['LocalMemoryManager', 'MemorySlot'] 

memory/local_memory.py

@@ -0,0 +1,324 @@
+"""
+CRANE AI - Local Memory Management
+"""
+
+from typing import Dict, Any, List, Optional
+import asyncio
+import time
+import json
+from dataclasses import dataclass, asdict
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class MemorySlot:
+    """Bellek slot'u veri yapısı"""
+    id: str
+    content: Any
+    timestamp: float
+    ttl: float  # Time to live (seconds)
+    access_count: int = 0
+    priority: int = 1
+    tags: List[str] = None
+    metadata: Dict[str, Any] = None
+    
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+        if self.metadata is None:
+            self.metadata = {}
+    
+    def is_expired(self) -> bool:
+        """Slot'un süresinin dolup dolmadığını kontrol eder"""
+        return time.time() > (self.timestamp + self.ttl)
+    
+    def update_access(self):
+        """Erişim sayısını günceller"""
+        self.access_count += 1
+        self.timestamp = time.time()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Dictionary'e çevirir"""
+        return asdict(self)
+
+class LocalMemoryManager:
+    """Yerel bellek yönetimi sistemi"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.max_slots = config.get("max_slots", 10)
+        self.default_ttl = config.get("default_ttl", 3600)  # 1 saat
+        self.cleanup_interval = config.get("cleanup_interval", 300)  # 5 dakika
+        
+        # Bellek slot'ları
+        self.slots: Dict[str, MemorySlot] = {}
+        
+        # İstatistikler
+        self.stats = {
+            "total_writes": 0,
+            "total_reads": 0,
+            "cache_hits": 0,
+            "cache_misses": 0,
+            "evictions": 0,
+            "cleanups": 0
+        }
+        
+        # Background cleanup task
+        self.cleanup_task = None
+        self.is_running = False
+        
+    async def start(self):
+        """Bellek yöneticisini başlatır"""
+        if not self.is_running:
+            self.is_running = True
+            self.cleanup_task = asyncio.create_task(self._cleanup_worker())
+            logger.info("Memory manager started")
+    
+    async def stop(self):
+        """Bellek yöneticisini durdurur"""
+        self.is_running = False
+        if self.cleanup_task:
+            self.cleanup_task.cancel()
+            try:
+                await self.cleanup_task
+            except asyncio.CancelledError:
+                pass
+        logger.info("Memory manager stopped")
+    
+    async def store(self, key: str, content: Any, ttl: Optional[float] = None, 
+                   priority: int = 1, tags: List[str] = None, metadata: Dict[str, Any] = None) -> bool:
+        """Bellek slot'una veri yazar"""
+        try:
+            # TTL ayarı
+            if ttl is None:
+                ttl = self.default_ttl
+            
+            # Slot oluştur
+            slot = MemorySlot(
+                id=key,
+                content=content,
+                timestamp=time.time(),
+                ttl=ttl,
+                priority=priority,
+                tags=tags or [],
+                metadata=metadata or {}
+            )
+            
+            # Yer kontrolü
+            if len(self.slots) >= self.max_slots and key not in self.slots:
+                await self._evict_slot()
+            
+            # Slot'u kaydet
+            self.slots[key] = slot
+            self.stats["total_writes"] += 1
+            
+            logger.debug(f"Stored in memory slot: {key}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Memory store error: {str(e)}")
+            return False
+    
+    async def retrieve(self, key: str) -> Optional[Any]:
+        """Bellek slot'undan veri okur"""
+        try:
+            if key not in self.slots:
+                self.stats["cache_misses"] += 1
+                return None
+            
+            slot = self.slots[key]
+            
+            # Expire kontrolü
+            if slot.is_expired():
+                await self.remove(key)
+                self.stats["cache_misses"] += 1
+                return None
+            
+            # Erişim güncelle
+            slot.update_access()
+            self.stats["total_reads"] += 1
+            self.stats["cache_hits"] += 1
+            
+            logger.debug(f"Retrieved from memory slot: {key}")
+            return slot.content
+            
+        except Exception as e:
+            logger.error(f"Memory retrieve error: {str(e)}")
+            return None
+    
+    async def remove(self, key: str) -> bool:
+        """Bellek slot'unu siler"""
+        try:
+            if key in self.slots:
+                del self.slots[key]
+                logger.debug(f"Removed memory slot: {key}")
+                return True
+            return False
+            
+        except Exception as e:
+            logger.error(f"Memory remove error: {str(e)}")
+            return False
+    
+    async def search_by_tags(self, tags: List[str]) -> List[MemorySlot]:
+        """Tag'lere göre slot'ları arar"""
+        matching_slots = []
+        
+        for slot in self.slots.values():
+            if not slot.is_expired():
+                if any(tag in slot.tags for tag in tags):
+                    matching_slots.append(slot)
+        
+        return matching_slots
+    
+    async def get_active_slots(self) -> List[MemorySlot]:
+        """Aktif slot'ları döndürür"""
+        active_slots = []
+        
+        for slot in self.slots.values():
+            if not slot.is_expired():
+                active_slots.append(slot)
+        
+        return active_slots
+    
+    async def update_slot(self, key: str, content: Any = None, ttl: Optional[float] = None,
+                         priority: Optional[int] = None, tags: Optional[List[str]] = None,
+                         metadata: Optional[Dict[str, Any]] = None) -> bool:
+        """Slot'u günceller"""
+        try:
+            if key not in self.slots:
+                return False
+            
+            slot = self.slots[key]
+            
+            # Expire kontrolü
+            if slot.is_expired():
+                await self.remove(key)
+                return False
+            
+            # Güncellemeleri uygula
+            if content is not None:
+                slot.content = content
+            if ttl is not None:
+                slot.ttl = ttl
+            if priority is not None:
+                slot.priority = priority
+            if tags is not None:
+                slot.tags = tags
+            if metadata is not None:
+                slot.metadata.update(metadata)
+            
+            slot.timestamp = time.time()
+            
+            logger.debug(f"Updated memory slot: {key}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Memory update error: {str(e)}")
+            return False
+    
+    async def _evict_slot(self):
+        """En az öncelikli slot'u çıkarır"""
+        if not self.slots:
+            return
+        
+        # En az kullanılan ve en düşük öncelikli slot'u bul
+        candidates = []
+        for slot in self.slots.values():
+            if not slot.is_expired():
+                candidates.append(slot)
+        
+        if not candidates:
+            return
+        
+        # Skorlama: düşük priority + düşük access_count + eski timestamp
+        def eviction_score(slot):
+            age = time.time() - slot.timestamp
+            return (1 / slot.priority) + (1 / max(slot.access_count, 1)) + (age / 3600)
+        
+        victim = max(candidates, key=eviction_score)
+        await self.remove(victim.id)
+        self.stats["evictions"] += 1
+        
+        logger.debug(f"Evicted memory slot: {victim.id}")
+    
+    async def _cleanup_worker(self):
+        """Periyodik temizlik işlevi"""
+        while self.is_running:
+            try:
+                await asyncio.sleep(self.cleanup_interval)
+                await self._cleanup_expired()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Cleanup worker error: {str(e)}")
+    
+    async def _cleanup_expired(self):
+        """Süresi dolmuş slot'ları temizler"""
+        expired_keys = []
+        
+        for key, slot in self.slots.items():
+            if slot.is_expired():
+                expired_keys.append(key)
+        
+        for key in expired_keys:
+            await self.remove(key)
+        
+        if expired_keys:
+            self.stats["cleanups"] += 1
+            logger.debug(f"Cleaned up {len(expired_keys)} expired slots")
+    
+    async def export_memory(self, include_expired: bool = False) -> Dict[str, Any]:
+        """Belleği dışa aktarır"""
+        export_data = {
+            "timestamp": datetime.now().isoformat(),
+            "slots": [],
+            "stats": self.stats
+        }
+        
+        for slot in self.slots.values():
+            if include_expired or not slot.is_expired():
+                export_data["slots"].append(slot.to_dict())
+        
+        return export_data
+    
+    async def import_memory(self, data: Dict[str, Any]) -> bool:
+        """Belleği içe aktarır"""
+        try:
+            slots_data = data.get("slots", [])
+            
+            for slot_data in slots_data:
+                slot = MemorySlot(**slot_data)
+                if not slot.is_expired():
+                    self.slots[slot.id] = slot
+            
+            logger.info(f"Imported {len(slots_data)} memory slots")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Memory import error: {str(e)}")
+            return False
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Bellek istatistikleri"""
+        total_requests = self.stats["total_reads"]
+        hit_rate = self.stats["cache_hits"] / max(total_requests, 1)
+        
+        active_slots = sum(1 for slot in self.slots.values() if not slot.is_expired())
+        
+        return {
+            "total_slots": len(self.slots),
+            "active_slots": active_slots,
+            "max_slots": self.max_slots,
+            "hit_rate": hit_rate,
+            "total_writes": self.stats["total_writes"],
+            "total_reads": self.stats["total_reads"],
+            "evictions": self.stats["evictions"],
+            "cleanups": self.stats["cleanups"]
+        }
+    
+    async def clear_all(self):
+        """Tüm belleği temizler"""
+        self.slots.clear()
+        logger.info("All memory slots cleared") 

modules/__init__.py

@@ -0,0 +1,15 @@
+"""
+CRANE AI - Modüller
+"""
+
+from .code_module import CodeModule
+from .chat_module import ChatModule
+from .reason_module import ReasonModule
+from .fast_module import FastModule
+
+__all__ = [
+    'CodeModule',
+    'ChatModule', 
+    'ReasonModule',
+    'FastModule'
+] 

modules/chat_module.py

@@ -0,0 +1,142 @@
+"""
+CRANE AI - Sohbet Modülü
+"""
+
+from typing import Dict, Any
+from core.base_module import BaseMicroModule
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ChatModule(BaseMicroModule):
+    """Genel sohbet için özelleşmiş modül"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(
+            model_id="Qwen/Qwen2.5-1.5B-Instruct",
+            config=config
+        )
+        
+        # Sohbet anahtar kelimeleri
+        self.chat_keywords = {
+            "merhaba", "selam", "nasılsın", "naber", "günaydın",
+            "iyi akşamlar", "hoş geldin", "sohbet", "konuş",
+            "anlat", "düşün", "fikir", "görüş", "yardım",
+            "açıkla", "izah", "detay", "örnek", "hikaye"
+        }
+        
+        # Genel konular
+        self.general_topics = {
+            "hava", "spor", "müzik", "film", "kitap", "yemek",
+            "seyahat", "hobiler", "oyun", "teknoloji", "tarih",
+            "kültür", "sanat", "bilim", "doğa", "eğitim"
+        }
+    
+    def can_handle(self, query: str, context: Dict[str, Any]) -> float:
+        """Sohbet sorguları için uygunluk skoru"""
+        query_lower = query.lower()
+        
+        # Sohbet anahtar kelimelerini kontrol et
+        chat_score = 0
+        for keyword in self.chat_keywords:
+            if keyword in query_lower:
+                chat_score += 0.15
+        
+        # Genel konuları kontrol et
+        for topic in self.general_topics:
+            if topic in query_lower:
+                chat_score += 0.1
+        
+        # Soru işaretleri ve konuşma ifadeleri
+        if "?" in query or "nedir" in query_lower or "nasıl" in query_lower:
+            chat_score += 0.2
+        
+        # Uzun açıklama gerektiren sorular
+        if any(word in query_lower for word in ["açıkla", "anlat", "detay", "neden"]):
+            chat_score += 0.25
+        
+        # Kısa ve basit sorular için yüksek skor
+        if len(query.split()) <= 10:
+            chat_score += 0.1
+        
+        # Maksimum 1.0 skor
+        return min(chat_score, 1.0)
+    
+    async def process(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Sohbet işlemi"""
+        try:
+            # Sohbet için özel prompt
+            prompt = self._build_chat_prompt(query, context)
+            
+            # Yanıt üretimi
+            response = await self.generate_response(
+                prompt,
+                max_tokens=self.config.get("max_tokens", 1024),
+                temperature=0.7  # Sohbet için orta temperature
+            )
+            
+            return {
+                "response": response,
+                "module": "chat_module",
+                "confidence": self.can_handle(query, context),
+                "conversation_type": self._detect_conversation_type(query)
+            }
+            
+        except Exception as e:
+            logger.error(f"Chat processing error: {str(e)}")
+            return {
+                "error": str(e),
+                "module": "chat_module"
+            }
+    
+    def _build_chat_prompt(self, query: str, context: Dict[str, Any]) -> str:
+        """Sohbet için prompt hazırlar"""
+        
+        # Konuşma geçmişi
+        history = context.get("history", [])
+        
+        # Temel prompt
+        prompt = f"""Sen yardımsever, dostane ve zeki bir asistansın. Kullanıcılarla doğal bir şekilde sohbet ediyorsun.
+
+Özellikler:
+- Türkçe konuşuyorsun
+- Samimi ve dostane bir ton kullanıyorsun
+- Bilgilendirici ama sıkıcı olmayan yanıtlar veriyorsun
+- Kullanıcının duygusal durumunu anlıyorsun
+
+"""
+        
+        # Konuşma geçmişi varsa ekle
+        if history:
+            prompt += "Önceki konuşma:\n"
+            for i, msg in enumerate(history[-3:]):  # Son 3 mesajı al
+                prompt += f"{'Kullanıcı' if i % 2 == 0 else 'Asistan'}: {msg}\n"
+            prompt += "\n"
+        
+        # Mevcut soru
+        prompt += f"Kullanıcı: {query}\nAsistan:"
+        
+        return prompt
+    
+    def _detect_conversation_type(self, query: str) -> str:
+        """Konuşma türünü tespit eder"""
+        query_lower = query.lower()
+        
+        # Selamlama
+        if any(word in query_lower for word in ["merhaba", "selam", "günaydın"]):
+            return "greeting"
+        
+        # Soru
+        if "?" in query or any(word in query_lower for word in ["nedir", "nasıl", "neden"]):
+            return "question"
+        
+        # Duygusal
+        if any(word in query_lower for word in ["üzgün", "mutlu", "kızgın", "heyecanlı"]):
+            return "emotional"
+        
+        # Bilgi arama
+        if any(word in query_lower for word in ["açıkla", "anlat", "öğren", "bilgi"]):
+            return "information"
+        
+        # Varsayılan
+        return "general" 

modules/code_module.py

@@ -0,0 +1,172 @@
+"""
+CRANE AI - Kod Yazım Modülü
+"""
+
+import re
+from typing import Dict, Any
+from core.base_module import BaseMicroModule
+import logging
+
+logger = logging.getLogger(__name__)
+
+class CodeModule(BaseMicroModule):
+    """Kod yazımı için özelleşmiş modül"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(
+            model_id="deepseek-ai/deepseek-coder-1.3b-instruct",
+            config=config
+        )
+        
+        # Kod kelime anahtar kelimeleri
+        self.code_keywords = {
+            "function", "class", "def", "import", "from", "return", 
+            "if", "else", "for", "while", "try", "except", "with",
+            "python", "javascript", "java", "c++", "html", "css",
+            "kod", "kodu", "script", "fonksiyon", "sınıf", "algoritma",
+            "program", "yazılım", "debug", "hata", "fix", "düzelt"
+        }
+        
+        # Programlama dilleri
+        self.programming_languages = {
+            "python", "javascript", "java", "c++", "c#", "php", "ruby",
+            "go", "rust", "kotlin", "swift", "typescript", "html", "css",
+            "sql", "bash", "powershell", "r", "matlab", "scala"
+        }
+    
+    def can_handle(self, query: str, context: Dict[str, Any]) -> float:
+        """Kod yazımı sorguları için uygunluk skoru"""
+        query_lower = query.lower()
+        
+        # Kod anahtar kelimelerini kontrol et
+        code_score = 0
+        for keyword in self.code_keywords:
+            if keyword in query_lower:
+                code_score += 0.15
+        
+        # Programlama dili belirtilmişse
+        for lang in self.programming_languages:
+            if lang in query_lower:
+                code_score += 0.3
+        
+        # Kod yazımı action kelimeleri
+        action_keywords = ["yaz", "oluştur", "geliştir", "kur", "hazırla", "tasarla"]
+        for action in action_keywords:
+            if action in query_lower:
+                code_score += 0.2
+        
+        # Kod karakteristik işaretlerini kontrol et
+        if any(char in query for char in ["()", "{}", "[]", "==", "!=", "<=", ">="]):
+            code_score += 0.15
+        
+        # Kod blokları varsa
+        if "```" in query or "def " in query or "class " in query:
+            code_score += 0.3
+        
+        # Spesifik kod türleri
+        code_types = ["hesap", "makinesi", "calculator", "app", "uygulama", "website", "site"]
+        for code_type in code_types:
+            if code_type in query_lower:
+                code_score += 0.25
+        
+        # Maksimum 1.0 skor
+        return min(code_score, 1.0)
+    
+    async def process(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Kod yazımı işlemi"""
+        try:
+            # Kod yazımı için özel prompt
+            prompt = self._build_code_prompt(query, context)
+            
+            # Kod üretimi
+            response = await self.generate_response(
+                prompt,
+                max_tokens=self.config.get("max_tokens", 2048),
+                temperature=0.1  # Kod için düşük temperature
+            )
+            
+            # Kod bloklarını ayıkla
+            code_blocks = self._extract_code_blocks(response)
+            
+            return {
+                "response": response,
+                "code_blocks": code_blocks,
+                "language": self._detect_language(query),
+                "module": "code_module",
+                "confidence": self.can_handle(query, context)
+            }
+            
+        except Exception as e:
+            logger.error(f"Code processing error: {str(e)}")
+            return {
+                "error": str(e),
+                "module": "code_module"
+            }
+    
+    def _build_code_prompt(self, query: str, context: Dict[str, Any]) -> str:
+        """Kod yazımı için prompt hazırlar"""
+        
+        # Dil tespiti
+        language = self._detect_language(query)
+        
+        # Temel prompt
+        prompt = f"""Sen bir uzman programcısın. Kullanıcının sorusunu anla ve en iyi kodu yaz.
+
+Kullanıcı sorusu: {query}
+
+Lütfen:
+1. Temiz, okunabilir kod yaz
+2. Kod açıklamalarını Türkçe yap
+3. En iyi pratikleri kullan
+4. Gerekirse örnek kullanımı göster
+
+"""
+        
+        # Dil özelinde ekleme
+        if language:
+            prompt += f"Programlama dili: {language}\n"
+        
+        # Bağlam varsa ekle
+        if context.get("history"):
+            prompt += f"Önceki konuşma: {context['history'][-1]}\n"
+        
+        return prompt
+    
+    def _detect_language(self, query: str) -> str:
+        """Sorgudan programlama dilini tespit eder"""
+        query_lower = query.lower()
+        
+        for lang in self.programming_languages:
+            if lang in query_lower:
+                return lang
+        
+        # Varsayılan dil
+        return "python"
+    
+    def _extract_code_blocks(self, response: str) -> list:
+        """Yanıttan kod bloklarını ayıklar"""
+        code_blocks = []
+        
+        # Markdown kod blokları
+        pattern = r'```(\w+)?\n(.*?)\n```'
+        matches = re.findall(pattern, response, re.DOTALL)
+        
+        for match in matches:
+            lang, code = match
+            code_blocks.append({
+                "language": lang or "text",
+                "code": code.strip()
+            })
+        
+        # Tek satır kod blokları
+        inline_pattern = r'`([^`]+)`'
+        inline_matches = re.findall(inline_pattern, response)
+        
+        for code in inline_matches:
+            if len(code) > 5:  # Çok kısa olanları atla
+                code_blocks.append({
+                    "language": "inline",
+                    "code": code.strip()
+                })
+        
+        return code_blocks 

modules/fast_module.py

@@ -0,0 +1,258 @@
+"""
+CRANE AI - Fast Response Modülü
+"""
+
+from typing import Dict, Any
+from core.base_module import BaseMicroModule
+import logging
+import asyncio
+
+# Weather tool import
+try:
+    from tools.weather_tool import WeatherTool
+    WEATHER_TOOL_AVAILABLE = True
+except ImportError:
+    WEATHER_TOOL_AVAILABLE = False
+    WeatherTool = None
+
+logger = logging.getLogger(__name__)
+
+class FastModule(BaseMicroModule):
+    """Hızlı yanıt için özelleşmiş modül"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(
+            model_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+            config=config
+        )
+        
+        # Weather tool initialize
+        if WEATHER_TOOL_AVAILABLE:
+            self.weather_tool = WeatherTool()
+        else:
+            self.weather_tool = None
+        
+        # Hızlı yanıt anahtar kelimeleri
+        self.quick_keywords = {
+            "hızlı", "kısa", "özet", "basit", "kolay",
+            "evet", "hayır", "doğru", "yanlış", "kim",
+            "ne", "nerede", "ne zaman", "kaç", "hangi",
+            "merhaba", "selam", "teşekkür", "tamam"
+        }
+        
+        # Basit soru türleri
+        self.simple_patterns = {
+            "greeting": ["merhaba", "selam", "günaydın", "iyi akşam"],
+            "thanks": ["teşekkür", "sağol", "merci"],
+            "simple_question": ["kim", "ne", "nerede", "kaç"],
+            "yes_no": ["mı", "mi", "mu", "mü"],
+            "time": ["saat", "tarih", "zaman"],
+            "weather": ["hava", "sıcaklık", "yağmur"]
+        }
+        
+        # Hazır yanıtlar
+        self.quick_responses = {
+            "greeting": [
+                "Merhaba! Size nasıl yardımcı olabilirim?",
+                "Selam! Bugün nasılsınız?",
+                "Günaydın! Ne yapmak istiyorsunuz?"
+            ],
+            "thanks": [
+                "Rica ederim! Başka bir konuda yardımcı olabilir miyim?",
+                "Bir şey değil! Başka sorunuz var mı?",
+                "Memnun oldum! Size daha nasıl yardımcı olabilirim?"
+            ],
+            "unknown": [
+                "Bu konuda daha detaylı bilgi verebilir miyim?",
+                "Sorunuzu biraz daha açabilir misiniz?",
+                "Bu konuda size yardımcı olmak istiyorum."
+            ]
+        }
+    
+    def can_handle(self, query: str, context: Dict[str, Any]) -> float:
+        """Hızlı yanıt sorguları için uygunluk skoru"""
+        query_lower = query.lower()
+        
+        # Kod anahtar kelimelerini kontrol et (negatif skor)
+        code_keywords = {
+            "function", "class", "def", "import", "from", "return", 
+            "if", "else", "for", "while", "try", "except", "with",
+            "python", "javascript", "java", "c++", "html", "css",
+            "kod", "kodu", "script", "fonksiyon", "sınıf", "algoritma",
+            "program", "yazılım", "debug", "hata", "fix", "düzelt",
+            "yaz", "oluştur", "geliştir", "hesap", "makinesi"
+        }
+        
+        # Kod soruları için düşük skor
+        for keyword in code_keywords:
+            if keyword in query_lower:
+                return 0.1  # Çok düşük skor
+        
+        # Hızlı yanıt anahtar kelimelerini kontrol et
+        quick_score = 0
+        for keyword in self.quick_keywords:
+            if keyword in query_lower:
+                quick_score += 0.15
+        
+        # Basit soru pattern'larını kontrol et
+        for pattern_type, patterns in self.simple_patterns.items():
+            for pattern in patterns:
+                if pattern in query_lower:
+                    quick_score += 0.2
+        
+        # Kısa sorular için yüksek skor
+        word_count = len(query.split())
+        if word_count <= 5:
+            quick_score += 0.3
+        elif word_count <= 10:
+            quick_score += 0.2
+        
+        # Selamlama ve teşekkür ifadeleri
+        if any(word in query_lower for word in ["merhaba", "selam", "teşekkür", "sağol"]):
+            quick_score += 0.4
+        
+        # Evet/hayır soruları
+        if any(ending in query_lower for ending in ["mı?", "mi?", "mu?", "mü?"]):
+            quick_score += 0.25
+        
+        # Hava durumu soruları için yüksek skor
+        if self.weather_tool and self.weather_tool.can_handle(query):
+            quick_score += 0.6
+        
+        # Maksimum 1.0 skor
+        return min(quick_score, 1.0)
+    
+    async def process(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Hızlı yanıt işlemi"""
+        try:
+            # Weather tool kontrolü
+            if self.weather_tool and self.weather_tool.can_handle(query):
+                weather_response = await self.weather_tool.process_weather_query(query)
+                return {
+                    "response": weather_response,
+                    "module": "fast_module",
+                    "confidence": self.can_handle(query, context),
+                    "response_type": "weather_tool",
+                    "cached": False,
+                    "tool_used": "weather_api"
+                }
+            
+            # Önce hazır yanıt kontrolü
+            quick_response = self._check_quick_response(query)
+            if quick_response:
+                return {
+                    "response": quick_response,
+                    "module": "fast_module",
+                    "confidence": self.can_handle(query, context),
+                    "response_type": "quick",
+                    "cached": True
+                }
+            
+            # Hızlı yanıt için özel prompt
+            prompt = self._build_fast_prompt(query, context)
+            
+            # Yanıt üretimi (düşük token limit)
+            response = await self.generate_response(
+                prompt,
+                max_tokens=min(self.config.get("max_tokens", 512), 256),  # Maksimum 256 token
+                temperature=0.8  # Hızlı yanıt için yüksek temperature
+            )
+            
+            return {
+                "response": response,
+                "module": "fast_module",
+                "confidence": self.can_handle(query, context),
+                "response_type": "generated",
+                "cached": False
+            }
+            
+        except Exception as e:
+            logger.error(f"Fast processing error: {str(e)}")
+            return {
+                "error": str(e),
+                "module": "fast_module"
+            }
+    
+    def _check_quick_response(self, query: str) -> str:
+        """Hazır yanıtları kontrol eder"""
+        query_lower = query.lower()
+        
+        # Selamlama kontrolü
+        if any(word in query_lower for word in self.simple_patterns["greeting"]):
+            import random
+            return random.choice(self.quick_responses["greeting"])
+        
+        # Teşekkür kontrolü
+        if any(word in query_lower for word in self.simple_patterns["thanks"]):
+            import random
+            return random.choice(self.quick_responses["thanks"])
+        
+        # Basit evet/hayır soruları
+        if len(query.split()) <= 3:
+            if any(ending in query_lower for ending in ["mı?", "mi?", "mu?", "mü?"]):
+                return "Bu konuda kesin bir yanıt verebilmek için biraz daha detay gerekiyor."
+        
+        return None
+    
+    def _build_fast_prompt(self, query: str, context: Dict[str, Any]) -> str:
+        """Hızlı yanıt için prompt hazırlar"""
+        
+        # Sorgu türünü belirle
+        query_type = self._detect_query_type(query)
+        
+        # Temel prompt
+        prompt = f"""Sen hızlı ve özlü yanıtlar veren bir asistansın. Kısa ve net cevaplar veriyorsun.
+
+Kullanıcı sorusu: {query}
+
+Lütfen:
+1. Kısa ve net yanıt ver
+2. Gereksiz detaylara girme
+3. Doğrudan soruyu yanıtla
+4. Maksimum 2-3 cümle kullan
+
+Soru türü: {query_type}
+"""
+        
+        # Bağlam varsa kısaca ekle
+        if context.get("history"):
+            last_msg = context["history"][-1]
+            if len(last_msg) < 100:  # Sadece kısa geçmişi ekle
+                prompt += f"\nÖnceki: {last_msg}\n"
+        
+        return prompt
+    
+    def _detect_query_type(self, query: str) -> str:
+        """Sorgu türünü tespit eder"""
+        query_lower = query.lower()
+        
+        # Selamlama
+        if any(word in query_lower for word in self.simple_patterns["greeting"]):
+            return "greeting"
+        
+        # Teşekkür
+        if any(word in query_lower for word in self.simple_patterns["thanks"]):
+            return "thanks"
+        
+        # Basit soru
+        if any(word in query_lower for word in self.simple_patterns["simple_question"]):
+            return "simple_question"
+        
+        # Evet/hayır
+        if any(ending in query_lower for ending in ["mı?", "mi?", "mu?", "mü?"]):
+            return "yes_no"
+        
+        # Zaman
+        if any(word in query_lower for word in self.simple_patterns["time"]):
+            return "time"
+        
+        # Hava
+        if any(word in query_lower for word in self.simple_patterns["weather"]):
+            return "weather"
+        
+        # Kısa soru
+        if len(query.split()) <= 5:
+            return "short_question"
+        
+        # Varsayılan
+        return "general" 

modules/reason_module.py

@@ -0,0 +1,196 @@
+"""
+CRANE AI - Reasoning Modülü
+"""
+
+from typing import Dict, Any
+from core.base_module import BaseMicroModule
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ReasonModule(BaseMicroModule):
+    """Mantık yürütme için özelleşmiş modül"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(
+            model_id="microsoft/Phi-3-mini-4k-instruct",
+            config=config
+        )
+        
+        # Mantık yürütme anahtar kelimeleri
+        self.reasoning_keywords = {
+            "çünkü", "neden", "sebep", "niye", "nasıl", "analiz",
+            "karşılaştır", "değerlendir", "açıkla", "kanıtla",
+            "sonuç", "çıkarım", "mantık", "düşünce", "fikir",
+            "strateji", "plan", "çözüm", "problem", "sorun",
+            "avantaj", "dezavantaj", "fark", "benzerlik"
+        }
+        
+        # Analiz türleri
+        self.analysis_types = {
+            "problem_solving", "comparison", "evaluation", 
+            "cause_effect", "strategy", "pros_cons"
+        }
+    
+    def can_handle(self, query: str, context: Dict[str, Any]) -> float:
+        """Mantık yürütme sorguları için uygunluk skoru"""
+        query_lower = query.lower()
+        
+        # Mantık yürütme anahtar kelimelerini kontrol et
+        reasoning_score = 0
+        for keyword in self.reasoning_keywords:
+            if keyword in query_lower:
+                reasoning_score += 0.12
+        
+        # Soru türlerini kontrol et
+        if "neden" in query_lower or "çünkü" in query_lower:
+            reasoning_score += 0.25
+        
+        # Karşılaştırma ifadeleri
+        if any(word in query_lower for word in ["karşılaştır", "fark", "benzer", "hangisi"]):
+            reasoning_score += 0.2
+        
+        # Analiz gerektiren ifadeler
+        if any(word in query_lower for word in ["analiz", "değerlendir", "incele", "araştır"]):
+            reasoning_score += 0.2
+        
+        # Problem çözme ifadeleri
+        if any(word in query_lower for word in ["problem", "sorun", "çözüm", "nasıl"]):
+            reasoning_score += 0.15
+        
+        # Uzun ve karmaşık sorular
+        if len(query.split()) > 15:
+            reasoning_score += 0.1
+        
+        # Maksimum 1.0 skor
+        return min(reasoning_score, 1.0)
+    
+    async def process(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Mantık yürütme işlemi"""
+        try:
+            # Analiz türünü belirle
+            analysis_type = self._detect_analysis_type(query)
+            
+            # Mantık yürütme için özel prompt
+            prompt = self._build_reasoning_prompt(query, context, analysis_type)
+            
+            # Yanıt üretimi
+            response = await self.generate_response(
+                prompt,
+                max_tokens=self.config.get("max_tokens", 1024),
+                temperature=0.3  # Mantık yürütme için düşük temperature
+            )
+            
+            return {
+                "response": response,
+                "module": "reason_module",
+                "confidence": self.can_handle(query, context),
+                "analysis_type": analysis_type,
+                "reasoning_steps": self._extract_reasoning_steps(response)
+            }
+            
+        except Exception as e:
+            logger.error(f"Reasoning processing error: {str(e)}")
+            return {
+                "error": str(e),
+                "module": "reason_module"
+            }
+    
+    def _build_reasoning_prompt(self, query: str, context: Dict[str, Any], analysis_type: str) -> str:
+        """Mantık yürütme için prompt hazırlar"""
+        
+        # Analiz türüne göre özel prompt
+        if analysis_type == "problem_solving":
+            system_prompt = """Sen bir problem çözme uzmanısın. Sorunları adım adım analiz edip mantıklı çözümler üretiyorsun."""
+        elif analysis_type == "comparison":
+            system_prompt = """Sen bir karşılaştırma uzmanısın. Farklı seçenekleri objektif bir şekilde karşılaştırıyorsun."""
+        elif analysis_type == "evaluation":
+            system_prompt = """Sen bir değerlendirme uzmanısın. Durumları kapsamlı bir şekilde analiz ediyorsun."""
+        elif analysis_type == "cause_effect":
+            system_prompt = """Sen bir sebep-sonuç analizi uzmanısın. Olaylar arasındaki ilişkileri açıklıyorsun."""
+        else:
+            system_prompt = """Sen bir mantık yürütme uzmanısın. Karmaşık konuları açık ve anlaşılır şekilde analiz ediyorsun."""
+        
+        # Temel prompt
+        prompt = f"""{system_prompt}
+
+Kullanıcı sorusu: {query}
+
+Lütfen:
+1. Konuyu kapsamlı analiz et
+2. Mantık zincirini açıkla
+3. Somut örnekler ver
+4. Sonuçları net bir şekilde özetle
+
+Analiz türü: {analysis_type}
+"""
+        
+        # Bağlam varsa ekle
+        if context.get("history"):
+            prompt += f"\nÖnceki konuşma: {context['history'][-1]}\n"
+        
+        return prompt
+    
+    def _detect_analysis_type(self, query: str) -> str:
+        """Sorgudan analiz türünü tespit eder"""
+        query_lower = query.lower()
+        
+        # Problem çözme
+        if any(word in query_lower for word in ["problem", "sorun", "çöz", "nasıl"]):
+            return "problem_solving"
+        
+        # Karşılaştırma
+        if any(word in query_lower for word in ["karşılaştır", "fark", "hangisi", "seç"]):
+            return "comparison"
+        
+        # Değerlendirme
+        if any(word in query_lower for word in ["değerlendir", "incele", "analiz"]):
+            return "evaluation"
+        
+        # Sebep-sonuç
+        if any(word in query_lower for word in ["neden", "çünkü", "sebep", "sonuç"]):
+            return "cause_effect"
+        
+        # Strateji
+        if any(word in query_lower for word in ["strateji", "plan", "yaklaşım"]):
+            return "strategy"
+        
+        # Avantaj-dezavantaj
+        if any(word in query_lower for word in ["avantaj", "dezavantaj", "artı", "eksi"]):
+            return "pros_cons"
+        
+        # Varsayılan
+        return "general_reasoning"
+    
+    def _extract_reasoning_steps(self, response: str) -> list:
+        """Yanıttan mantık yürütme adımlarını çıkarır"""
+        steps = []
+        
+        # Numaralı adımları bul
+        import re
+        numbered_steps = re.findall(r'(\d+[\.\)])\s*([^\n]+)', response)
+        
+        for num, step in numbered_steps:
+            steps.append({
+                "step": num,
+                "description": step.strip()
+            })
+        
+        # Anahtar kelimelerle adımları bul
+        key_phrases = [
+            "ilk olarak", "öncelikle", "birincisi",
+            "ikincisi", "üçüncüsü", "son olarak",
+            "sonuç olarak", "özetle", "bu nedenle"
+        ]
+        
+        sentences = response.split('.')
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if any(phrase in sentence.lower() for phrase in key_phrases):
+                if len(sentence) > 10:  # Çok kısa olanları atla
+                    steps.append({
+                        "step": "auto",
+                        "description": sentence
+                    })
+        
+        return steps[:10]  # Maksimum 10 adım 

requirements.txt

@@ -1,10 +1,18 @@
 torch>=2.0.0
-gradio==4.26.0
-transformers>=4.30.0
-accelerate>=0.20.0
-bitsandbytes>=0.41.0
+transformers==4.41.0
+accelerate>=0.28.0
+tokenizers>=0.19.0
+gradio==4.29.0
 spaces>=0.19.0
+requests>=2.31.0
+aiohttp>=3.9.0
 numpy>=1.24.0
-sentencepiece>=0.1.99
-protobuf>=3.20.0
-safetensors>=0.3.0 
+psutil>=5.9.0
+huggingface_hub>=0.20.0
+safetensors>=0.4.0
+peft==0.10.0
+bitsandbytes==0.43.0
+pydantic>=2.6.0
+python-multipart>=0.0.9
+aiofiles>=23.2.0
+jinja2>=3.1.3

router/__init__.py

@@ -0,0 +1,7 @@
+"""
+CRANE AI - Router Package
+"""
+
+from .intelligent_router import IntelligentRouter
+
+__all__ = ['IntelligentRouter'] 

router/intelligent_router.py

@@ -0,0 +1,306 @@
+"""
+CRANE AI - Intelligent Router Layer
+"""
+
+from typing import Dict, Any, List, Optional
+import asyncio
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+import json
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class RoutingDecision:
+    """Routing kararı için veri sınıfı"""
+    module_name: str
+    confidence: float
+    priority: int
+    reasoning: str
+    estimated_time: float
+
+class IntelligentRouter:
+    """Sorguları en uygun modüllere yönlendiren router"""
+    
+    def __init__(self, modules: Dict[str, Any], config: Dict[str, Any]):
+        self.modules = modules
+        self.config = config
+        self.routing_history = []
+        self.performance_stats = {}
+        
+        # Routing parametreleri
+        self.confidence_threshold = config.get("confidence_threshold", 0.7)
+        self.max_concurrent = config.get("max_concurrent_requests", 4)
+        self.timeout = config.get("timeout", 30)
+        self.fallback_module = config.get("fallback_module", "fast_module")
+        
+        # Performans takibi
+        self.total_requests = 0
+        self.successful_routings = 0
+        self.failed_routings = 0
+        
+    async def route_query(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Ana routing fonksiyonu"""
+        try:
+            start_time = datetime.now()
+            
+            # Routing kararı al
+            routing_decisions = await self._analyze_query(query, context)
+            
+            # En iyi modülü seç
+            best_module = self._select_best_module(routing_decisions)
+            
+            if not best_module:
+                # Fallback modülü kullan
+                best_module = RoutingDecision(
+                    module_name=self.fallback_module,
+                    confidence=0.5,
+                    priority=999,
+                    reasoning="Fallback module used",
+                    estimated_time=2.0
+                )
+            
+            # Modülü çalıştır
+            result = await self._execute_module(
+                best_module.module_name,
+                query,
+                context
+            )
+            
+            # Performans güncelle
+            execution_time = (datetime.now() - start_time).total_seconds()
+            self._update_performance_stats(
+                best_module.module_name,
+                execution_time,
+                True
+            )
+            
+            # Routing geçmişini güncelle
+            self._update_routing_history(query, best_module, result, execution_time)
+            
+            # Sonuç ekle
+            result["routing_info"] = {
+                "selected_module": best_module.module_name,
+                "confidence": best_module.confidence,
+                "reasoning": best_module.reasoning,
+                "execution_time": execution_time,
+                "all_candidates": [
+                    {
+                        "module": decision.module_name,
+                        "confidence": decision.confidence,
+                        "priority": decision.priority
+                    }
+                    for decision in routing_decisions
+                ]
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Routing error: {str(e)}")
+            self.failed_routings += 1
+            
+            # Hata durumunda fallback
+            return await self._execute_fallback(query, context, str(e))
+    
+    async def _analyze_query(self, query: str, context: Dict[str, Any]) -> List[RoutingDecision]:
+        """Sorguyu analiz eder ve tüm modüllerin skorlarını hesaplar"""
+        decisions = []
+        
+        # Tüm modülleri paralel olarak test et
+        tasks = []
+        for module_name, module in self.modules.items():
+            if hasattr(module, 'can_handle'):
+                task = asyncio.create_task(
+                    self._evaluate_module(module_name, module, query, context)
+                )
+                tasks.append(task)
+        
+        # Sonuçları topla
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, RoutingDecision):
+                decisions.append(result)
+            elif isinstance(result, Exception):
+                logger.warning(f"Module evaluation error: {str(result)}")
+        
+        # Confidence'a göre sırala
+        decisions.sort(key=lambda x: x.confidence, reverse=True)
+        
+        return decisions
+    
+    async def _evaluate_module(self, module_name: str, module: Any, query: str, context: Dict[str, Any]) -> RoutingDecision:
+        """Tek bir modülü değerlendirir"""
+        try:
+            # Can_handle skorunu al
+            confidence = module.can_handle(query, context)
+            
+            # Modül performansını kontrol et
+            performance = self.performance_stats.get(module_name, {})
+            avg_time = performance.get("avg_execution_time", 2.0)
+            success_rate = performance.get("success_rate", 0.8)
+            
+            # Confidence'ı performansa göre ayarla
+            adjusted_confidence = confidence * success_rate
+            
+            # Priority'yi config'den al
+            priority = module.config.get("priority", 1)
+            
+            # Reasoning oluştur
+            reasoning = self._generate_reasoning(
+                module_name, confidence, performance, query
+            )
+            
+            return RoutingDecision(
+                module_name=module_name,
+                confidence=adjusted_confidence,
+                priority=priority,
+                reasoning=reasoning,
+                estimated_time=avg_time
+            )
+            
+        except Exception as e:
+            logger.error(f"Error evaluating module {module_name}: {str(e)}")
+            return RoutingDecision(
+                module_name=module_name,
+                confidence=0.0,
+                priority=999,
+                reasoning=f"Evaluation error: {str(e)}",
+                estimated_time=10.0
+            )
+    
+    def _select_best_module(self, decisions: List[RoutingDecision]) -> Optional[RoutingDecision]:
+        """En iyi modülü seçer"""
+        if not decisions:
+            return None
+        
+        # Confidence threshold'u geçenleri filtrele
+        qualified = [d for d in decisions if d.confidence >= self.confidence_threshold]
+        
+        if not qualified:
+            # Eğer hiçbiri threshold'u geçmiyorsa en yüksek skorluyu al
+            qualified = [decisions[0]]
+        
+        # Priority ve confidence'a göre sırala
+        qualified.sort(key=lambda x: (x.priority, -x.confidence))
+        
+        return qualified[0]
+    
+    async def _execute_module(self, module_name: str, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Seçilen modülü çalıştırır"""
+        try:
+            module = self.modules.get(module_name)
+            if not module:
+                raise Exception(f"Module {module_name} not found")
+            
+            # Timeout ile çalıştır
+            result = await asyncio.wait_for(
+                module.process(query, context),
+                timeout=self.timeout
+            )
+            
+            self.successful_routings += 1
+            return result
+            
+        except asyncio.TimeoutError:
+            logger.error(f"Module {module_name} timed out")
+            raise Exception(f"Module {module_name} execution timeout")
+        except Exception as e:
+            logger.error(f"Module {module_name} execution error: {str(e)}")
+            raise
+    
+    async def _execute_fallback(self, query: str, context: Dict[str, Any], error: str) -> Dict[str, Any]:
+        """Fallback modülü çalıştırır"""
+        try:
+            fallback_module = self.modules.get(self.fallback_module)
+            if fallback_module:
+                result = await fallback_module.process(query, context)
+                result["fallback_used"] = True
+                result["original_error"] = error
+                return result
+            else:
+                return {
+                    "error": f"Routing failed and no fallback available: {error}",
+                    "fallback_used": True
+                }
+        except Exception as e:
+            return {
+                "error": f"Both routing and fallback failed: {error}, {str(e)}",
+                "fallback_used": True
+            }
+    
+    def _update_performance_stats(self, module_name: str, execution_time: float, success: bool):
+        """Performans istatistiklerini günceller"""
+        if module_name not in self.performance_stats:
+            self.performance_stats[module_name] = {
+                "total_requests": 0,
+                "successful_requests": 0,
+                "total_time": 0,
+                "avg_execution_time": 0,
+                "success_rate": 0
+            }
+        
+        stats = self.performance_stats[module_name]
+        stats["total_requests"] += 1
+        stats["total_time"] += execution_time
+        
+        if success:
+            stats["successful_requests"] += 1
+        
+        # Ortalama süre & başarı oranı
+        stats["avg_execution_time"] = stats["total_time"] / max(stats["total_requests"], 1)
+        stats["success_rate"] = stats["successful_requests"] / max(stats["total_requests"], 1)
+        
+        self.total_requests += 1
+    
+    def _update_routing_history(self, query: str, decision: RoutingDecision, result: Dict[str, Any], execution_time: float):
+        """Routing geçmişini günceller"""
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "query": query[:100],  # İlk 100 karakter
+            "selected_module": decision.module_name,
+            "confidence": decision.confidence,
+            "execution_time": execution_time,
+            "success": "error" not in result
+        }
+        
+        self.routing_history.append(entry)
+        
+        # Geçmişi sınırla (son 1000 entry)
+        if len(self.routing_history) > 1000:
+            self.routing_history = self.routing_history[-1000:]
+    
+    def _generate_reasoning(self, module_name: str, confidence: float, performance: Dict[str, Any], query: str) -> str:
+        """Routing kararı için açıklama oluşturur"""
+        reasons = []
+        
+        if confidence > 0.8:
+            reasons.append(f"Yüksek confidence skoru ({confidence:.2f})")
+        elif confidence > 0.6:
+            reasons.append(f"Orta confidence skoru ({confidence:.2f})")
+        else:
+            reasons.append(f"Düşük confidence skoru ({confidence:.2f})")
+        
+        if performance:
+            success_rate = performance.get("success_rate", 0)
+            if success_rate > 0.9:
+                reasons.append("Yüksek başarı oranı")
+            elif success_rate > 0.7:
+                reasons.append("Orta başarı oranı")
+            else:
+                reasons.append("Düşük başarı oranı")
+        
+        return ", ".join(reasons)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Router istatistiklerini döndürür"""
+        return {
+            "total_requests": self.total_requests,
+            "successful_routings": self.successful_routings,
+            "failed_routings": self.failed_routings,
+            "success_rate": self.successful_routings / max(self.total_requests, 1),
+            "module_performance": self.performance_stats,
+            "recent_history": self.routing_history[-10:]  # Son 10 routing
+        } 

setup.py

@@ -0,0 +1,186 @@
+"""
+CRANE AI - Kurulum Scripti
+"""
+
+import asyncio
+import logging
+import os
+import sys
+from pathlib import Path
+
+# Logging ayarları
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class CRANESetup:
+    """CRANE AI kurulum sınıfı"""
+    
+    def __init__(self):
+        self.project_root = Path(__file__).parent
+        self.required_dirs = [
+            "logs",
+            "models",
+            "cache",
+            "data",
+            "exports"
+        ]
+        
+    async def setup_system(self):
+        """Sistemi kurar"""
+        try:
+            logger.info("🏗️  CRANE AI Kurulumu Başlatılıyor...")
+            
+            # Dizinleri oluştur
+            await self._create_directories()
+            
+            # Paketleri kontrol et
+            await self._check_packages()
+            
+            # Hugging Face token'ını kontrol et
+            await self._check_hf_token()
+            
+            # Modelleri hazırla
+            await self._prepare_models()
+            
+            # Test çalıştır
+            await self._run_tests()
+            
+            logger.info("✅ CRANE AI Kurulumu Başarıyla Tamamlandı!")
+            logger.info("🚀 Sistemi başlatmak için: python main.py")
+            
+        except Exception as e:
+            logger.error(f"❌ Kurulum hatası: {str(e)}")
+            sys.exit(1)
+    
+    async def _create_directories(self):
+        """Gerekli dizinleri oluşturur"""
+        logger.info("📁 Dizinler oluşturuluyor...")
+        
+        for dir_name in self.required_dirs:
+            dir_path = self.project_root / dir_name
+            dir_path.mkdir(exist_ok=True)
+            logger.info(f"  ✅ {dir_name}/ oluşturuldu")
+        
+        # __init__.py dosyalarını oluştur
+        init_files = [
+            "core/__init__.py",
+            "router/__init__.py",
+            "memory/__init__.py",
+            "config/__init__.py"
+        ]
+        
+        for init_file in init_files:
+            init_path = self.project_root / init_file
+            init_path.parent.mkdir(exist_ok=True)
+            if not init_path.exists():
+                init_path.write_text('"""Package initialization"""')
+                logger.info(f"  ✅ {init_file} oluşturuldu")
+    
+    async def _check_packages(self):
+        """Gerekli paketleri kontrol eder"""
+        logger.info("📦 Paketler kontrol ediliyor...")
+        
+        required_packages = [
+            "torch",
+            "transformers",
+            "fastapi",
+            "uvicorn",
+            "gradio",
+            "numpy",
+            "requests",
+            "psutil"
+        ]
+        
+        missing_packages = []
+        
+        for package in required_packages:
+            try:
+                __import__(package)
+                logger.info(f"  ✅ {package} mevcut")
+            except ImportError:
+                missing_packages.append(package)
+                logger.warning(f"  ❌ {package} eksik")
+        
+        if missing_packages:
+            logger.error(f"❌ Eksik paketler: {', '.join(missing_packages)}")
+            logger.info("💡 Çözüm: pip install -r requirements.txt")
+            raise Exception("Eksik paketler var")
+    
+    async def _check_hf_token(self):
+        """Hugging Face token'ını kontrol eder"""
+        logger.info("🔑 Hugging Face token kontrol ediliyor...")
+        
+        from config.settings import HF_TOKEN
+        
+        if not HF_TOKEN or HF_TOKEN == "YOUR_TOKEN_HERE":
+            logger.error("❌ Hugging Face token bulunamadı")
+            logger.info("💡 config/settings.py dosyasında HF_TOKEN'ı ayarlayın")
+            raise Exception("Hugging Face token gerekli")
+        
+        # Token'ın geçerli olup olmadığını kontrol et
+        try:
+            from huggingface_hub import HfApi
+            api = HfApi()
+            user_info = api.whoami(token=HF_TOKEN)
+            logger.info(f"  ✅ Token geçerli: {user_info.get('name', 'Unknown')}")
+        except Exception as e:
+            logger.error(f"❌ Token geçersiz: {str(e)}")
+            raise Exception("Hugging Face token geçersiz")
+    
+    async def _prepare_models(self):
+        """Modelleri hazırlar"""
+        logger.info("🤖 Modeller hazırlanıyor...")
+        
+        from config.settings import MODELS, DEVICE
+        
+        # Cihaz bilgisini göster
+        logger.info(f"  🖥️  Cihaz: {DEVICE}")
+        
+        # Model bilgilerini göster
+        for model_name, model_config in MODELS.items():
+            model_id = model_config["model_id"]
+            logger.info(f"  📋 {model_name}: {model_id}")
+            
+            # Model cache'ini kontrol et
+            cache_dir = self.project_root / "cache" / model_name
+            cache_dir.mkdir(exist_ok=True)
+        
+        logger.info("  ✅ Modeller hazırlandı")
+    
+    async def _run_tests(self):
+        """Basit testler çalıştırır"""
+        logger.info("🧪 Testler çalıştırılıyor...")
+        
+        try:
+            # Router testi
+            from router.intelligent_router import IntelligentRouter
+            logger.info("  ✅ Router importu başarılı")
+            
+            # Modül testleri
+            from modules import CodeModule, ChatModule, ReasonModule, FastModule
+            logger.info("  ✅ Modül importları başarılı")
+            
+            # Memory testi
+            from memory.local_memory import LocalMemoryManager
+            logger.info("  ✅ Memory Manager importu başarılı")
+            
+            # Token layer testi
+            from core.token_capsule import TokenCapsuleLayer
+            logger.info("  ✅ Token Capsule Layer importu başarılı")
+            
+            logger.info("  ✅ Tüm testler başarılı")
+            
+        except Exception as e:
+            logger.error(f"❌ Test hatası: {str(e)}")
+            raise Exception("Sistem testleri başarısız")
+
+def main():
+    """Ana kurulum fonksiyonu"""
+    setup = CRANESetup()
+    asyncio.run(setup.setup_system())
+
+if __name__ == "__main__":
+    main() 

tools/__init__.py

@@ -0,0 +1,7 @@
+"""
+CRANE AI - External Tools Package
+"""
+
+from .weather_tool import WeatherTool
+ 
+__all__ = ['WeatherTool'] 

tools/weather_tool.py

@@ -0,0 +1,135 @@
+"""
+CRANE AI - Weather Tool
+Gerçek zamanlı hava durumu verisi için tool
+"""
+
+import asyncio
+import json
+from typing import Dict, Any, Optional
+import logging
+
+try:
+    import aiohttp
+    AIOHTTP_AVAILABLE = True
+except ImportError:
+    import requests
+    AIOHTTP_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+class WeatherTool:
+    """Hava durumu sorguları için external tool"""
+    
+    def __init__(self):
+        # Ücretsiz OpenWeatherMap API kullanabiliriz
+        self.base_url = "http://api.openweathermap.org/data/2.5/weather"
+        self.api_key = None  # API key gerekirse eklenebilir
+        
+        # Alternatif olarak wttr.in kullanabiliriz (ücretsiz)
+        self.wttr_url = "http://wttr.in/{city}?format=j1"
+    
+    def can_handle(self, query: str) -> bool:
+        """Bu tool'un handle edebileceği sorguları tespit eder"""
+        weather_keywords = [
+            "hava", "weather", "sıcaklık", "temperature", "yağmur", "rain",
+            "kar", "snow", "rüzgar", "wind", "nem", "humidity", "güneş", "sun",
+            "bulut", "cloud", "fırtına", "storm", "bugün", "today", "yarın", "tomorrow"
+        ]
+        
+        query_lower = query.lower()
+        return any(keyword in query_lower for keyword in weather_keywords)
+    
+    async def get_weather(self, city: str = "Istanbul") -> Dict[str, Any]:
+        """Belirtilen şehir için hava durumu bilgisi alır"""
+        try:
+            # wttr.in API kullan (ücretsiz ve API key gerektirmez)
+            url = f"http://wttr.in/{city}?format=j1"
+            
+            if AIOHTTP_AVAILABLE:
+                # Async aiohttp kullan
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                        if response.status == 200:
+                            data = await response.json()
+                        else:
+                            return {
+                                "error": f"API response error: {response.status}",
+                                "status": "error"
+                            }
+            else:
+                # Fallback to sync requests
+                import requests
+                response = requests.get(url, timeout=10)
+                if response.status_code == 200:
+                    data = response.json()
+                else:
+                    return {
+                        "error": f"API response error: {response.status_code}",
+                        "status": "error"
+                    }
+            
+            # Veriyi parse et
+            current = data.get("current_condition", [{}])[0]
+            weather_desc = current.get("weatherDesc", [{}])[0].get("value", "Bilinmiyor")
+            temp_c = current.get("temp_C", "N/A")
+            humidity = current.get("humidity", "N/A")
+            wind_speed = current.get("windspeedKmph", "N/A")
+            
+            return {
+                "city": city,
+                "temperature": f"{temp_c}°C",
+                "description": weather_desc,
+                "humidity": f"{humidity}%",
+                "wind_speed": f"{wind_speed} km/h",
+                "status": "success"
+            }
+                
+        except Exception as e:
+            logger.error(f"Weather API error: {str(e)}")
+            return {
+                "error": str(e),
+                "status": "error"
+            }
+    
+    def extract_city(self, query: str) -> str:
+        """Sorgudan şehir adını çıkarır"""
+        # Türk şehirleri
+        turkish_cities = [
+            "istanbul", "ankara", "izmir", "bursa", "antalya", "adana",
+            "konya", "gaziantep", "mersin", "diyarbakır", "kayseri", "eskişehir"
+        ]
+        
+        query_lower = query.lower()
+        
+        # Şehir adı geçiyorsa onu al
+        for city in turkish_cities:
+            if city in query_lower:
+                return city.title()
+        
+        # Şehir belirtilmemişse İstanbul default
+        return "Istanbul"
+    
+    async def process_weather_query(self, query: str) -> str:
+        """Hava durumu sorgusunu işler ve yanıt oluşturur"""
+        try:
+            # Şehri tespit et
+            city = self.extract_city(query)
+            
+            # Hava durumu bilgisini al
+            weather_data = await self.get_weather(city)
+            
+            if weather_data.get("status") == "success":
+                return f"""🌤️ **{city} Hava Durumu:**
+
+🌡️ **Sıcaklık:** {weather_data['temperature']}
+☁️ **Durum:** {weather_data['description']}
+💧 **Nem:** {weather_data['humidity']}
+💨 **Rüzgar:** {weather_data['wind_speed']}
+
+*Güncel bilgi - API üzerinden alındı*"""
+            else:
+                return f"❌ Hava durumu bilgisi alınamadı: {weather_data.get('error', 'Bilinmeyen hata')}"
+                
+        except Exception as e:
+            logger.error(f"Weather query processing error: {str(e)}")
+            return f"❌ Hava durumu servisi şu anda kullanılamıyor: {str(e)}" 

training/__init__.py

@@ -0,0 +1 @@
+ 

training/fine_tune.py

@@ -0,0 +1,96 @@
+"""Fine-tune CRANE AI modelleri (LoRA/QLoRA).
+
+Kullanım:
+    python training/fine_tune.py --module code_module --data data/code_train.jsonl --output adapters/code_module
+
+Varsayılan hiper-parametreler configte yer alır; CLI arg'ları ile override edilebilir.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import json
+import logging
+from pathlib import Path
+
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer
+
+MODEL_MAP = {
+    "code_module": "deepseek-ai/deepseek-coder-1.3b-instruct",
+    "chat_module": "Qwen/Qwen2.5-1.5B-Instruct",
+    "reason_module": "microsoft/Phi-3-mini-4k-instruct",
+    "fast_module": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+}
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+log = logging.getLogger(__name__)
+
+def parse_args():
+    p = argparse.ArgumentParser(description="CRANE AI Fine-Tuner")
+    p.add_argument("--module", choices=list(MODEL_MAP.keys()))
+    p.add_argument("--data", required=True, help="JSONL veya HuggingFace dataset yolu")
+    p.add_argument("--output", default="adapters", help="Çıktı klasörü (LoRA adaptörü)")
+    p.add_argument("--epochs", type=int, default=3)
+    p.add_argument("--lr", type=float, default=2e-4)
+    p.add_argument("--batch", type=int, default=16)
+    p.add_argument("--r", type=int, default=16)
+    p.add_argument("--alpha", type=int, default=32)
+    p.add_argument("--bits4", action="store_true", help="QLoRA (4-bit) kullan")
+    return p.parse_args()
+
+def main():
+    args = parse_args()
+
+    model_id = MODEL_MAP[args.module]
+    log.info(f"Model: {model_id}")
+
+    # Dataset
+    if os.path.isfile(args.data):
+        ds = load_dataset("json", data_files=args.data)["train"]
+    else:
+        ds = load_dataset(args.data)["train"]
+
+    tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+    tok.pad_token = tok.eos_token if tok.pad_token is None else tok.pad_token
+
+    if args.bits4:
+        model = AutoModelForCausalLM.from_pretrained(model_id, load_in_4bit=True, device_map="auto")
+        model = prepare_model_for_kbit_training(model)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto")
+
+    peft_cfg = LoraConfig(
+        r=args.r,
+        lora_alpha=args.alpha,
+        lora_dropout=0.05,
+        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+        bias="none",
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, peft_cfg)
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tok,
+        train_dataset=ds,
+        max_seq_length=4096,
+        gradient_accumulation_steps=max(1, 32 // args.batch),
+        learning_rate=args.lr,
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=args.batch,
+    )
+
+    trainer.train()
+
+    out_dir = Path(args.output) / args.module
+    out_dir.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(out_dir)
+    tok.save_pretrained(out_dir)
+    log.info(f"LoRA adaptörü kaydedildi → {out_dir}")
+
+if __name__ == "__main__":
+    main()