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

isa_model/inference/services/embedding/ollama_embed_service.py

@@ -1,75 +1,87 @@
 import logging
+import httpx
+import asyncio
 from typing import List, Dict, Any, Optional
+
+# 保留您指定的导入和框架结构
 from isa_model.inference.services.base_service import BaseEmbeddingService
 from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.backends.local_services import OllamaBackendClient
 
 logger = logging.getLogger(__name__)
 
 class OllamaEmbedService(BaseEmbeddingService):
-    """Ollama embedding service using backend client"""
+    """
+    Ollama embedding service.
+    此类遵循基础服务架构，但使用其自己的 HTTP 客户端与 Ollama API 通信，
+    而不依赖于注入的 backend 对象。
+    """
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "bge-m3", backend: Optional[OllamaBackendClient] = None):
+    def __init__(self, provider: 'BaseProvider', model_name: str = "bge-m3"):
+        # 保持对基类和 provider 的兼容
         super().__init__(provider, model_name)
         
-        # Use provided backend or create new one
-        if backend:
-            self.backend = backend
-        else:
-            host = self.config.get("host", "localhost")
-            port = self.config.get("port", 11434)
-            self.backend = OllamaBackendClient(host, port)
+        # 从基类继承的 self.config 中获取配置
+        host = self.config.get("host", "localhost")
+        port = self.config.get("port", 11434)
+        
+        # 创建并持有自己的 httpx 客户端实例
+        base_url = f"http://{host}:{port}"
+        self.client = httpx.AsyncClient(base_url=base_url, timeout=30.0)
             
-        logger.info(f"Initialized OllamaEmbedService with model {model_name}")
+        logger.info(f"Initialized OllamaEmbedService with model '{self.model_name}' at {base_url}")
     
     async def create_text_embedding(self, text: str) -> List[float]:
-        """Create embedding for text"""
+        """为单个文本创建 embedding"""
         try:
             payload = {
                 "model": self.model_name,
                 "prompt": text
             }
-            response = await self.backend.post("/api/embeddings", payload)
-            return response["embedding"]
+            # 使用自己的 client 实例，而不是 self.backend
+            response = await self.client.post("/api/embeddings", json=payload)
+            response.raise_for_status() # 检查请求是否成功
+            return response.json()["embedding"]
             
+        except httpx.RequestError as e:
+            logger.error(f"An error occurred while requesting {e.request.url!r}: {e}")
+            raise
         except Exception as e:
             logger.error(f"Error creating text embedding: {e}")
             raise
     
     async def create_text_embeddings(self, texts: List[str]) -> List[List[float]]:
-        """Create embeddings for multiple texts"""
-        embeddings = []
-        for text in texts:
-            embedding = await self.create_text_embedding(text)
-            embeddings.append(embedding)
+        """为多个文本并发地创建 embeddings"""
+        if not texts:
+            return []
+        
+        tasks = [self.create_text_embedding(text) for text in texts]
+        embeddings = await asyncio.gather(*tasks)
         return embeddings
     
     async def create_chunks(self, text: str, metadata: Optional[Dict] = None) -> List[Dict]:
-        """Create text chunks with embeddings"""
-        # 简单实现：将文本分成固定大小的块
+        """将文本分块并为每个块创建 embedding"""
         chunk_size = 200  # 单词数量
-        chunks = []
-        
-        # 按单词分割
         words = text.split()
+        chunk_texts = [" ".join(words[i:i+chunk_size]) for i in range(0, len(words), chunk_size)]
         
