Upload 5 files

llm/llm_factory.py

@@ -0,0 +1,97 @@
+"""
+LLM Provider Factory for Flare
+"""
+import os
+from typing import Optional
+from dotenv import load_dotenv
+
+from llm_interface import LLMInterface
+from llm_spark import SparkLLM
+from llm_openai import OpenAILLM
+from config_provider import ConfigProvider
+from logger import log_info, log_error, log_warning, log_debug
+
+class LLMFactory:
+    @staticmethod
+    def create_provider() -> LLMInterface:
+        """Create LLM provider based on configuration"""
+        cfg = ConfigProvider.get()
+        llm_config = cfg.global_config.llm_provider
+        
+        if not llm_config:
+            raise ValueError("No LLM provider configured")
+        
+        provider_name = llm_config.name
+        log_info(f"🏭 Creating LLM provider: {provider_name}")
+        
+        # Get provider definition
+        provider_def = cfg.global_config.get_provider_config("llm", provider_name)
+        if not provider_def:
+            raise ValueError(f"Unknown LLM provider: {provider_name}")
+        
+        # Get API key
+        api_key = LLMFactory._get_api_key(provider_name, llm_config.api_key)
+        
+        # Create provider based on name
+        if provider_name == "spark":
+            return LLMFactory._create_spark_provider(llm_config, api_key, provider_def)
+        elif provider_name == "spark_cloud":
+            return LLMFactory._create_spark_provider(llm_config, api_key, provider_def)
+        elif provider_name in ["gpt-4o", "gpt-4o-mini"]:
+            return LLMFactory._create_gpt_provider(llm_config, api_key, provider_def)
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider_name}")
+    
+    @staticmethod
+    def _create_spark_provider(llm_config, api_key, provider_def):
+        """Create Spark LLM provider"""
+        endpoint = llm_config.endpoint
+        if not endpoint:
+            raise ValueError("Spark endpoint not configured")
+        
+        # Determine variant based on environment
+        is_cloud = bool(os.environ.get("SPACE_ID"))
+        variant = "hfcloud" if is_cloud else "on-premise"
+        
+        return SparkLLM(
+            spark_endpoint=endpoint,
+            spark_token=api_key,
+            provider_variant=variant,
+            settings=llm_config.settings
+        )
+    
+    @staticmethod
+    def _create_gpt_provider(llm_config, api_key, provider_def):
+        """Create OpenAI GPT provider"""
+        return OpenAILLM(
+            api_key=api_key,
+            model=llm_config.name,
+            settings=llm_config.settings
+        )
+    
+    @staticmethod
+    def _get_api_key(provider_name: str, configured_key: Optional[str]) -> str:
+        """Get API key from config or environment"""
+        # First try configured key
+        if configured_key:
+            # Handle encrypted keys
+            if configured_key.startswith("enc:"):
+                from encryption_utils import decrypt
+                return decrypt(configured_key)
+            return configured_key
+        
+        # Then try environment variables
+        env_mappings = {
+            "spark": "SPARK_TOKEN",
+            "gpt-4o": "OPENAI_API_KEY",
+            "gpt-4o-mini": "OPENAI_API_KEY"
+        }
+        
+        env_var = env_mappings.get(provider_name)
+        if env_var:
+            key = os.environ.get(env_var)
+            if key:
+                log_info(f"📌 Using API key from environment: {env_var}")
+                return key
+        
+        raise ValueError(f"No API key found for provider: {provider_name}")

llm/llm_interface.py

