isa-model 0.3.9__py3-none-any.whl → 0.4.0__py3-none-any.whl

isa_model/serving/api/startup.py

@@ -0,0 +1,304 @@
+"""
+Server Startup Initialization for ISA Model
+
+Handles automatic initialization of:
+- Database migrations
+- Model registry population
+- Embedding generation
+- System validation
+"""
+
+import logging
+import asyncio
+from typing import Dict, Any
+import json
+import psycopg2
+import os
+
+from ...core.config.config_manager import ConfigManager
+from ...core.database.migrations import run_environment_migrations
+from ...core.models.model_repo import ModelRegistry
+from ...core.types import ModelType, ModelCapability
+
+logger = logging.getLogger(__name__)
+
+class StartupInitializer:
+    """Handles server startup initialization"""
+    
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        
+    async def initialize_system(self):
+        """Run complete system initialization"""
+        logger.info("🚀 Starting ISA Model system initialization...")
+        
+        try:
+            # 1. Run database migrations
+            await self._run_migrations()
+            
+            # 2. Populate model registry
+            await self._populate_models()
+            
+            # 3. Generate embeddings
+            await self._generate_embeddings()
+            
+            # 4. Validate system
+            await self._validate_system()
+            
+            logger.info("✅ System initialization completed successfully!")
+            
+        except Exception as e:
+            logger.error(f"❌ System initialization failed: {e}")
+            raise
+    
+    async def _run_migrations(self):
+        """Run database migrations"""
+        logger.info("📋 Running database migrations...")
+        
+        try:
+            success = run_environment_migrations()
+            if success:
+                logger.info("✅ Database migrations completed")
+            else:
+                raise Exception("Database migrations failed")
+        except Exception as e:
+            logger.error(f"❌ Migration error: {e}")
+            raise
+    
+    async def _populate_models(self):
+        """Populate model registry with all configured models"""
+        logger.info("📚 Populating model registry...")
+        
+        try:
+            registry = ModelRegistry()
+            
+            # Get all configured models
+            all_models = self.config_manager.model_definitions
+            
+            if not all_models:
+                logger.warning("⚠️ No models configured in providers")
+                return
+            
+            registered_count = 0
+            
+            for model_id, model_data in all_models.items():
+                try:
+                    # Check if already registered
+                    existing = registry.get_model_info(model_id)
+                    if existing:
+                        logger.debug(f"Model {model_id} already registered, skipping")
+                        continue
+                    
+                    # Map model type
+                    model_type_str = model_data.get('type', 'llm')
+                    model_type = self._map_model_type(model_type_str)
+                    
+                    # Map capabilities
+                    capabilities = self._map_capabilities(model_data.get('capabilities', []))
+                    
+                    # Get provider
+                    provider = model_data.get('provider', 'unknown')
+                    
+                    # Register the model
+                    success = registry.register_model(
+                        model_id=model_id,
+                        model_type=model_type,
+                        capabilities=capabilities,
+                        metadata=model_data,
+                        provider=provider
+                    )
+                    
+                    if success:
+                        registered_count += 1
+                        logger.debug(f"Registered {model_id} ({provider})")
+                    else:
+                        logger.warning(f"Failed to register {model_id}")
+                        
+                except Exception as e:
+                    logger.error(f"Error registering {model_id}: {e}")
+                    continue
+            
+            logger.info(f"✅ Model registry populated: {registered_count}/{len(all_models)} models")
+            
+        except Exception as e:
+            logger.error(f"❌ Model population error: {e}")
+            raise
+    
+    async def _generate_embeddings(self):
+        """Generate embeddings for all registered models using OpenAI embedding service"""
+        logger.info("🧠 Generating model embeddings with OpenAI embedding service...")
+        
+        try:
+            # Initialize embedding service
+            from ...inference.ai_factory import AIFactory
+            factory = AIFactory.get_instance()
+            embedding_service = factory.get_embed("text-embedding-3-small", "openai")
+            
+            if not embedding_service:
+                logger.warning("⚠️ Could not initialize embedding service, skipping embedding generation")
+                return
+            
+            # Get all registered models
+            registry = ModelRegistry()
+            models = registry.list_models()
+            
+            if not models:
+                logger.warning("⚠️ No models found in registry")
+                return
+            
+            # Check existing embeddings using Supabase client
+            supabase_client = registry.supabase_client
+            existing_result = supabase_client.table("model_embeddings").select("model_id").execute()
+            existing_embeddings = {row['model_id'] for row in existing_result.data}
+            
+            logger.info(f"Found {len(existing_embeddings)} existing embeddings")
+            
+            processed = 0
+            
+            for model_id, model_data in models.items():
+                try:
+                    # Skip if embedding already exists
+                    if model_id in existing_embeddings:
+                        logger.debug(f"Embedding already exists for {model_id}, skipping")
+                        continue
+                    
+                    provider = model_data.get('provider', 'unknown')
+                    model_type = model_data.get('type', 'llm')
+                    metadata = model_data.get('metadata', {})
+                    
+                    # Create searchable text from model information (same logic as intelligent_model_selector)
+                    description = metadata.get('description', '')
+                    specialized_tasks = metadata.get('specialized_tasks', [])
+                    
+                    # Combine all text for embedding
+                    search_text = f"{model_id} {provider} model. "
+                    if description:
+                        search_text += f"{description} "
+                    if specialized_tasks:
+                        search_text += f"Specialized for: {', '.join(specialized_tasks)}"
+                    
+                    # Generate embedding using OpenAI service
+                    logger.debug(f"Generating embedding for {model_id}...")
+                    embedding = await embedding_service.create_text_embedding(search_text)
+                    
+                    # Store embedding in database
+                    embedding_data = {
+                        'model_id': model_id,
+                        'provider': provider,
+                        'description': search_text,
+                        'embedding': embedding
+                    }
+                    
+                    result = supabase_client.table('model_embeddings').insert(embedding_data).execute()
+                    
+                    if result.data:
+                        processed += 1
+                        logger.debug(f"Stored embedding for {model_id}")
+                    else:
+                        logger.warning(f"Failed to store embedding for {model_id}")
+                    
+                except Exception as e:
+                    logger.error(f"Error creating embedding for {model_id}: {e}")
+                    continue
+            
+            logger.info(f"✅ Generated {processed}/{len(models)} new embeddings")
+            
+            # Close embedding service
+            await embedding_service.close()
+            
+        except Exception as e:
+            logger.error(f"❌ Embedding generation error: {e}")
+            raise
+    
+    async def _validate_system(self):
+        """Validate system is working correctly"""
+        logger.info("🔍 Validating system...")
+        
+        try:
+            registry = ModelRegistry()
+            stats = registry.get_stats()
+            
+            logger.info(f"📊 System validation results:")
+            logger.info(f"   Models: {stats['total_models']}")
+            logger.info(f"   By type: {stats['models_by_type']}")
+            logger.info(f"   By capability: {stats['models_by_capability']}")
+            
+            if stats['total_models'] == 0:
+                raise Exception("No models found in registry")
+            
+            # Initialize and test intelligent selector
+            try:
+                from ...core.services.intelligent_model_selector import get_model_selector
+                selector = await get_model_selector()
+                
+                # Test basic functionality
+                available_models = await selector.get_available_models()
+                logger.info(f"   Available models for selection: {len(available_models)}")
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Intelligent selector initialization failed: {e}")
+            
+            logger.info("✅ System validation completed")
+            
+        except Exception as e:
+            logger.error(f"❌ System validation error: {e}")
+            raise
+    
+    def _map_model_type(self, model_type_str: str) -> ModelType:
+        """Map string model type to enum"""
+        mapping = {
+            'llm': ModelType.LLM,
+            'embedding': ModelType.EMBEDDING,
+            'rerank': ModelType.RERANK,
+            'image': ModelType.IMAGE,
+            'audio': ModelType.AUDIO,
+            'video': ModelType.VIDEO,
+            'vision': ModelType.VISION,
+            'omni': ModelType.LLM  # Omni models are treated as LLM for now
+        }
+        return mapping.get(model_type_str.lower(), ModelType.LLM)
+    
+    def _map_capabilities(self, capabilities_list: list) -> list:
+        """Map capability strings to enums"""
+        mapping = {
+            'text_generation': ModelCapability.TEXT_GENERATION,
+            'chat': ModelCapability.CHAT,
+            'embedding': ModelCapability.EMBEDDING,
+            'reranking': ModelCapability.RERANKING,
+            'reasoning': ModelCapability.REASONING,
+            'image_generation': ModelCapability.IMAGE_GENERATION,
+            'image_analysis': ModelCapability.IMAGE_ANALYSIS,
+            'audio_transcription': ModelCapability.AUDIO_TRANSCRIPTION,
+            'audio_realtime': ModelCapability.AUDIO_REALTIME,
+            'speech_to_text': ModelCapability.SPEECH_TO_TEXT,
+            'text_to_speech': ModelCapability.TEXT_TO_SPEECH,
+            'conversation': ModelCapability.CONVERSATION,
+            'image_understanding': ModelCapability.IMAGE_UNDERSTANDING,
+            'ui_detection': ModelCapability.UI_DETECTION,
+            'ocr': ModelCapability.OCR,
+            'table_detection': ModelCapability.TABLE_DETECTION,
+            'table_structure_recognition': ModelCapability.TABLE_STRUCTURE_RECOGNITION
+        }
+        
+        result = []
+        for cap in capabilities_list:
+            if cap in mapping:
+                result.append(mapping[cap])
+            else:
+                # Log unmapped capabilities for debugging
+                logger.warning(f"Unknown capability '{cap}' - skipping")
+        
+        # Default to text generation if no capabilities
+        if not result:
+            result = [ModelCapability.TEXT_GENERATION]
+            
+        return result
+    
+
+
+# Global initializer instance
+startup_initializer = StartupInitializer()
+
+async def run_startup_initialization():
+    """Main startup initialization function"""
+    await startup_initializer.initialize_system()

