powermem 0.1.0__py3-none-any.whl

powermem/integrations/llm/qwen_asr.py

@@ -0,0 +1,171 @@
+import logging
+import os
+from typing import Dict, List, Optional, Union
+
+try:
+    import dashscope
+    from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+except ImportError:
+    dashscope = None
+    DashScopeAPIResponse = None
+
+from powermem.integrations.llm import LLMBase
+from powermem.integrations.llm.config.base import BaseLLMConfig
+from powermem.integrations.llm.config.qwen_asr import QwenASRConfig
+
+
+class QwenASR(LLMBase):
+    """
+    Qwen ASR (Automatic Speech Recognition) integration.
+    Converts audio to text using Qwen ASR models.
+    """
+
+    def __init__(self, config: Optional[Union[BaseLLMConfig, QwenASRConfig, Dict]] = None):
+        # Check if dashscope is available first
+        if dashscope is None:
+            raise ImportError(
+                "DashScope SDK is not installed. Please install it with: pip install dashscope"
+            )
+
+        # Convert to QwenASRConfig if needed
+        if config is None:
+            config = QwenASRConfig()
+        elif isinstance(config, dict):
+            config = QwenASRConfig(**config)
+        elif isinstance(config, BaseLLMConfig) and not isinstance(config, QwenASRConfig):
+            # Convert BaseLLMConfig to QwenASRConfig (only use model and api_key for ASR)
+            config = QwenASRConfig(
+                model=config.model,
+                api_key=config.api_key,
+            )
+
+        super().__init__(config)
+
+        if not self.config.model:
+            self.config.model = "qwen3-asr-flash"
+
+        # Set API key
+        api_key = self.config.api_key or os.getenv("DASHSCOPE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "API key is required. Set DASHSCOPE_API_KEY environment variable or pass api_key in config."
+            )
+
+        # Set API key for DashScope SDK
+        dashscope.api_key = api_key
+
+        # Set base URL
+        base_url = self.config.dashscope_base_url or os.getenv(
+            "DASHSCOPE_BASE_URL") or "https://dashscope.aliyuncs.com/api/v1"
+
+        if base_url:
+            dashscope.base_http_api_url = base_url
+
+    def _parse_response(self, response: DashScopeAPIResponse) -> str:
+        """
+        Parse the ASR response and extract text content.
+
+        Args:
+            response: The raw response from DashScope API.
+
+        Returns:
+            str: The extracted text content.
+        """
+        if response.status_code != 200:
+            raise Exception(f"API request failed with status {response.status_code}: {response.message}")
+
+        try:
+            choices = response.output.choices
+            if choices:
+                content = choices[0].message.content
+                if content:
+                    # Extract all text fields from content list
+                    texts = [item["text"] for item in content if "text" in item]
+                    # Join all text segments
+                    return " ".join(texts)
+            return ""
+        except Exception as e:
+            logging.error(f"Error parsing ASR response: {e}")
+            raise
+
+    def generate_response(
+            self,
+            messages: List[Dict[str, Union[str, List]]],
+            **kwargs,
+    ):
+        """
+        Generate text response from audio input using Qwen ASR.
+
+        Args:
+            messages: List of message dicts. For ASR, messages should contain audio content.
+                Example:
+                [
+                    {
+                        "role": "system",
+                        "content": [{"text": ""}]
+                    },
+                    {
+                        "role": "user",
+                        "content": [{"audio": "https://example.com/audio.wav"}]
+                    }
+                ]
+            **kwargs: Additional ASR-specific parameters.
+
+        Returns:
+            str: The transcribed text from the audio.
+        """
+        # Prepare ASR parameters
+        asr_params = {
+            "api_key": self.config.api_key or os.getenv("DASHSCOPE_API_KEY"),
+            "model": self.config.model,
+            "messages": messages,
+            "result_format": self.config.result_format,
+        }
+
+        # Add ASR options
+        asr_options = kwargs.get("asr_options", self.config.asr_options)
+        if asr_options:
+            asr_params["asr_options"] = asr_options
+
+        # Add any other kwargs
+        for key, value in kwargs.items():
+            if key not in ["asr_options"]:
+                asr_params[key] = value
+
+        try:
+            response = dashscope.MultiModalConversation.call(**asr_params)
+            return self._parse_response(response)
+        except Exception as e:
+            logging.error(f"Qwen ASR API call failed: {e}")
+            raise
+
+    def transcribe(
+            self,
+            audio_url: str,
+            system_text: Optional[str] = "",
+            asr_options: Optional[dict] = None,
+    ) -> str:
+        """
+        Convenience method to transcribe audio from URL file path.
+
+        Args:
+            audio_url: URL file path to the audio file.
+            system_text: Optional system message text for customization context.
+            asr_options: Optional ASR-specific options (e.g., {"language": "zh", "enable_itn": True}).
+
+        Returns:
+            str: The transcribed text from the audio.
+        """
+        messages = [
+            {
+                "role": "system",
+                "content": [{"text": system_text}]
+            },
+            {
+                "role": "user",
+                "content": [{"audio": audio_url}]
+            }
+        ]
+
+        return self.generate_response(messages, asr_options=asr_options or self.config.asr_options)
+

