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

isa_model/serving/api/startup.py

@@ -12,11 +12,9 @@ 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
 
@@ -27,67 +25,59 @@ class StartupInitializer:
     
     def __init__(self):
         self.config_manager = ConfigManager()
+        self._embedding_service = None
+        self._model_registry = None
         
     async def initialize_system(self):
         """Run complete system initialization"""
-        logger.info("🚀 Starting ISA Model system initialization...")
-        
+        print("🚀 Starting ISA Model system initialization...")
+
         try:
-            # 1. Run database migrations
-            await self._run_migrations()
-            
-            # 2. Populate model registry
+            # 1. Populate model registry
             await self._populate_models()
-            
-            # 3. Generate embeddings
+
+            # 2. Generate embeddings
             await self._generate_embeddings()
-            
-            # 4. Validate system
+
+            # 3. Validate system
             await self._validate_system()
-            
-            logger.info("✅ System initialization completed successfully!")
-            
+
+            print("✅ 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...")
+        print("📚 Populating model registry...")
         
         try:
             registry = ModelRegistry()
+            self._model_registry = registry  # Track for cleanup
+            
+            # Check if models are already populated to avoid unnecessary database operations
+            try:
+                stats = registry.get_stats()
+                if stats and stats.get('total_models', 0) > 0:
+                    print(f"✅ Model registry already populated: {stats['total_models']} models")
+                    return
+            except Exception as e:
+                print(f"⚠️ Could not check existing models, proceeding with population: {e}")
             
             # Get all configured models
             all_models = self.config_manager.model_definitions
             
             if not all_models:
-                logger.warning("⚠️ No models configured in providers")
+                print("⚠️ 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
+                    # Skip individual model check to avoid multiple database queries
+                    # We already checked if any models exist above
                     
                     # Map model type
                     model_type_str = model_data.get('type', 'llm')
@@ -110,7 +100,6 @@ class StartupInitializer:
                     
                     if success:
                         registered_count += 1
-                        logger.debug(f"Registered {model_id} ({provider})")
                     else:
                         logger.warning(f"Failed to register {model_id}")
                         
@@ -118,7 +107,7 @@ class StartupInitializer:
                     logger.error(f"Error registering {model_id}: {e}")
                     continue
             
-            logger.info(f"✅ Model registry populated: {registered_count}/{len(all_models)} models")
+            print(f"✅ Model registry populated: {registered_count}/{len(all_models)} models")
             
         except Exception as e:
             logger.error(f"❌ Model population error: {e}")
@@ -126,16 +115,17 @@ class StartupInitializer:
     
     async def _generate_embeddings(self):
         """Generate embeddings for all registered models using OpenAI embedding service"""
-        logger.info("🧠 Generating model embeddings with OpenAI embedding service...")
+        print("🧠 Generating model embeddings...")
         
         try:
             # Initialize embedding service
             from ...inference.ai_factory import AIFactory
             factory = AIFactory.get_instance()
             embedding_service = factory.get_embed("text-embedding-3-small", "openai")
+            self._embedding_service = embedding_service  # Track for cleanup
             
             if not embedding_service:
-                logger.warning("⚠️ Could not initialize embedding service, skipping embedding generation")
+                print("⚠️ Could not initialize embedding service, skipping embedding generation")
                 return
             
             # Get all registered models
@@ -143,7 +133,7 @@ class StartupInitializer:
             models = registry.list_models()
             
             if not models:
-                logger.warning("⚠️ No models found in registry")
+                print("⚠️ No models found in registry")
                 return
             
             # Check existing embeddings using Supabase client
@@ -151,15 +141,12 @@ class StartupInitializer:
             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')
@@ -178,7 +165,6 @@ class StartupInitializer:
                         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
@@ -193,7 +179,6 @@ class StartupInitializer:
                     
                     if result.data:
                         processed += 1
-                        logger.debug(f"Stored embedding for {model_id}")
                     else:
                         logger.warning(f"Failed to store embedding for {model_id}")
                     
@@ -201,7 +186,7 @@ class StartupInitializer:
                     logger.error(f"Error creating embedding for {model_id}: {e}")
                     continue
             
-            logger.info(f"✅ Generated {processed}/{len(models)} new embeddings")
+            print(f"✅ Generated {processed}/{len(models)} new embeddings")
             
             # Close embedding service
             await embedding_service.close()
@@ -212,16 +197,16 @@ class StartupInitializer:
     
     async def _validate_system(self):
         """Validate system is working correctly"""
-        logger.info("🔍 Validating system...")
+        print("🔍 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']}")
+            print(f"📊 System validation results:")
+            print(f"   Models: {stats['total_models']}")
+            print(f"   By type: {stats['models_by_type']}")
+            print(f"   By capability: {stats['models_by_capability']}")
             
             if stats['total_models'] == 0:
                 raise Exception("No models found in registry")
@@ -233,12 +218,12 @@ class StartupInitializer:
                 
                 # Test basic functionality
                 available_models = await selector.get_available_models()
-                logger.info(f"   Available models for selection: {len(available_models)}")
+                print(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")
+            print("✅ System validation completed")
             
         except Exception as e:
             logger.error(f"❌ System validation error: {e}")
@@ -294,6 +279,35 @@ class StartupInitializer:
             
         return result
     
+    async def cleanup(self):
+        """Clean up startup resources"""
+        logger.info("🧹 Starting startup initializer cleanup...")
+        
+        try:
+            # Clean up any persistent connections or resources
+            # Most cleanup is handled by individual services, but we can do some general cleanup here
+            
+            # If we have any cached embedding services, clean them up
+            if hasattr(self, '_embedding_service') and self._embedding_service:
+                try:
+                    await self._embedding_service.close()
+                    logger.info("✅ Embedding service closed")
+                except Exception as e:
+                    logger.error(f"❌ Error closing embedding service: {e}")
+            
+            # Clean up model registry connections if needed
+            if hasattr(self, '_model_registry'):
+                try:
+                    # ModelRegistry doesn't need explicit cleanup currently
+                    # but this is where we'd add it if needed
+                    pass
+                except Exception as e:
+                    logger.error(f"❌ Error cleaning up model registry: {e}")
+            
+            logger.info("✅ Startup initializer cleanup completed")
+            
+        except Exception as e:
+            logger.error(f"❌ Error during startup cleanup: {e}")
 
 
 # Global initializer instance

isa_model/utils/gpu_utils.py

@@ -0,0 +1,311 @@
+"""
+GPU detection and resource management utilities
+
+Provides functions for detecting and managing local GPU resources.
+"""
+
+import os
+import logging
+import subprocess
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass
+import platform
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GPUInfo:
+    """GPU information structure"""
+    gpu_id: int
+    name: str
+    memory_total: int  # MB
+    memory_free: int   # MB  
+    memory_used: int   # MB
+    utilization: float  # %
+    temperature: Optional[int] = None  # Celsius
+    power_draw: Optional[float] = None  # Watts
+    driver_version: Optional[str] = None
+    cuda_version: Optional[str] = None
+
+
+class GPUManager:
+    """Local GPU resource manager"""
+    
+    def __init__(self):
+        self.gpus: List[GPUInfo] = []
+        self.cuda_available = False
+        self.nvidia_smi_available = False
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize GPU detection"""
+        self.cuda_available = self._check_cuda_availability()
+        self.nvidia_smi_available = self._check_nvidia_smi()
+        
+        if self.nvidia_smi_available:
+            self.gpus = self._detect_nvidia_gpus()
+        elif self.cuda_available:
+            self.gpus = self._detect_cuda_gpus_fallback()
+        else:
+            logger.warning("No CUDA-capable GPUs detected")
+    
+    def _check_cuda_availability(self) -> bool:
+        """Check if CUDA is available through PyTorch"""
+        try:
+            import torch
+            available = torch.cuda.is_available()
+            if available:
+                logger.info(f"CUDA detected: {torch.cuda.device_count()} devices")
+                logger.info(f"CUDA version: {torch.version.cuda}")
+            return available
+        except ImportError:
+            logger.warning("PyTorch not available for CUDA detection")
+            return False
+        except Exception as e:
+            logger.warning(f"CUDA detection failed: {e}")
+            return False
+    
+    def _check_nvidia_smi(self) -> bool:
+        """Check if nvidia-smi is available"""
+        try:
+            result = subprocess.run(['nvidia-smi', '--version'], 
+                                  capture_output=True, text=True, timeout=5)
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.SubprocessError):
+            return False
+    
+    def _detect_nvidia_gpus(self) -> List[GPUInfo]:
+        """Detect GPUs using nvidia-smi"""
+        gpus = []
+        
+        try:
+            # Get GPU information using nvidia-smi
+            cmd = [
+                'nvidia-smi', 
+                '--query-gpu=index,name,memory.total,memory.free,memory.used,utilization.gpu,temperature.gpu,power.draw,driver_version',
+                '--format=csv,noheader,nounits'
+            ]
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            
+            if result.returncode == 0:
+                lines = result.stdout.strip().split('\n')
+                for line in lines:
+                    if line.strip():
+                        parts = [p.strip() for p in line.split(',')]
+                        if len(parts) >= 7:
+                            gpu_info = GPUInfo(
+                                gpu_id=int(parts[0]),
+                                name=parts[1],
+                                memory_total=int(parts[2]),
+                                memory_free=int(parts[3]), 
+                                memory_used=int(parts[4]),
+                                utilization=float(parts[5]),
+                                temperature=int(parts[6]) if parts[6] != '[Not Supported]' else None,
+                                power_draw=float(parts[7]) if len(parts) > 7 and parts[7] != '[Not Supported]' else None,
+                                driver_version=parts[8] if len(parts) > 8 else None
+                            )
+                            gpus.append(gpu_info)
+            
+            # Get CUDA version
+            try:
+                cuda_result = subprocess.run(['nvcc', '--version'], 
+                                           capture_output=True, text=True, timeout=5)
+                if cuda_result.returncode == 0:
+                    for line in cuda_result.stdout.split('\n'):
+                        if 'release' in line.lower():
+                            cuda_version = line.split()[-1].rstrip(',')
+                            for gpu in gpus:
+                                gpu.cuda_version = cuda_version
+                            break
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                pass
+                
+        except Exception as e:
+            logger.error(f"Failed to detect GPUs with nvidia-smi: {e}")
+        
+        return gpus
+    
+    def _detect_cuda_gpus_fallback(self) -> List[GPUInfo]:
+        """Fallback GPU detection using PyTorch"""
+        gpus = []
+        
+        try:
+            import torch
+            if torch.cuda.is_available():
+                for i in range(torch.cuda.device_count()):
+                    props = torch.cuda.get_device_properties(i)
+                    
+                    # Get memory info
+                    torch.cuda.set_device(i)
+                    memory_total = torch.cuda.get_device_properties(i).total_memory // (1024**2)  # MB
+                    memory_free = (torch.cuda.get_device_properties(i).total_memory - torch.cuda.memory_allocated(i)) // (1024**2)
+                    memory_used = torch.cuda.memory_allocated(i) // (1024**2)
+                    
+                    gpu_info = GPUInfo(
+                        gpu_id=i,
+                        name=props.name,
+                        memory_total=memory_total,
+                        memory_free=memory_free,
+                        memory_used=memory_used,
+                        utilization=0.0,  # Cannot get utilization without nvidia-smi
+                        cuda_version=torch.version.cuda
+                    )
+                    gpus.append(gpu_info)
+                    
+        except Exception as e:
+            logger.error(f"Failed to detect GPUs with PyTorch: {e}")
+            
+        return gpus
+    
+    def get_gpu_info(self, gpu_id: Optional[int] = None) -> Optional[GPUInfo]:
+        """Get information for a specific GPU or best available GPU"""
+        if not self.gpus:
+            return None
+            
+        if gpu_id is not None:
+            for gpu in self.gpus:
+                if gpu.gpu_id == gpu_id:
+                    return gpu
+            return None
+        
+        # Return GPU with most free memory
+        return max(self.gpus, key=lambda x: x.memory_free)
+    
+    def get_best_gpu(self, min_memory_mb: int = 1024) -> Optional[GPUInfo]:
+        """Get the best available GPU for model deployment"""
+        available_gpus = [gpu for gpu in self.gpus if gpu.memory_free >= min_memory_mb]
+        
+        if not available_gpus:
+            return None
+        
+        # Sort by free memory (descending) and utilization (ascending)
+        return sorted(available_gpus, 
+                     key=lambda x: (-x.memory_free, x.utilization))[0]
+    
+    def estimate_model_memory(self, model_id: str, precision: str = "float16") -> int:
+        """Estimate memory requirements for a model in MB"""
+        # Simple estimation based on model name and precision
+        memory_multipliers = {
+            "float32": 4,
+            "float16": 2, 
+            "int8": 1,
+            "int4": 0.5
+        }
+        
+        multiplier = memory_multipliers.get(precision, 2)
+        
+        # Rough parameter estimates based on model names
+        if "7b" in model_id.lower():
+            params = 7_000_000_000
+        elif "13b" in model_id.lower():
+            params = 13_000_000_000
+        elif "70b" in model_id.lower():
+            params = 70_000_000_000
+        elif "large" in model_id.lower():
+            params = 1_000_000_000
+        elif "medium" in model_id.lower():
+            params = 350_000_000
+        elif "small" in model_id.lower():
+            params = 125_000_000
+        else:
+            params = 500_000_000  # Default estimate
+        
+        # Memory = parameters * bytes_per_param + overhead
+        estimated_mb = int((params * multiplier + 1024**3) / (1024**2))  # +1GB overhead
+        
+        return estimated_mb
+    
+    def check_gpu_compatibility(self, model_id: str, precision: str = "float16") -> Tuple[bool, List[str]]:
+        """Check if local GPUs can handle the model"""
+        warnings = []
+        
+        if not self.gpus:
+            return False, ["No CUDA-capable GPUs detected"]
+        
+        estimated_memory = self.estimate_model_memory(model_id, precision)
+        best_gpu = self.get_best_gpu(estimated_memory)
+        
+        if not best_gpu:
+            warnings.append(f"Insufficient GPU memory. Required: {estimated_memory}MB, Available: {max(gpu.memory_free for gpu in self.gpus)}MB")
+            return False, warnings
+        
+        # Check compute capability for advanced features
+        if precision in ["int8", "int4"]:
+            warnings.append("Quantized precision may require specific GPU compute capability")
+        
+        return True, warnings
+    
+    def refresh(self):
+        """Refresh GPU information"""
+        if self.nvidia_smi_available:
+            self.gpus = self._detect_nvidia_gpus()
+        elif self.cuda_available:
+            self.gpus = self._detect_cuda_gpus_fallback()
+    
+    def get_system_info(self) -> Dict[str, Any]:
+        """Get comprehensive system information"""
+        info = {
+            "platform": platform.system(),
+            "architecture": platform.machine(),
+            "cuda_available": self.cuda_available,
+            "nvidia_smi_available": self.nvidia_smi_available,
+            "gpu_count": len(self.gpus),
+            "gpus": [
+                {
+                    "id": gpu.gpu_id,
+                    "name": gpu.name,
+                    "memory_total_mb": gpu.memory_total,
+                    "memory_free_mb": gpu.memory_free,
+                    "memory_used_mb": gpu.memory_used,
+                    "utilization_percent": gpu.utilization,
+                    "temperature_c": gpu.temperature,
+                    "power_draw_w": gpu.power_draw,
+                    "driver_version": gpu.driver_version,
+                    "cuda_version": gpu.cuda_version
+                }
+                for gpu in self.gpus
+            ]
+        }
+        
+        # Add Python environment info
+        try:
+            import torch
+            info["torch_version"] = torch.__version__
+            info["torch_cuda_version"] = torch.version.cuda
+        except ImportError:
+            pass
+            
+        return info
+
+
+# Global GPU manager instance
+_gpu_manager = None
+
+def get_gpu_manager() -> GPUManager:
+    """Get global GPU manager instance"""
+    global _gpu_manager
+    if _gpu_manager is None:
+        _gpu_manager = GPUManager()
+    return _gpu_manager
+
+
+def detect_gpus() -> List[GPUInfo]:
+    """Convenience function to detect GPUs"""
+    return get_gpu_manager().gpus
+
+
+def get_best_gpu(min_memory_mb: int = 1024) -> Optional[GPUInfo]:
+    """Convenience function to get best available GPU"""
+    return get_gpu_manager().get_best_gpu(min_memory_mb)
+
+
+def check_cuda_availability() -> bool:
+    """Check if CUDA is available"""
+    return get_gpu_manager().cuda_available
+
+
+def estimate_model_memory(model_id: str, precision: str = "float16") -> int:
+    """Estimate model memory requirements"""
+    return get_gpu_manager().estimate_model_memory(model_id, precision)

{isa_model-0.4.0.dist-info → isa_model-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa_model
-Version: 0.4.0
+Version: 0.4.3
 Summary: Unified AI model serving framework
 Author: isA_Model Contributors
 Classifier: Development Status :: 3 - Alpha
@@ -10,45 +10,87 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: fastapi>=0.95.0
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: httpx>=0.23.0
-Requires-Dist: pydantic>=2.0.0
 Requires-Dist: uvicorn>=0.22.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.23.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: transformers>=4.30.0
-Requires-Dist: langchain-core>=0.1.0
-Requires-Dist: huggingface-hub>=0.16.0
-Requires-Dist: kubernetes>=25.3.0
-Requires-Dist: mlflow>=2.4.0
-Requires-Dist: torch>=2.0.0
-Requires-Dist: openai>=1.10.0
-Requires-Dist: replicate>=0.23.0
 Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: ollama>=0.3.0
-Requires-Dist: runpod>=1.0.0
-Requires-Dist: boto3>=1.26.0
-Requires-Dist: google-cloud-storage>=2.7.0
-Requires-Dist: datasets>=2.10.0
-Requires-Dist: accelerate>=0.20.0
-Requires-Dist: bitsandbytes>=0.39.0
-Requires-Dist: peft>=0.4.0
-Requires-Dist: trl>=0.4.0
+Requires-Dist: numpy>=1.20.0
 Requires-Dist: supabase>=2.0.0
-Requires-Dist: pgvector>=0.2.0
 Requires-Dist: psycopg2-binary>=2.9.0
 Requires-Dist: asyncpg>=0.28.0
 Requires-Dist: slowapi>=0.1.8
-Requires-Dist: redis>=4.5.0
 Requires-Dist: circuitbreaker>=1.3.2
-Requires-Dist: prometheus-fastapi-instrumentator>=6.1.0
 Requires-Dist: structlog>=23.1.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: redis>=4.5.0
+Requires-Dist: tenacity>=8.2.0
+Provides-Extra: cloud
+Requires-Dist: openai>=1.10.0; extra == "cloud"
+Requires-Dist: replicate>=0.23.0; extra == "cloud"
+Requires-Dist: cerebras-cloud-sdk>=1.0.0; extra == "cloud"
+Requires-Dist: modal>=0.63.0; extra == "cloud"
+Requires-Dist: grpclib>=0.4.7; extra == "cloud"
+Requires-Dist: python-logging-loki>=0.3.1; extra == "cloud"
+Requires-Dist: huggingface-hub>=0.16.0; extra == "cloud"
+Requires-Dist: docker>=6.0.0; extra == "cloud"
+Requires-Dist: influxdb-client>=1.36.0; extra == "cloud"
+Requires-Dist: tiktoken>=0.5.0; extra == "cloud"
+Provides-Extra: local
+Requires-Dist: torch>=2.0.0; extra == "local"
+Requires-Dist: transformers>=4.30.0; extra == "local"
+Requires-Dist: accelerate>=0.20.0; extra == "local"
+Requires-Dist: huggingface-hub>=0.16.0; extra == "local"
+Requires-Dist: safetensors>=0.4.1; extra == "local"
+Requires-Dist: sentencepiece>=0.1.99; extra == "local"
+Provides-Extra: training
+Requires-Dist: datasets>=2.10.0; extra == "training"
+Requires-Dist: peft>=0.4.0; extra == "training"
+Requires-Dist: trl>=0.4.0; extra == "training"
+Requires-Dist: bitsandbytes>=0.39.0; extra == "training"
+Provides-Extra: audio
+Requires-Dist: librosa>=0.10.1; extra == "audio"
+Requires-Dist: soundfile>=0.12.1; extra == "audio"
+Requires-Dist: numba>=0.57.0; extra == "audio"
+Provides-Extra: vision
+Requires-Dist: Pillow>=10.0.1; extra == "vision"
+Requires-Dist: torchvision>=0.15.2; extra == "vision"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Requires-Dist: langchain-openai>=0.0.2; extra == "langchain"
+Provides-Extra: storage
+Requires-Dist: boto3>=1.26.0; extra == "storage"
+Requires-Dist: google-cloud-storage>=2.7.0; extra == "storage"
+Provides-Extra: monitoring
+Requires-Dist: mlflow>=2.4.0; extra == "monitoring"
+Requires-Dist: redis>=4.5.0; extra == "monitoring"
+Requires-Dist: prometheus-fastapi-instrumentator>=6.1.0; extra == "monitoring"
+Requires-Dist: influxdb-client>=1.36.0; extra == "monitoring"
+Requires-Dist: pgvector>=0.2.0; extra == "monitoring"
+Requires-Dist: python-logging-loki>=0.3.1; extra == "monitoring"
+Provides-Extra: k8s
+Requires-Dist: kubernetes>=25.3.0; extra == "k8s"
+Provides-Extra: gpu-cloud
+Requires-Dist: runpod>=1.0.0; extra == "gpu-cloud"
+Requires-Dist: ollama>=0.3.0; extra == "gpu-cloud"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: flake8>=4.0.0; extra == "dev"
 Requires-Dist: mypy>=0.991; extra == "dev"
 Requires-Dist: twine>=4.0.0; extra == "dev"
+Provides-Extra: api-only
+Requires-Dist: isa-model[cloud,langchain]; extra == "api-only"
+Provides-Extra: full-local
+Requires-Dist: isa-model[audio,langchain,local,training,vision]; extra == "full-local"
+Provides-Extra: production
+Requires-Dist: isa-model[cloud,k8s,monitoring,storage]; extra == "production"
+Provides-Extra: staging
+Requires-Dist: isa-model[cloud,langchain,monitoring,storage]; extra == "staging"
+Requires-Dist: python-consul>=1.1.0; extra == "staging"
+Provides-Extra: all
+Requires-Dist: isa-model[audio,cloud,gpu-cloud,k8s,langchain,local,monitoring,storage,training,vision]; extra == "all"
 
 # isa_model_sdk - Unified AI Model Serving Framework