-        # 分块
-        for i in range(0, len(words), chunk_size):
-            chunk_text = " ".join(words[i:i+chunk_size])
-            embedding = await self.create_text_embedding(chunk_text)
-            
-            chunk = {
+        if not chunk_texts:
+            return []
+
+        embeddings = await self.create_text_embeddings(chunk_texts)
+        
+        chunks = [
+            {
                 "text": chunk_text,
-                "embedding": embedding,
+                "embedding": emb,
                 "metadata": metadata or {}
             }
-            chunks.append(chunk)
+            for chunk_text, emb in zip(chunk_texts, embeddings)
+        ]
             
         return chunks
     
     async def compute_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
         """计算两个嵌入向量之间的余弦相似度"""
-        # 余弦相似度简单实现
         dot_product = sum(a * b for a, b in zip(embedding1, embedding2))
         norm1 = sum(a * a for a in embedding1) ** 0.5
         norm2 = sum(b * b for b in embedding2) ** 0.5
@@ -80,6 +92,6 @@ class OllamaEmbedService(BaseEmbeddingService):
         return dot_product / (norm1 * norm2)
     
     async def close(self):
-        """Close the backend client"""
-        await self.backend.close()
-
+        """关闭内置的 HTTP 客户端"""
+        await self.client.aclose()
+        logger.info("OllamaEmbedService's internal client has been closed.")

isa_model/inference/services/llm/__init__.py

@@ -4,13 +4,9 @@ LLM Services - Business logic services for Language Models
 
 # Import LLM services here when created
 from .ollama_llm_service import OllamaLLMService
-from .triton_llm_service import TritonLLMService
 from .openai_llm_service import OpenAILLMService
-from .replicate_llm_service import ReplicateLLMService
 
 __all__ = [
     "OllamaLLMService",
-    "TritonLLMService",
     "OpenAILLMService",
-    "ReplicateLLMService",
 ] 

isa_model/inference/services/llm/base_llm_service.py

@@ -0,0 +1,134 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Union, Optional, AsyncGenerator, TypeVar
+from isa_model.inference.services.base_service import BaseService
+
+T = TypeVar('T')  # Generic type for responses
+
+class BaseLLMService(BaseService):
+    """Base class for Large Language Model services"""
+    
+    @abstractmethod
+    async def ainvoke(self, prompt: Union[str, List[Dict[str, str]], Any]) -> T:
+        """
+        Universal invocation method that handles different input types
+        
+        Args:
+            prompt: Can be a string, list of messages, or other format
+            
+        Returns:
+            Model response in the appropriate format
+        """
+        pass
+    
+    @abstractmethod
+    async def achat(self, messages: List[Dict[str, str]]) -> T:
+        """
+        Chat completion method using message format
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content' keys
+                     Example: [{"role": "user", "content": "Hello"}]
+            
+        Returns:
+            Chat completion response
+        """
+        pass
+    
+    @abstractmethod
+    async def acompletion(self, prompt: str) -> T:
+        """
+        Text completion method for simple prompt completion
+        
+        Args:
+            prompt: Input text prompt
+            
+        Returns:
+            Text completion response
+        """
+        pass
+    
+    @abstractmethod
+    async def agenerate(self, messages: List[Dict[str, str]], n: int = 1) -> List[T]:
+        """
+        Generate multiple completions for the same input
+        
+        Args:
+            messages: List of message dictionaries
+            n: Number of completions to generate
+            
+        Returns:
+            List of completion responses
+        """
+        pass
+    
+    @abstractmethod
+    async def astream_chat(self, messages: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
+        """
+        Stream chat responses token by token
+        
+        Args:
+            messages: List of message dictionaries
+            
+        Yields:
+            Individual tokens or chunks of the response
+        """
+        pass
+    
+    @abstractmethod
+    async def astream_completion(self, prompt: str) -> AsyncGenerator[str, None]:
+        """
+        Stream completion responses token by token
+        
+        Args:
+            prompt: Input text prompt
+            
+        Yields:
+            Individual tokens or chunks of the response
+        """
+        pass
+    
+    @abstractmethod
+    def get_token_usage(self) -> Dict[str, Any]:
+        """
+        Get cumulative token usage statistics for this service instance
+        
+        Returns:
+            Dict containing token usage information:
+            - total_tokens: Total tokens used
+            - prompt_tokens: Tokens used for prompts
+            - completion_tokens: Tokens used for completions
+            - requests_count: Number of requests made
+        """
+        pass
+    
+    @abstractmethod
+    def get_last_token_usage(self) -> Dict[str, int]:
+        """
+        Get token usage from the last request
+        
+        Returns:
+            Dict containing last request token usage:
+            - prompt_tokens: Tokens in last prompt
+            - completion_tokens: Tokens in last completion
+            - total_tokens: Total tokens in last request
+        """
+        pass
+    
+    @abstractmethod
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Get information about the current model
+        
+        Returns:
+            Dict containing model information:
+            - name: Model name
+            - max_tokens: Maximum context length
+            - supports_streaming: Whether streaming is supported
+            - supports_functions: Whether function calling is supported
+        """
+        pass
+    
+    @abstractmethod
+    async def close(self):
+        """Cleanup resources and close connections"""
+        pass

isa_model/inference/services/llm/ollama_llm_service.py

@@ -2,23 +2,14 @@ import logging
 from typing import Dict, Any, List, Union, AsyncGenerator, Optional
 from isa_model.inference.services.base_service import BaseLLMService
 from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.backends.local_services import OllamaBackendClient
 
 logger = logging.getLogger(__name__)
 
 class OllamaLLMService(BaseLLMService):
     """Ollama LLM service using backend client"""
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "llama3.1", backend: Optional[OllamaBackendClient] = None):
+    def __init__(self, provider: 'BaseProvider', model_name: str = "llama3.1"):
         super().__init__(provider, model_name)
-        
-        # Use provided backend or create new one
-        if backend:
-            self.backend = backend
-        else:
-            host = self.config.get("host", "localhost")
-            port = self.config.get("port", 11434)
-            self.backend = OllamaBackendClient(host, port)
             
         self.last_token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
         logger.info(f"Initialized OllamaLLMService with model {model_name}")

isa_model/inference/services/llm/openai_llm_service.py

@@ -1,72 +1,80 @@
 import logging
+import os
 from typing import Dict, Any, List, Union, AsyncGenerator, Optional
+
+# 使用官方 OpenAI 库和 dotenv
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
 from isa_model.inference.services.base_service import BaseLLMService
 from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.backends.openai_client import OpenAIBackendClient
+
+# 加载 .env.local 文件中的环境变量
+load_dotenv(dotenv_path='.env.local')
 
 logger = logging.getLogger(__name__)
 
 class OpenAILLMService(BaseLLMService):
     """OpenAI LLM service implementation"""
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "gpt-3.5-turbo", backend: Optional[OpenAIBackendClient] = None):
+    def __init__(self, provider: 'BaseProvider', model_name: str = "gpt-3.5-turbo"):
         super().__init__(provider, model_name)
         
-        # Use provided backend or create new one
-        if backend:
-            self.backend = backend
-        else:
-            api_key = self.config.get("api_key", "")
-            api_base = self.config.get("api_base", "https://api.openai.com/v1")
-            self.backend = OpenAIBackendClient(api_key, api_base)
+        # 从provider配置初始化 AsyncOpenAI 客户端
+        try:
+            api_key = provider.config.get("api_key") or os.getenv("OPENAI_API_KEY")
+            base_url = provider.config.get("api_base") or os.getenv("OPENAI_API_BASE")
+            
+            self.client = AsyncOpenAI(
+                api_key=api_key,
+                base_url=base_url
+            )
+        except TypeError as e:
+            logger.error("初始化 OpenAI 客户端失败。请检查您的 .env.local 文件中是否正确设置了 OPENAI_API_KEY。")
+            raise ValueError("OPENAI_API_KEY 未设置。") from e
             
         self.last_token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-        logger.info(f"Initialized OpenAILLMService with model {model_name}")
+        logger.info(f"Initialized OpenAILLMService with model {self.model_name} and endpoint {self.client.base_url}")
     
-    async def ainvoke(self, prompt: Union[str, List[Dict[str, str]], Any]):
+    async def ainvoke(self, prompt: Union[str, List[Dict[str, str]], Any]) -> str:
         """Universal invocation method"""
         if isinstance(prompt, str):
             return await self.acompletion(prompt)
         elif isinstance(prompt, list):
             return await self.achat(prompt)
         else:
-            raise ValueError("Prompt must be string or list of messages")
+            raise ValueError("Prompt must be a string or a list of messages")
     
-    async def achat(self, messages: List[Dict[str, str]]):
+    async def achat(self, messages: List[Dict[str, str]]) -> str:
         """Chat completion method"""
         try:
             temperature = self.config.get("temperature", 0.7)
             max_tokens = self.config.get("max_tokens", 1024)
             
-            payload = {
-                "model": self.model_name,
-                "messages": messages,
-                "temperature": temperature,
-                "max_tokens": max_tokens
-            }
-            response = await self.backend.post("/chat/completions", payload)
+            response = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
             
-            # Update token usage
-            self.last_token_usage = response.get("usage", {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-            })
+            if response.usage:
+                self.last_token_usage = {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens
+                }
             
-            return response["choices"][0]["message"]["content"]
+            return response.choices[0].message.content or ""
             
         except Exception as e:
             logger.error(f"Error in chat completion: {e}")
             raise
     
-    async def acompletion(self, prompt: str):
-        """Text completion method (using chat API since completions is deprecated)"""
-        try:
-            messages = [{"role": "user", "content": prompt}]
-            return await self.achat(messages)
-        except Exception as e:
-            logger.error(f"Error in text completion: {e}")
-            raise
+    async def acompletion(self, prompt: str) -> str:
+        """Text completion method (using chat API)"""
+        messages = [{"role": "user", "content": prompt}]
+        return await self.achat(messages)
     
     async def agenerate(self, messages: List[Dict[str, str]], n: int = 1) -> List[str]:
         """Generate multiple completions"""
@@ -74,23 +82,22 @@ class OpenAILLMService(BaseLLMService):
             temperature = self.config.get("temperature", 0.7)
             max_tokens = self.config.get("max_tokens", 1024)
             
-            payload = {
-                "model": self.model_name,
-                "messages": messages,
-                "temperature": temperature,
-                "max_tokens": max_tokens,
-                "n": n
-            }
-            response = await self.backend.post("/chat/completions", payload)
+            response = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                n=n
+            )
             
-            # Update token usage
-            self.last_token_usage = response.get("usage", {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-            })
+            if response.usage:
+                self.last_token_usage = {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens
+                }
             
-            return [choice["message"]["content"] for choice in response["choices"]]
+            return [choice.message.content or "" for choice in response.choices]
         except Exception as e:
             logger.error(f"Error in generate: {e}")
             raise
@@ -101,22 +108,24 @@ class OpenAILLMService(BaseLLMService):
             temperature = self.config.get("temperature", 0.7)
             max_tokens = self.config.get("max_tokens", 1024)
             
-            payload = {
-                "model": self.model_name,
-                "messages": messages,
-                "temperature": temperature,
-                "max_tokens": max_tokens,
-                "stream": True
-            }
+            stream = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True
+            )
             
-            async for chunk in self.backend.stream_chat(payload):
-                yield chunk
+            async for chunk in stream:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
                 
         except Exception as e:
             logger.error(f"Error in stream chat: {e}")
             raise
     
-    def get_token_usage(self):
+    def get_token_usage(self) -> Dict[str, int]:
         """Get total token usage statistics"""
         return self.last_token_usage
     
@@ -126,4 +135,4 @@ class OpenAILLMService(BaseLLMService):
         
     async def close(self):
         """Close the backend client"""
-        await self.backend.close() 
+        await self.client.aclose()

isa_model/inference/services/vision/__init__.py

@@ -7,6 +7,6 @@ Vision服务包
 """
 
 # 导出ReplicateVisionService
-from isa_model.inference.services.vision.replicate_vision_service import ReplicateVisionService
+from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateVisionService
 
 __all__ = ["ReplicateVisionService"] 

isa_model/inference/services/vision/ollama_vision_service.py

@@ -4,11 +4,11 @@ import base64
 import ollama
 from typing import Dict, Any, Union
 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 OllamaVisionService(BaseService):
     """Vision model service wrapper for Ollama using base64 encoded images"""

isa_model/inference/services/vision/{yyds_vision_service.py → openai_vision_service.py}

@@ -1,14 +1,14 @@
 from typing import Dict, Any, Union
 from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
-from ...base_service import BaseService
-from ...base_provider import BaseProvider
+from isa_model.inference.services.base_service import BaseService
+from isa_model.inference.providers.base_provider import BaseProvider
 from .helpers.image_utils import compress_image, encode_image_to_base64
-from app.config.config_manager import config_manager
+import logging
 
-logger = config_manager.get_logger(__name__)
+logger = logging.getLogger(__name__)
 
-class YYDSVisionService(BaseService):
+class OpenAIVisionService(BaseService):
     """Vision model service wrapper for YYDS"""
     
     def __init__(self, provider: 'BaseProvider', model_name: str):