powermem/integrations/llm/vllm.py

@@ -0,0 +1,106 @@
+import json
+import os
+from typing import Dict, List, Optional, Union
+
+from openai import OpenAI
+from powermem.integrations.llm import LLMBase
+from powermem.integrations.llm.config.base import BaseLLMConfig
+from powermem.integrations.llm.config.vllm import VllmConfig
+from powermem.utils.utils import extract_json
+
+
+class VllmLLM(LLMBase):
+    def __init__(self, config: Optional[Union[BaseLLMConfig, VllmConfig, Dict]] = None):
+        # Convert to VllmConfig if needed
+        if config is None:
+            config = VllmConfig()
+        elif isinstance(config, dict):
+            config = VllmConfig(**config)
+        elif isinstance(config, BaseLLMConfig) and not isinstance(config, VllmConfig):
+            # Convert BaseLLMConfig to VllmConfig
+            config = VllmConfig(
+                model=config.model,
+                temperature=config.temperature,
+                api_key=config.api_key,
+                max_tokens=config.max_tokens,
+                top_p=config.top_p,
+                top_k=config.top_k,
+                enable_vision=config.enable_vision,
+                vision_details=config.vision_details,
+                http_client_proxies=config.http_client,
+            )
+
+        super().__init__(config)
+
+        if not self.config.model:
+            self.config.model = "Qwen/Qwen2.5-32B-Instruct"
+
+        self.config.api_key = self.config.api_key or os.getenv("VLLM_API_KEY") or "vllm-api-key"
+        base_url = self.config.vllm_base_url or os.getenv("VLLM_BASE_URL")
+        self.client = OpenAI(api_key=self.config.api_key, base_url=base_url)
+
+    def _parse_response(self, response, tools):
+        """
+        Process the response based on whether tools are used or not.
+
+        Args:
+            response: The raw response from API.
+            tools: The list of tools provided in the request.
+
+        Returns:
+            str or dict: The processed response.
+        """
+        if tools:
+            processed_response = {
+                "content": response.choices[0].message.content,
+                "tool_calls": [],
+            }
+
+            if response.choices[0].message.tool_calls:
+                for tool_call in response.choices[0].message.tool_calls:
+                    processed_response["tool_calls"].append(
+                        {
+                            "name": tool_call.function.name,
+                            "arguments": json.loads(extract_json(tool_call.function.arguments)),
+                        }
+                    )
+
+            return processed_response
+        else:
+            return response.choices[0].message.content
+
+    def generate_response(
+            self,
+            messages: List[Dict[str, str]],
+            response_format=None,
+            tools: Optional[List[Dict]] = None,
+            tool_choice: str = "auto",
+            **kwargs,
+    ):
+        """
+        Generate a response based on the given messages using vLLM.
+
+        Args:
+            messages (list): List of message dicts containing 'role' and 'content'.
+            response_format (str or object, optional): Format of the response. Defaults to "text".
+            tools (list, optional): List of tools that the model can call. Defaults to None.
+            tool_choice (str, optional): Tool choice method. Defaults to "auto".
+            **kwargs: Additional vLLM-specific parameters.
+
+        Returns:
+            str: The generated response.
+        """
+        params = self._get_supported_params(messages=messages, **kwargs)
+        params.update(
+            {
+                "model": self.config.model,
+                "messages": messages,
+            }
+        )
+
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.chat.completions.create(**params)
+        return self._parse_response(response, tools)

powermem/integrations/rerank/__init__.py

@@ -0,0 +1,20 @@
+"""
+Rerank integration module
+
+This module provides integration with various rerank services.
+"""
+
+from .base import RerankBase
+from .factory import RerankFactory
+from .qwen import QwenRerank
+from .config.base import BaseRerankConfig
+from .configs import RerankConfig
+
+__all__ = [
+    "RerankBase",
+    "RerankFactory", 
+    "QwenRerank",
+    "BaseRerankConfig",
+    "RerankConfig",
+]
+

powermem/integrations/rerank/base.py