@@ -0,0 +1,35 @@
+"""
+LLM Provider Interface for Flare
+"""
+import os
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Any
+
+class LLMInterface(ABC):
+    """Abstract base class for LLM providers"""
+    
+    def __init__(self, settings: Dict[str, Any] = None):
+        """Initialize with provider settings"""
+        self.settings = settings or {}
+        self.internal_prompt = self.settings.get("internal_prompt", "")
+        self.parameter_collection_config = self.settings.get("parameter_collection_config", {})
+    
+    @abstractmethod
+    async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
+        """Generate response from LLM"""
+        pass
+    
+    @abstractmethod
+    async def startup(self, project_config: Dict) -> bool:
+        """Initialize LLM with project config"""
+        pass
+    
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        """Get provider name for logging"""
+        pass
+    
+    @abstractmethod
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get model information"""
+        pass

llm/llm_openai.py

@@ -0,0 +1,104 @@
+"""
+OpenAI GPT Implementation
+"""
+import os
+import openai
+from typing import Dict, List, Any
+from llm_interface import LLMInterface
+from logger import log_info, log_error, log_warning, log_debug, LogTimer
+
+DEFAULT_LLM_TIMEOUT = int(os.getenv("LLM_TIMEOUT_SECONDS", "60"))
+MAX_RESPONSE_LENGTH = 4096  # Max response length
+
+class OpenAILLM(LLMInterface):
+    """OpenAI GPT integration with improved error handling"""
+    
+    def __init__(self, api_key: str, model: str = "gpt-4", settings: Dict[str, Any] = None):
+        super().__init__(settings)
+        self.api_key = api_key
+        self.model = model
+        self.timeout = self.settings.get("timeout", DEFAULT_LLM_TIMEOUT)
+        openai.api_key = api_key
+        log_info(f"🔌 OpenAI LLM initialized", model=self.model, timeout=self.timeout)
+    
+    async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
+        """Generate response with consistent error handling"""
+        
+        # Build messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # Add context
+        for msg in context[-10:]:  # Last 10 messages
+            role = "assistant" if msg.get("role") == "assistant" else "user"
+            messages.append({"role": role, "content": msg.get("content", "")})
+        
+        # Add current input
+        messages.append({"role": "user", "content": user_input})
+        
+        try:
+            with LogTimer(f"OpenAI {self.model} request"):
+                # Use async client
+                client = openai.AsyncOpenAI(
+                    api_key=self.api_key,
+                    timeout=self.timeout
+                )
+                
+                response = await client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    max_tokens=self.settings.get("max_tokens", 2048),
+                    temperature=self.settings.get("temperature", 0.7),
+                    stream=False
+                )
+                
+                # Extract content
+                content = response.choices[0].message.content
+                
+                # Check length
+                if len(content) > MAX_RESPONSE_LENGTH:
+                    log_warning(f"Response exceeded max length, truncating",
+                              original_length=len(content),
+                              max_length=MAX_RESPONSE_LENGTH)
+                    content = content[:MAX_RESPONSE_LENGTH] + "..."
+                
+                # Log token usage
+                if response.usage:
+                    log_info(f"Token usage",
+                           prompt_tokens=response.usage.prompt_tokens,
+                           completion_tokens=response.usage.completion_tokens,
+                           total_tokens=response.usage.total_tokens)
+                
+                return content
+                
+        except openai.RateLimitError as e:
+            log_warning("OpenAI rate limit", error=str(e))
+            raise
+        except openai.APITimeoutError as e:
+            log_error("OpenAI timeout", error=str(e))
+            raise
+        except openai.APIError as e:
+            log_error("OpenAI API error", 
+                     status_code=e.status_code if hasattr(e, 'status_code') else None,
+                     error=str(e))
+            raise
+        except Exception as e:
+            log_error("OpenAI unexpected error", error=str(e))
+            raise
+    
+    async def startup(self, project_config: Dict) -> bool:
+        """OpenAI doesn't need startup"""
+        log_info("OpenAI startup called (no-op)")
+        return True
+    
+    def get_provider_name(self) -> str:
+        return f"openai-{self.model}"
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        return {
+            "provider": "openai",
+            "model": self.model,
+            "max_tokens": self.settings.get("max_tokens", 2048),
+            "temperature": self.settings.get("temperature", 0.7)
+        }

llm/llm_spark.py

@@ -0,0 +1,116 @@
+"""
+Spark LLM Implementation
+"""
+import os
+import httpx
+import json
+from typing import Dict, List, Any, AsyncIterator
+from llm_interface import LLMInterface
+from logger import log_info, log_error, log_warning, log_debug
+
+# Get timeout from environment
+DEFAULT_LLM_TIMEOUT = int(os.getenv("LLM_TIMEOUT_SECONDS", "60"))
+MAX_RESPONSE_LENGTH = int(os.getenv("LLM_MAX_RESPONSE_LENGTH", "4096"))
+
+class SparkLLM(LLMInterface):
+    """Spark LLM integration with improved error handling"""
+    
+    def __init__(self, spark_endpoint: str, spark_token: str, provider_variant: str = "cloud", settings: Dict[str, Any] = None):
+        super().__init__(settings)
+        self.spark_endpoint = spark_endpoint.rstrip("/")
+        self.spark_token = spark_token
+        self.provider_variant = provider_variant
+        self.timeout = self.settings.get("timeout", DEFAULT_LLM_TIMEOUT)
+        log_info(f"🔌 SparkLLM initialized", endpoint=self.spark_endpoint, timeout=self.timeout)
+    
+    async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
+        """Generate response with improved error handling and streaming support"""
+        headers = {
+            "Authorization": f"Bearer {self.spark_token}",
+            "Content-Type": "application/json"
+        }
+        
+        # Build context messages
+        messages = []
+        if system_prompt:
+            messages.append({
+                "role": "system",
+                "content": system_prompt
+            })
+        
+        for msg in context[-10:]:  # Last 10 messages for context
+            messages.append({
+                "role": msg.get("role", "user"),
+                "content": msg.get("content", "")
+            })
+        
+        messages.append({
+            "role": "user",
+            "content": user_input
+        })
+        
+        payload = {
+            "messages": messages,
+            "mode": self.provider_variant,
+            "max_tokens": self.settings.get("max_tokens", 2048),
+            "temperature": self.settings.get("temperature", 0.7),
+            "stream": False  # For now, no streaming
+        }
+        
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                with LogTimer(f"Spark LLM request"):
+                    response = await client.post(
+                        f"{self.spark_endpoint}/generate",
+                        json=payload,
+                        headers=headers
+                    )
+                    
+                    # Check for rate limiting
+                    if response.status_code == 429:
+                        retry_after = response.headers.get("Retry-After", "60")
+                        log_warning(f"Rate limited by Spark", retry_after=retry_after)
+                        raise httpx.HTTPStatusError(
+                            f"Rate limited. Retry after {retry_after}s",
+                            request=response.request,
+                            response=response
+                        )
+                    
+                    response.raise_for_status()
+                    result = response.json()
+                    
+                    # Extract response
+                    content = result.get("model_answer", "")
+                    
+                    # Check response length
+                    if len(content) > MAX_RESPONSE_LENGTH:
+                        log_warning(f"Response exceeded max length, truncating", 
+                                  original_length=len(content),
+                                  max_length=MAX_RESPONSE_LENGTH)
+                        content = content[:MAX_RESPONSE_LENGTH] + "..."
+                    
+                    return content
+                    
+        except httpx.TimeoutException:
+            log_error(f"Spark request timed out", timeout=self.timeout)
+            raise
+        except httpx.HTTPStatusError as e:
+            log_error(f"Spark HTTP error", 
+                     status_code=e.response.status_code,
+                     response=e.response.text[:500])
+            raise
+        except Exception as e:
+            log_error("Spark unexpected error", error=str(e))
+            raise
+    
+    def get_provider_name(self) -> str:
+        return f"spark-{self.provider_variant}"
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        return {
+            "provider": "spark",
+            "variant": self.provider_variant,
+            "endpoint": self.spark_endpoint,
+            "max_tokens": self.settings.get("max_tokens", 2048),
+            "temperature": self.settings.get("temperature", 0.7)
+        }

