isa-model 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

isa_model/inference/ai_factory.py

@@ -5,11 +5,6 @@ from isa_model.inference.services.base_service import BaseService
 from isa_model.inference.base import ModelType
 import os
 
-from isa_model.inference.services.llm.llama_service import LlamaService
-from isa_model.inference.services.llm.gemma_service import GemmaService
-from isa_model.inference.services.audio.whisper_service import WhisperService
-from isa_model.inference.services.embedding.bge_service import BgeEmbeddingService
-
 # 设置基本的日志配置
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -29,7 +24,7 @@ class AIFactory:
     
     def __init__(self):
         """Initialize the AI Factory."""
-        self.triton_url = os.environ.get("TRITON_URL", "localhost:8001")
+        self.triton_url = os.environ.get("TRITON_URL", "http://localhost:8000")
         
         # Cache for services (singleton pattern)
         self._llm_services = {}
@@ -70,58 +65,25 @@ class AIFactory:
             # Register Replicate provider and services
             try:
                 from isa_model.inference.providers.replicate_provider import ReplicateProvider
-                from isa_model.inference.services.llm.replicate_llm_service import ReplicateLLMService
-                from isa_model.inference.services.vision.replicate_vision_service import ReplicateVisionService
+                from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateVisionService
                 
                 self.register_provider('replicate', ReplicateProvider)
-                self.register_service('replicate', ModelType.LLM, ReplicateLLMService)
                 self.register_service('replicate', ModelType.VISION, ReplicateVisionService)
-                logger.info("Replicate services registered successfully")
+                logger.info("Replicate provider and vision service registered successfully")
             except ImportError as e:
                 logger.warning(f"Replicate services not available: {e}")
+            except Exception as e:
+                logger.warning(f"Error registering Replicate services: {e}")
             
             # Try to register Triton services
             try:
                 from isa_model.inference.providers.triton_provider import TritonProvider
-                from isa_model.inference.services.llm.triton_llm_service import TritonLLMService
-                from isa_model.inference.services.vision.triton_vision_service import TritonVisionService
-                from isa_model.inference.services.audio.triton_speech_service import TritonSpeechService
                 
                 self.register_provider('triton', TritonProvider)
-                self.register_service('triton', ModelType.LLM, TritonLLMService)
-                self.register_service('triton', ModelType.VISION, TritonVisionService)
-                self.register_service('triton', ModelType.AUDIO, TritonSpeechService)
-                logger.info("Triton services registered successfully")
-                
-                # Register HuggingFace-based direct LLM service for Llama3-8B
-                try:
-                    from isa_model.inference.llm.llama3_service import Llama3Service
-                    # Register as a standalone service for direct access
-                    self._cached_services["llama3"] = Llama3Service()
-                    logger.info("Llama3-8B service registered successfully")
-                except ImportError as e:
-                    logger.warning(f"Llama3-8B service not available: {e}")
-                
-                # Register HuggingFace-based direct Vision service for Gemma3-4B
-                try:
-                    from isa_model.inference.vision.gemma3_service import Gemma3VisionService
-                    # Register as a standalone service for direct access
-                    self._cached_services["gemma3"] = Gemma3VisionService()
-                    logger.info("Gemma3-4B Vision service registered successfully")
-                except ImportError as e:
-                    logger.warning(f"Gemma3-4B Vision service not available: {e}")
-                
-                # Register HuggingFace-based direct Speech service for Whisper Tiny
-                try:
-                    from isa_model.inference.speech.whisper_service import WhisperService
-                    # Register as a standalone service for direct access
-                    self._cached_services["whisper"] = WhisperService()
-                    logger.info("Whisper Tiny Speech service registered successfully")
-                except ImportError as e:
-                    logger.warning(f"Whisper Tiny Speech service not available: {e}")
+                logger.info("Triton provider registered successfully")
                 
             except ImportError as e:
-                logger.warning(f"Triton services not available: {e}")
+                logger.warning(f"Triton provider not available: {e}")
             
             logger.info("Default AI providers and services initialized with backend architecture")
         except Exception as e:
@@ -176,24 +138,90 @@ class AIFactory:
     
     # Convenient methods for common services
     def get_llm(self, model_name: str = "llama3.1", provider: str = "ollama",
-                config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get a LLM service instance"""
+                config: Optional[Dict[str, Any]] = None, api_key: Optional[str] = None) -> BaseService:
+        """
+        Get a LLM service instance
+        
+        Args:
+            model_name: Name of the model to use
+            provider: Provider name ('ollama', 'openai', 'replicate', etc.)
+            config: Optional configuration dictionary
+            api_key: Optional API key for the provider (OpenAI, Replicate, etc.)
+            
+        Returns:
+            LLM service instance
+            
+        Example:
+            # Using with API key directly
+            llm = AIFactory.get_instance().get_llm(
+                model_name="gpt-4o-mini", 
+                provider="openai", 
+                api_key="your-api-key-here"
+            )
+            
+            # Using without API key (will use environment variable)
+            llm = AIFactory.get_instance().get_llm(
+                model_name="gpt-4o-mini", 
+                provider="openai"
+            )
+        """
+        
+        # Special case for DeepSeek service
+        if model_name.lower() in ["deepseek", "deepseek-r1", "qwen3-8b"]:
+            if "deepseek" in self._cached_services:
+                return self._cached_services["deepseek"]
         
         # Special case for Llama3-8B direct service
         if model_name.lower() in ["llama3", "llama3-8b", "meta-llama-3"]:
             if "llama3" in self._cached_services:
                 return self._cached_services["llama3"]
         
-        basic_config = {
+        basic_config: Dict[str, Any] = {
             "temperature": 0
         }
+        
+        # Add API key to config if provided
+        if api_key:
+            if provider == "openai":
+                basic_config["api_key"] = api_key
+            elif provider == "replicate":
+                basic_config["api_token"] = api_key
+            else:
+                logger.warning(f"API key provided but provider '{provider}' may not support it")
+        
         if config:
             basic_config.update(config)
         return self.create_service(provider, ModelType.LLM, model_name, basic_config)
     
     def get_vision_model(self, model_name: str = "gemma3-4b", provider: str = "triton",
-                       config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get a vision model service instance"""
+                       config: Optional[Dict[str, Any]] = None, api_key: Optional[str] = None) -> BaseService:
+        """
+        Get a vision model service instance
+        
+        Args:
+            model_name: Name of the model to use
+            provider: Provider name ('openai', 'replicate', 'triton', etc.)
+            config: Optional configuration dictionary
+            api_key: Optional API key for the provider (OpenAI, Replicate, etc.)
+            
+        Returns:
+            Vision service instance
+            
+        Example:
+            # Using with API key directly
+            vision = AIFactory.get_instance().get_vision_model(
+                model_name="gpt-4o", 
+                provider="openai", 
+                api_key="your-api-key-here"
+            )
+            
+            # Using Replicate for image generation
+            image_gen = AIFactory.get_instance().get_vision_model(
+                model_name="stability-ai/sdxl", 
+                provider="replicate", 
+                api_key="your-replicate-token"
+            )
+        """
         
         # Special case for Gemma3-4B direct service
         if model_name.lower() in ["gemma3", "gemma3-4b", "gemma3-vision"]:
@@ -202,19 +230,33 @@ class AIFactory:
         
         # Special case for Replicate's image generation models
         if provider == "replicate" and "/" in model_name:
-            basic_config = {
-                "api_token": os.environ.get("REPLICATE_API_TOKEN", ""),
+            replicate_config: Dict[str, Any] = {
                 "guidance_scale": 7.5,
                 "num_inference_steps": 30
             }
+            
+            # Add API key if provided
+            if api_key:
+                replicate_config["api_token"] = api_key
+            
             if config:
-                basic_config.update(config)
-            return self.create_service(provider, ModelType.VISION, model_name, basic_config)
+                replicate_config.update(config)
+            return self.create_service(provider, ModelType.VISION, model_name, replicate_config)
         
-        basic_config = {
+        basic_config: Dict[str, Any] = {
             "temperature": 0.7,
             "max_new_tokens": 512
         }
+        
+        # Add API key to config if provided
+        if api_key:
+            if provider == "openai":
+                basic_config["api_key"] = api_key
+            elif provider == "replicate":
+                basic_config["api_token"] = api_key
+            else:
+                logger.warning(f"API key provided but provider '{provider}' may not support it")
+        
         if config:
             basic_config.update(config)
         return self.create_service(provider, ModelType.VISION, model_name, basic_config)
@@ -251,32 +293,6 @@ class AIFactory:
             basic_config.update(config)
         return self.create_service(provider, ModelType.AUDIO, model_name, basic_config)
     
-    async def get_llm_service(self, model_name: str) -> Any:
-        """
-        Get an LLM service for the specified model.
-        
-        Args:
-            model_name: Name of the model
-            
-        Returns:
-            LLM service instance
-        """
-        if model_name in self._llm_services:
-            return self._llm_services[model_name]
-        
-        if model_name == "llama":
-            service = LlamaService(triton_url=self.triton_url, model_name="llama")
-            await service.load()
-            self._llm_services[model_name] = service
-            return service
-        elif model_name == "gemma":
-            service = GemmaService(triton_url=self.triton_url, model_name="gemma")
-            await service.load()
-            self._llm_services[model_name] = service
-            return service
-        else:
-            raise ValueError(f"Unsupported LLM model: {model_name}")
-    
     async def get_embedding_service(self, model_name: str) -> Any:
         """
         Get an embedding service for the specified model.
@@ -290,11 +306,6 @@ class AIFactory:
         if model_name in self._embedding_services:
             return self._embedding_services[model_name]
         
-        if model_name == "bge_embed":
-            service = BgeEmbeddingService(triton_url=self.triton_url, model_name="bge_embed")
-            await service.load()
-            self._embedding_services[model_name] = service
-            return service
         else:
             raise ValueError(f"Unsupported embedding model: {model_name}")
     
@@ -311,13 +322,6 @@ class AIFactory:
         if model_name in self._speech_services:
             return self._speech_services[model_name]
         
-        if model_name == "whisper":
-            service = WhisperService(triton_url=self.triton_url, model_name="whisper")
-            await service.load()
-            self._speech_services[model_name] = service
-            return service
-        else:
-            raise ValueError(f"Unsupported speech model: {model_name}")
     
     def get_model_info(self, model_type: Optional[str] = None) -> Dict[str, Any]:
         """
@@ -331,6 +335,7 @@ class AIFactory:
         """
         models = {
             "llm": [
+                {"name": "deepseek", "description": "DeepSeek-R1-0528-Qwen3-8B language model"},
                 {"name": "llama", "description": "Llama3-8B language model"},
                 {"name": "gemma", "description": "Gemma3-4B language model"}
             ],

isa_model/inference/providers/openai_provider.py

@@ -15,13 +15,13 @@ class OpenAIProvider(BaseProvider):
         
         Args:
             config (dict, optional): Configuration for the provider
-                - api_key: OpenAI API key (default: from environment variable)
+                - api_key: OpenAI API key (can be passed here or via environment variable)
                 - api_base: Base URL for OpenAI API (default: https://api.openai.com/v1)
                 - timeout: Timeout for API calls in seconds
         """
         default_config = {
-            "api_key": os.environ.get("OPENAI_API_KEY", ""),
-            "api_base": "https://api.openai.com/v1",
+            "api_key": "",  # Will be set from config or environment
+            "api_base": os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
             "timeout": 60,
             "stream": True,
             "temperature": 0.7,
@@ -32,14 +32,28 @@ class OpenAIProvider(BaseProvider):
         # Merge default config with provided config
         merged_config = {**default_config, **(config or {})}
         
+        # Set API key from config first, then fallback to environment variable
+        if not merged_config["api_key"]:
+            merged_config["api_key"] = os.environ.get("OPENAI_API_KEY", "")
+        
         super().__init__(config=merged_config)
         self.name = "openai"
         
         logger.info(f"Initialized OpenAIProvider with URL: {self.config['api_base']}")
         
-        # Validate API key
+        # Only warn if no API key is provided at all
         if not self.config["api_key"]:
-            logger.warning("OpenAI API key not provided. Set OPENAI_API_KEY environment variable or pass in config.")
+            logger.info("OpenAI API key not provided. You can set it via OPENAI_API_KEY environment variable or pass it in the config when creating services.")
+    
+    def set_api_key(self, api_key: str):
+        """
+        Set the API key after initialization
+        
+        Args:
+            api_key: OpenAI API key
+        """
+        self.config["api_key"] = api_key
+        logger.info("OpenAI API key updated")
     
     def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
         """Get provider capabilities by model type"""
@@ -52,7 +66,7 @@ class OpenAIProvider(BaseProvider):
                 Capability.EMBEDDING
             ],
             ModelType.VISION: [
-                Capability.IMAGE_UNDERSTANDING,
+                Capability.IMAGE_GENERATION,
                 Capability.MULTIMODAL_UNDERSTANDING
             ],
             ModelType.AUDIO: [
@@ -63,7 +77,7 @@ class OpenAIProvider(BaseProvider):
     def get_models(self, model_type: ModelType) -> List[str]:
         """Get available models for given type"""
         if model_type == ModelType.LLM:
-            return ["gpt-4o", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"]
+            return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"]
         elif model_type == ModelType.EMBEDDING:
             return ["text-embedding-3-large", "text-embedding-3-small", "text-embedding-ada-002"]
         elif model_type == ModelType.VISION:

isa_model/inference/providers/replicate_provider.py

@@ -15,11 +15,11 @@ class ReplicateProvider(BaseProvider):
         
         Args:
             config (dict, optional): Configuration for the provider
-                - api_token: Replicate API token (default: from environment variable)
+                - api_token: Replicate API token (can be passed here or via environment variable)
                 - timeout: Timeout for API calls in seconds
         """
         default_config = {
-            "api_token": os.environ.get("REPLICATE_API_TOKEN", ""),
+            "api_token": "",  # Will be set from config or environment
             "timeout": 60,
             "stream": True,
             "max_tokens": 1024
@@ -28,14 +28,28 @@ class ReplicateProvider(BaseProvider):
         # Merge default config with provided config
         merged_config = {**default_config, **(config or {})}
         
+        # Set API token from config first, then fallback to environment variable
+        if not merged_config["api_token"]:
+            merged_config["api_token"] = os.environ.get("REPLICATE_API_TOKEN", "")
+        
         super().__init__(config=merged_config)
         self.name = "replicate"
         
         logger.info(f"Initialized ReplicateProvider")
         
-        # Validate API token
+        # Only warn if no API token is provided at all
         if not self.config["api_token"]:
-            logger.warning("Replicate API token not provided. Set REPLICATE_API_TOKEN environment variable or pass in config.")
+            logger.info("Replicate API token not provided. You can set it via REPLICATE_API_TOKEN environment variable or pass it in the config when creating services.")
+    
+    def set_api_token(self, api_token: str):
+        """
+        Set the API token after initialization
+        
+        Args:
+            api_token: Replicate API token
+        """
+        self.config["api_token"] = api_token
+        logger.info("Replicate API token updated")
     
     def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
         """Get provider capabilities by model type"""
@@ -45,7 +59,6 @@ class ReplicateProvider(BaseProvider):
                 Capability.COMPLETION
             ],
             ModelType.VISION: [
-                Capability.IMAGE_UNDERSTANDING,
                 Capability.IMAGE_GENERATION,
                 Capability.MULTIMODAL_UNDERSTANDING
             ],

isa_model/inference/providers/triton_provider.py

@@ -29,7 +29,7 @@ class TritonProvider(BaseProvider):
         
         # Default configuration
         self.default_config = {
-            "server_url": os.environ.get("TRITON_SERVER_URL", "localhost:8000"),
+            "server_url": os.environ.get("TRITON_SERVER_URL", "http://localhost:8000"),
             "model_repository": os.environ.get(
                 "MODEL_REPOSITORY", 
                 os.path.join(os.getcwd(), "models/triton/model_repository")

isa_model/inference/services/audio/base_stt_service.py

@@ -0,0 +1,91 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Union, Optional, BinaryIO
+from isa_model.inference.services.base_service import BaseService
+
+class BaseSTTService(BaseService):
+    """Base class for Speech-to-Text services"""
+    
+    @abstractmethod
+    async def transcribe_audio(
+        self, 
+        audio_file: Union[str, BinaryIO], 
+        language: Optional[str] = None,
+        prompt: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Transcribe audio file to text
+        
+        Args:
+            audio_file: Path to audio file or file-like object
+            language: Language code (e.g., 'en', 'es', 'fr')
+            prompt: Optional prompt to guide transcription
+            
+        Returns:
+            Dict containing transcription results with keys:
+            - text: The transcribed text
+            - language: Detected/specified language
+            - confidence: Confidence score (if available)
+            - segments: Time-segmented transcription (if available)
+        """
+        pass
+    
+    @abstractmethod
+    async def transcribe_audio_batch(
+        self, 
+        audio_files: List[Union[str, BinaryIO]], 
+        language: Optional[str] = None,
+        prompt: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Transcribe multiple audio files
+        
+        Args:
+            audio_files: List of audio file paths or file-like objects
+            language: Language code (e.g., 'en', 'es', 'fr')
+            prompt: Optional prompt to guide transcription
+            
+        Returns:
+            List of transcription results
+        """
+        pass
+    
+    @abstractmethod
+    async def detect_language(self, audio_file: Union[str, BinaryIO]) -> Dict[str, Any]:
+        """
+        Detect language of audio file
+        
+        Args:
+            audio_file: Path to audio file or file-like object
+            
+        Returns:
+            Dict containing language detection results with keys:
+            - language: Detected language code
+            - confidence: Confidence score
+            - alternatives: List of alternative languages with scores
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_formats(self) -> List[str]:
+        """
+        Get list of supported audio formats
+        
+        Returns:
+            List of supported file extensions (e.g., ['mp3', 'wav', 'flac'])
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_languages(self) -> List[str]:
+        """
+        Get list of supported language codes
+        
+        Returns:
+            List of supported language codes (e.g., ['en', 'es', 'fr'])
+        """
+        pass
+    
+    @abstractmethod
+    async def close(self):
+        """Cleanup resources"""
+        pass

isa_model/inference/services/audio/base_tts_service.py

@@ -0,0 +1,136 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Union, Optional, BinaryIO
+from isa_model.inference.services.base_service import BaseService
+
+class BaseTTSService(BaseService):
+    """Base class for Text-to-Speech services"""
+    
+    @abstractmethod
+    async def synthesize_speech(
+        self, 
+        text: str, 
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> Dict[str, Any]:
+        """
+        Synthesize speech from text
+        
+        Args:
+            text: Input text to convert to speech
+            voice: Voice ID or name to use
+            speed: Speech speed multiplier (0.5-2.0)
+            pitch: Pitch adjustment (-1.0 to 1.0)
+            format: Audio format ('mp3', 'wav', 'ogg')
+            
+        Returns:
+            Dict containing synthesis results with keys:
+            - audio_data: Binary audio data
+            - format: Audio format
+            - duration: Audio duration in seconds
+            - sample_rate: Audio sample rate
+        """
+        pass
+    
+    @abstractmethod
+    async def synthesize_speech_to_file(
+        self, 
+        text: str,
+        output_path: str,
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> Dict[str, Any]:
+        """
+        Synthesize speech and save directly to file
+        
+        Args:
+            text: Input text to convert to speech
+            output_path: Path to save the audio file
+            voice: Voice ID or name to use
+            speed: Speech speed multiplier (0.5-2.0)
+            pitch: Pitch adjustment (-1.0 to 1.0)
+            format: Audio format ('mp3', 'wav', 'ogg')
+            
+        Returns:
+            Dict containing synthesis results with keys:
+            - file_path: Path to saved audio file
+            - duration: Audio duration in seconds
+            - sample_rate: Audio sample rate
+        """
+        pass
+    
+    @abstractmethod
+    async def synthesize_speech_batch(
+        self, 
+        texts: List[str],
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> List[Dict[str, Any]]:
+        """
+        Synthesize speech for multiple texts
+        
+        Args:
+            texts: List of input texts to convert to speech
+            voice: Voice ID or name to use
+            speed: Speech speed multiplier (0.5-2.0)
+            pitch: Pitch adjustment (-1.0 to 1.0)
+            format: Audio format ('mp3', 'wav', 'ogg')
+            
+        Returns:
+            List of synthesis result dictionaries
+        """
+        pass
+    
+    @abstractmethod
+    def get_available_voices(self) -> List[Dict[str, Any]]:
+        """
+        Get list of available voices
+        
+        Returns:
+            List of voice information dictionaries with keys:
+            - id: Voice identifier
+            - name: Human-readable voice name
+            - language: Language code (e.g., 'en-US', 'es-ES')
+            - gender: Voice gender ('male', 'female', 'neutral')
+            - age: Voice age category ('adult', 'child', 'elderly')
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_formats(self) -> List[str]:
+        """
+        Get list of supported audio formats
+        
+        Returns:
+            List of supported file extensions (e.g., ['mp3', 'wav', 'ogg'])
+        """
+        pass
+    
+    @abstractmethod
+    def get_voice_info(self, voice_id: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a specific voice
+        
+        Args:
+            voice_id: Voice identifier
+            
+        Returns:
+            Dict containing voice information:
+            - id: Voice identifier
+            - name: Human-readable voice name
+            - language: Language code
+            - gender: Voice gender
+            - description: Voice description
+            - sample_rate: Default sample rate
+        """
+        pass
+    
+    @abstractmethod
+    async def close(self):
+        """Cleanup resources"""
+        pass

isa_model/inference/services/audio/{yyds_audio_service.py → openai_tts_service.py}

@@ -3,11 +3,11 @@ import tempfile
 import os
 from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
-from ...base_service import BaseService
-from ...base_provider import BaseProvider
-from app.config.config_manager import config_manager
+from isa_model.inference.services.base_service import BaseService
+from isa_model.inference.providers.base_provider import BaseProvider
+import logging
 
-logger = config_manager.get_logger(__name__)
+logger = logging.getLogger(__name__)
 
 class YYDSAudioService(BaseService):
     """Audio model service wrapper for YYDS"""