@@ -0,0 +1,43 @@
+"""
+Base class for rerank models
+"""
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple
+
+from powermem.integrations.rerank.config.base import BaseRerankConfig
+
+
+class RerankBase(ABC):
+    """Base class for rerank models
+    
+    Args:
+        config (Optional[BaseRerankConfig]): Configuration for the rerank model
+    """
+
+    def __init__(self, config: Optional[BaseRerankConfig] = None):
+        if config is None:
+            self.config = BaseRerankConfig()
+        else:
+            self.config = config
+
+    @abstractmethod
+    def rerank(
+        self, 
+        query: str, 
+        documents: List[str], 
+        top_n: Optional[int] = None
+    ) -> List[Tuple[int, float]]:
+        """
+        Rerank documents based on relevance to the query.
+
+        Args:
+            query (str): The search query
+            documents (List[str]): List of document texts to rerank
+            top_n (Optional[int]): Number of top results to return. If None, uses config.top_n
+
+        Returns:
+            List[Tuple[int, float]]: List of (document_index, relevance_score) tuples,
+                                     sorted by relevance score in descending order
+        """
+        pass
+

powermem/integrations/rerank/config/__init__.py

@@ -0,0 +1,7 @@
+"""
+Rerank configuration module
+"""
+from .base import BaseRerankConfig
+
+__all__ = ["BaseRerankConfig"]
+

powermem/integrations/rerank/config/base.py