isa_model/serving/modal_proxy_server.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Modal Services Proxy Server (Port 8082)
+
+This server acts as a proxy to Modal services, providing a unified interface
+for all Modal-deployed AI services like vision, audio, embedding, etc.
+"""
+
+import os
+import logging
+import uvicorn
+import httpx
+import asyncio
+from fastapi import FastAPI, HTTPException, Request, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from typing import Dict, Any, Optional
+import json
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="isA Model Modal Proxy",
+    description="Proxy server for Modal-deployed AI services",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Security
+security = HTTPBearer()
+
+# Configuration
+MODAL_SERVICES = {
+    "vision": os.getenv("MODAL_VISION_URL", ""),
+    "audio": os.getenv("MODAL_AUDIO_URL", ""),
+    "embedding": os.getenv("MODAL_EMBED_URL", ""),
+    "image_gen": os.getenv("MODAL_IMAGE_GEN_URL", "")
+}
+
+API_KEY = os.getenv("API_KEY", "")
+REQUEST_TIMEOUT = int(os.getenv("MODAL_TIMEOUT", "120"))
+
+
+def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify API key if configured"""
+    if API_KEY and credentials.credentials != API_KEY:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+    return credentials.credentials
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    # Test connectivity to Modal services
+    service_status = {}
+    async with httpx.AsyncClient(timeout=5.0) as client:
+        for service_name, service_url in MODAL_SERVICES.items():
+            if service_url:
+                try:
+                    response = await client.get(f"{service_url}/health", timeout=5.0)
+                    service_status[service_name] = "healthy" if response.status_code == 200 else "unhealthy"
+                except Exception:
+                    service_status[service_name] = "unreachable"
+            else:
+                service_status[service_name] = "not_configured"
+    
+    return {
+        "status": "healthy",
+        "service": "modal-proxy",
+        "port": 8082,
+        "modal_services": service_status
+    }
+
+
+@app.get("/services")
+async def list_services():
+    """List available Modal services"""
+    return {
+        "available_services": list(MODAL_SERVICES.keys()),
+        "service_urls": {k: v for k, v in MODAL_SERVICES.items() if v},
+        "total_services": len([v for v in MODAL_SERVICES.values() if v])
+    }
+
+
+@app.post("/modal/{service_name}/{endpoint:path}")
+async def proxy_modal_service(
+    service_name: str,
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Proxy requests to specific Modal service"""
+    
+    # Validate service name
+    if service_name not in MODAL_SERVICES:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Service '{service_name}' not found. Available: {list(MODAL_SERVICES.keys())}"
+        )
+    
+    service_url = MODAL_SERVICES[service_name]
+    if not service_url:
+        raise HTTPException(
+            status_code=503,
+            detail=f"Service '{service_name}' not configured"
+        )
+    
+    try:
+        # Get request body
+        body = await request.body()
+        
+        # Prepare headers (exclude host and content-length)
+        headers = {}
+        for key, value in request.headers.items():
+            if key.lower() not in ['host', 'content-length']:
+                headers[key] = value
+        
+        # Make request to Modal service
+        target_url = f"{service_url}/{endpoint}"
+        
+        async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+            response = await client.request(
+                method=request.method,
+                url=target_url,
+                headers=headers,
+                content=body,
+                params=dict(request.query_params)
+            )
+            
+            # Return response
+            return response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text
+            
+    except httpx.TimeoutException:
+        logger.error(f"Timeout calling Modal service {service_name} at {endpoint}")
+        raise HTTPException(
+            status_code=504,
+            detail=f"Modal service '{service_name}' timeout"
+        )
+    except httpx.RequestError as e:
+        logger.error(f"Request error calling Modal service {service_name}: {e}")
+        raise HTTPException(
+            status_code=503,
+            detail=f"Modal service '{service_name}' unavailable: {str(e)}"
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error calling Modal service {service_name}: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error: {str(e)}"
+        )
+
+
+@app.get("/modal/{service_name}/{endpoint:path}")
+async def proxy_modal_service_get(
+    service_name: str,
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Proxy GET requests to Modal services"""
+    return await proxy_modal_service(service_name, endpoint, request, api_key)
+
+
+# Convenience endpoints for common services
+@app.post("/vision/{endpoint:path}")
+async def vision_service(
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Direct access to vision service"""
+    return await proxy_modal_service("vision", endpoint, request, api_key)
+
+
+@app.post("/audio/{endpoint:path}")
+async def audio_service(
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Direct access to audio service"""
+    return await proxy_modal_service("audio", endpoint, request, api_key)
+
+
+@app.post("/embedding/{endpoint:path}")
+async def embedding_service(
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Direct access to embedding service"""
+    return await proxy_modal_service("embedding", endpoint, request, api_key)
+
+
+@app.post("/image-gen/{endpoint:path}")
+async def image_gen_service(
+    endpoint: str,
+    request: Request,
+    api_key: str = Depends(verify_api_key)
+):
+    """Direct access to image generation service"""
+    return await proxy_modal_service("image_gen", endpoint, request, api_key)
+
+
+# Error handlers
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc: HTTPException):
+    return {
+        "error": "Not Found",
+        "detail": "The requested endpoint was not found",
+        "available_endpoints": [
+            "/health",
+            "/services",
+            "/modal/{service_name}/{endpoint}",
+            "/vision/{endpoint}",
+            "/audio/{endpoint}",
+            "/embedding/{endpoint}",
+            "/image-gen/{endpoint}"
+        ]
+    }
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "8082"))
+    workers = int(os.getenv("WORKERS", "1"))
+    
+    logger.info(f"Starting Modal Proxy Server on port {port}")
+    logger.info(f"Configured Modal services: {list(MODAL_SERVICES.keys())}")
+    
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        workers=workers,
+        log_level="info"
+    )

isa_model/training/__init__.py

@@ -6,6 +6,7 @@ Provides unified training capabilities for AI models including:
 - Cloud training on RunPod
 - Model evaluation and management
 - HuggingFace integration
+- 🧠 Intelligent training with AI-powered optimization
 
 Example usage:
     ```python
@@ -27,6 +28,18 @@ Example usage:
         batch_size=4,
         num_epochs=3
     )
+    
+    # 🧠 Intelligent training with natural language
+    from isa_model.training import IntelligentTrainingFactory
+    
+    intelligent_factory = IntelligentTrainingFactory()
+    recommendation = intelligent_factory.analyze_training_request(
+        "Train a customer service chatbot for medical domain",
+        dataset_path="medical_dialogues.json",
+        quality_target="high",
+        budget_limit=200.0
+    )
+    model_path = intelligent_factory.train_with_recommendation(recommendation)
     ```
 """
 
@@ -41,17 +54,60 @@ from .core import (
     BaseTrainer,
     SFTTrainer,
     TrainingUtils,
-    DatasetManager
+    DatasetManager,
+    RunPodConfig,
+    StorageConfig,
+    JobConfig
 )
 
 # Import cloud training components
 from .cloud import (
-    RunPodConfig,
-    StorageConfig,
-    JobConfig,
     TrainingJobOrchestrator
 )
 
+# Import intelligent training components (optional)
+try:
+    from .intelligent import (
+        IntelligentTrainingFactory,
+        IntelligentDecisionEngine,
+        TaskClassifier,
+        KnowledgeBase,
+        ResourceOptimizer,
+        TrainingRequest,
+        TrainingRecommendation
+    )
+    INTELLIGENT_AVAILABLE = True
+except ImportError as e:
+    INTELLIGENT_AVAILABLE = False
+    # Create placeholder classes for graceful degradation
+    class IntelligentTrainingFactory:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available. Please install required dependencies.")
+    
+    class IntelligentDecisionEngine:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+    
+    class TaskClassifier:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+    
+    class KnowledgeBase:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+    
+    class ResourceOptimizer:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+    
+    class TrainingRequest:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+    
+    class TrainingRecommendation:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Intelligent training features not available.")
+
 __all__ = [
     # Main factory
     'TrainingFactory',
@@ -70,5 +126,43 @@ __all__ = [
     'RunPodConfig',
     'StorageConfig',
     'JobConfig',
-    'TrainingJobOrchestrator'
-] 
+    'TrainingJobOrchestrator',
+    
+    # Intelligent training components
+    'IntelligentTrainingFactory',
+    'IntelligentDecisionEngine',
+    'TaskClassifier',
+    'KnowledgeBase',
+    'ResourceOptimizer',
+    'TrainingRequest',
+    'TrainingRecommendation',
+    'INTELLIGENT_AVAILABLE',
+    
+    # Training storage components (optional)
+    'TrainingStorage',
+    'TrainingRepository',
+    'CoreModelIntegration'
+]
+
+# Import training storage components (optional)
+try:
+    from .storage import (
+        TrainingStorage,
+        TrainingRepository,
+        CoreModelIntegration
+    )
+    STORAGE_AVAILABLE = True
+except ImportError:
+    STORAGE_AVAILABLE = False
+    # Create placeholder classes for graceful degradation
+    class TrainingStorage:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Training storage features not available.")
+    
+    class TrainingRepository:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Training repository features not available.")
+    
+    class CoreModelIntegration:
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Core model integration features not available.")