llm/llm_startup.py

@@ -0,0 +1,102 @@
+"""
+Flare – LLM startup notifier (Refactored)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Projeler açılırken LLM provider'a startup çağrısı yapar.
+"""
+
+from __future__ import annotations
+import threading
+import asyncio
+from typing import Dict, Any
+from logger import log_info, log_error, log_warning, log_debug
+from config_provider import ConfigProvider, ProjectConfig, VersionConfig
+from llm_factory import LLMFactory
+
+def _select_live_version(p: ProjectConfig) -> VersionConfig | None:
+    """Yayınlanmış en güncel versiyonu getir."""
+    published = [v for v in p.versions if v.published]
+    return max(published, key=lambda v: v.no) if published else None
+
+async def notify_startup_async():
+    """Notify LLM provider about project startups (async version)"""
+    cfg = ConfigProvider.get()
+    
+    # Check if LLM provider requires repo info
+    llm_provider_def = cfg.global_config.get_provider_config(
+        "llm", 
+        cfg.global_config.llm_provider.name
+    )
+    
+    if not llm_provider_def or not llm_provider_def.requires_repo_info:
+        log_info(f"ℹ️ LLM provider '{cfg.global_config.llm_provider.name}' does not require startup notification")
+        return
+    
+    # Create LLM provider instance
+    try:
+        llm_provider = LLMFactory.create_provider()
+    except Exception as e:
+        log_error("❌ Failed to create LLM provider for startup", e)
+        return
+    
+    # Notify for each enabled project
+    enabled_projects = [p for p in cfg.projects if p.enabled and not getattr(p, 'deleted', False)]
+    
+    if not enabled_projects:
+        log_info("ℹ️ No enabled projects found for startup notification")
+        return
+    
+    for project in enabled_projects:
+        version = _select_live_version(project)
+        if not version:
+            log_info(f"⚠️ No published version found for project '{project.name}', skipping startup")
+            continue
+        
+        # Build project config - version.id yerine version.no kullan
+        project_config = {
+            "name": project.name,
+            "version_no": version.no,  # version_id yerine version_no
+            "repo_id": version.llm.repo_id,
+            "generation_config": version.llm.generation_config,
+            "use_fine_tune": version.llm.use_fine_tune,
+            "fine_tune_zip": version.llm.fine_tune_zip
+        }
+        
+        try:
+            log_info(f"🚀 Notifying LLM provider startup for project '{project.name}'...")
+            success = await llm_provider.startup(project_config)
+            
+            if success:
+                log_info(f"✅ LLM provider acknowledged startup for '{project.name}'")
+            else:
+                log_info(f"⚠️ LLM provider startup failed for '{project.name}'")
+                
+        except Exception as e:
+            log_error(f"❌ Error during startup notification for '{project.name}'", e)
+
+def notify_startup():
+    """Synchronous wrapper for async startup notification"""
+    # Create new event loop for thread
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    try:
+        loop.run_until_complete(notify_startup_async())
+    finally:
+        loop.close()
+
+def run_in_thread():
+    """Start startup notification in background thread"""
+    cfg = ConfigProvider.get()
+    
+    # Check if provider requires startup
+    llm_provider_def = cfg.global_config.get_provider_config(
+        "llm", 
+        cfg.global_config.llm_provider.name
+    )
+    
+    if not llm_provider_def or not llm_provider_def.requires_repo_info:
+        log_info(f"🤖 {cfg.global_config.llm_provider.name} - Startup notification not required")
+        return
+    
+    log_info("🚀 Starting LLM provider startup notification thread...")
+    threading.Thread(target=notify_startup, daemon=True).start()