@@ -0,0 +1,27 @@
+"""
+Base configuration for rerank models
+"""
+from typing import Optional
+
+
+class BaseRerankConfig:
+    """Base configuration for rerank models
+    
+    Args:
+        model (str): The rerank model to use
+        api_key (Optional[str]): API key for the rerank service
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        api_key: Optional[str] = None,
+        **kwargs,
+    ):
+        self.model = model
+        self.api_key = api_key
+        
+        # Store any additional kwargs
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+

powermem/integrations/rerank/configs.py

@@ -0,0 +1,23 @@
+"""
+Configuration for rerank models
+"""
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class RerankConfig(BaseModel):
+    """Configuration for rerank functionality."""
+    
+    enabled: bool = Field(
+        description="Whether to enable reranker",
+        default=False,
+    )
+    provider: str = Field(
+        description="Reranker provider (e.g., 'qwen', 'cohere')",
+        default="qwen",
+    )
+    config: Optional[Dict[str, Any]] = Field(
+        description="Configuration for the specific reranker provider",
+        default=None
+    )
+

powermem/integrations/rerank/factory.py

@@ -0,0 +1,68 @@
+"""
+Rerank factory for creating rerank instances
+
+This module provides a factory for creating different rerank instances.
+"""
+
+import importlib
+from typing import Optional
+
+from powermem.integrations.rerank.config.base import BaseRerankConfig
+
+
+def load_class(class_type):
+    """Dynamically load a class from a string path"""
+    module_path, class_name = class_type.rsplit(".", 1)
+    module = importlib.import_module(module_path)
+    return getattr(module, class_name)
+
+
+class RerankFactory:
+    """Factory class for creating rerank model instances
+    """
+    
+    provider_to_class = {
+        "qwen": "powermem.integrations.rerank.qwen.QwenRerank",
+    }
+
+    @classmethod
+    def create(cls, provider_name: str = "qwen", config: Optional[dict] = None):
+        """
+        Create a rerank instance based on provider name.
+
+        Args:
+            provider_name (str): Name of the rerank provider. Defaults to "qwen"
+            config (Optional[dict]): Configuration dictionary for the rerank model
+
+        Returns:
+            RerankBase: An instance of the requested rerank provider
+
+        Raises:
+            ValueError: If the provider is not supported
+        """
+        class_type = cls.provider_to_class.get(provider_name)
+        if class_type:
+            reranker_class = load_class(class_type)
+            # Create config if provided
+            if config:
+                base_config = BaseRerankConfig(**config)
+                return reranker_class(base_config)
+            else:
+                return reranker_class()
+        else:
+            supported = ", ".join(cls.provider_to_class.keys())
+            raise ValueError(
+                f"Unsupported rerank provider: {provider_name}. "
+                f"Supported providers: {supported}"
+            )
+
+    @classmethod
+    def list_providers(cls) -> list:
+        """
+        List all supported rerank providers.
+
+        Returns:
+            list: List of supported provider names
+        """
+        return list(cls.provider_to_class.keys())
+

powermem/integrations/rerank/qwen.py

@@ -0,0 +1,159 @@
+"""
+Qwen Rerank implementation using Alibaba Cloud DashScope API
+"""
+import os
+from typing import List, Optional, Tuple
+
+try:
+    import dashscope
+    from dashscope import TextReRank
+except ImportError:
+    TextReRank = None
+    dashscope = None
+
+from powermem.integrations.rerank.base import RerankBase
+from powermem.integrations.rerank.config.base import BaseRerankConfig
+
+
+class QwenRerank(RerankBase):
+    """Qwen3 Rerank implementation using Alibaba Cloud Bailian API
+    
+    This implementation uses the qwen3-rerank model through DashScope SDK.
+    
+    Args:
+        config (Optional[BaseRerankConfig]): Configuration for the rerank model
+    """
+
+    def __init__(self, config: Optional[BaseRerankConfig] = None):
+        super().__init__(config)
+
+        # Set default model
+        self.config.model = self.config.model or "qwen3-rerank"
+
+        # Check if dashscope is available
+        if TextReRank is None or dashscope is None:
+            raise ImportError(
+                "DashScope SDK is not installed. Please install it with: pip install dashscope"
+            )
+
+        # Set API key
+        api_key = self.config.api_key or os.getenv("DASHSCOPE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "API key is required. Set DASHSCOPE_API_KEY environment variable or pass api_key in config."
+            )
+
+        # Set API key for DashScope SDK
+        dashscope.api_key = api_key
+
+    def rerank(
+        self, 
+        query: str, 
+        documents: List[str], 
+        top_n: Optional[int] = None,
+        instruct: Optional[str] = None
+    ) -> List[Tuple[int, float]]:
+        """
+        Rerank documents based on relevance to the query using Qwen3 Rerank model.
+
+        Args:
+            query (str): The search query
+            documents (List[str]): List of document texts to rerank
+            top_n (Optional[int]): Number of top results to return. If None, uses config.top_n
+            instruct (Optional[str]): Instruct for rerank
+
+        Returns:
+            List[Tuple[int, float]]: List of (document_index, relevance_score) tuples,
+                                     sorted by relevance score in descending order
+                                     
+        Raises:
+            ValueError: If query is empty or documents list is empty
+            Exception: If API call fails
+        """
+        # Validate inputs
+        if not query or not query.strip():
+            raise ValueError("Query cannot be empty")
+        
+        if not documents or len(documents) == 0:
+            raise ValueError("Documents list cannot be empty")
+
+        # Clean query
+        query = query.strip()
+        
+        # Use provided top_n or return all results
+        effective_top_n = top_n if top_n is not None else len(documents)
+        
+        try:
+            # Call the Rerank API
+            if instruct is not None:
+                response = TextReRank.call(
+                    model=self.config.model,
+                    query=query,
+                    documents=documents,
+                    top_n=effective_top_n,
+                    return_documents=False,
+                    instruct=instruct
+                )
+            else:
+                response = TextReRank.call(
+                    model=self.config.model,
+                    query=query,
+                    documents=documents,
+                    top_n=effective_top_n,
+                    return_documents=False,
+                )
+
+            # Check response status
+            if response.status_code != 200:
+                raise Exception(
+                    f"Rerank API request failed with status {response.status_code}: {response.message}"
+                )
+
+            # Parse results
+            results = []
+            if hasattr(response, 'output') and isinstance(response.output, dict):
+                rerank_results = response.output.get('results', [])
+                for result in rerank_results:
+                    index = result.get('index')
+                    score = result.get('relevance_score', 0.0)
+                    if index is not None:
+                        results.append((index, float(score)))
+            else:
+                raise Exception("Unexpected response format from Rerank API")
+
+            return results
+
+        except Exception as e:
+            raise Exception(f"Failed to rerank documents: {e}")
+
+    def rerank_with_texts(
+        self, 
+        query: str, 
+        documents: List[str], 
+        top_n: Optional[int] = None,
+        instruct: Optional[str] = None
+    ) -> List[Tuple[str, float]]:
+        """
+        Rerank documents and return texts with scores instead of indices.
+
+        Args:
+            query (str): The search query
+            documents (List[str]): List of document texts to rerank
+            top_n (Optional[int]): Number of top results to return
+            instruct (Optional[str]): Instruct for rerank
+
+        Returns:
+            List[Tuple[str, float]]: List of (document_text, relevance_score) tuples,
+                                     sorted by relevance score in descending order
+        """
+        # Get reranked indices and scores
+        reranked_results = self.rerank(query, documents, top_n,instruct)
+        
+        # Map indices back to document texts
+        results_with_texts = [
+            (documents[idx], score) 
+            for idx, score in reranked_results
+        ]
+        
+        return results_with_texts
+

powermem/intelligence/__init__.py

@@ -0,0 +1,17 @@
+"""
+Intelligence layer for memory processing
+
+This module provides intelligent memory processing capabilities.
+"""
+
+from .manager import IntelligenceManager
+from .intelligent_memory_manager import IntelligentMemoryManager
+from .importance_evaluator import ImportanceEvaluator
+from .ebbinghaus_algorithm import EbbinghausAlgorithm
+
+__all__ = [
+    "IntelligenceManager",
+    "IntelligentMemoryManager",
+    "ImportanceEvaluator",
+    "EbbinghausAlgorithm",
+]