mem-llm 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

mem_llm/__init__.py

@@ -5,7 +5,13 @@ AI library that remembers user interactions
 
 from .mem_agent import MemAgent
 from .memory_manager import MemoryManager
-from .llm_client import OllamaClient
+from .llm_client import OllamaClient  # Backward compatibility
+from .base_llm_client import BaseLLMClient
+from .llm_client_factory import LLMClientFactory
+
+# New multi-backend support (v1.3.0+)
+from .clients import OllamaClient as OllamaClientNew
+from .clients import LMStudioClient, GeminiClient
 
 # Tools (optional)
 try:
@@ -43,9 +49,26 @@ try:
 except ImportError:
     __all_enhanced__ = []
 
-__version__ = "1.1.0"
+# Conversation Summarization (v1.2.0+)
+try:
+    from .conversation_summarizer import ConversationSummarizer, AutoSummarizer
+    __all_summarizer__ = ["ConversationSummarizer", "AutoSummarizer"]
+except ImportError:
+    __all_summarizer__ = []
+
+# Data Export/Import (v1.2.0+)
+try:
+    from .data_export_import import DataExporter, DataImporter
+    __all_export_import__ = ["DataExporter", "DataImporter"]
+except ImportError:
+    __all_export_import__ = []
+
+__version__ = "1.3.0"
 __author__ = "C. Emre Karataş"
 
+# Multi-backend LLM support (v1.3.0+)
+__all_llm_backends__ = ["BaseLLMClient", "LLMClientFactory", "OllamaClientNew", "LMStudioClient", "GeminiClient"]
+
 # CLI
 try:
     from .cli import cli
@@ -57,4 +80,4 @@ __all__ = [
     "MemAgent",
     "MemoryManager", 
     "OllamaClient",
-] + __all_tools__ + __all_pro__ + __all_cli__ + __all_security__ + __all_enhanced__
+] + __all_llm_backends__ + __all_tools__ + __all_pro__ + __all_cli__ + __all_security__ + __all_enhanced__ + __all_summarizer__ + __all_export_import__

mem_llm/base_llm_client.py

@@ -0,0 +1,175 @@
+"""
+Base LLM Client Interface
+==========================
+
+Abstract base class for all LLM client implementations.
+Ensures consistent interface across different backends (Ollama, LM Studio, Gemini, etc.)
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Any
+import logging
+
+
+class BaseLLMClient(ABC):
+    """
+    Abstract base class for LLM clients
+    
+    All LLM backends must implement these methods to ensure
+    compatibility with MemAgent and other components.
+    """
+    
+    def __init__(self, model: str = None, **kwargs):
+        """
+        Initialize LLM client
+        
+        Args:
+            model: Model name/identifier
+            **kwargs: Backend-specific configuration
+        """
+        self.model = model
+        self.logger = logging.getLogger(self.__class__.__name__)
+    
+    @abstractmethod
+    def chat(self, messages: List[Dict[str, str]], 
+             temperature: float = 0.7, 
+             max_tokens: int = 2000,
+             **kwargs) -> str:
+        """
+        Send chat request and return response
+        
+        Args:
+            messages: List of messages in format:
+                     [{"role": "system/user/assistant", "content": "..."}]
+            temperature: Sampling temperature (0.0-1.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional backend-specific parameters
+            
+        Returns:
+            Model response text
+            
+        Raises:
+            ConnectionError: If cannot connect to service
+            ValueError: If invalid parameters
+        """
+        pass
+    
+    @abstractmethod
+    def check_connection(self) -> bool:
+        """
+        Check if LLM service is available and responding
+        
+        Returns:
+            True if service is available, False otherwise
+        """
+        pass
+    
+    def generate(self, prompt: str, 
+                 system_prompt: Optional[str] = None,
+                 temperature: float = 0.7, 
+                 max_tokens: int = 500,
+                 **kwargs) -> str:
+        """
+        Generate text from a simple prompt (convenience method)
+        
+        Args:
+            prompt: User prompt
+            system_prompt: Optional system prompt
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens
+            **kwargs: Additional parameters
+            
+        Returns:
+            Generated text
+        """
+        # Convert to chat format
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        return self.chat(messages, temperature, max_tokens, **kwargs)
+    
+    def list_models(self) -> List[str]:
+        """
+        List available models (optional, not all backends support this)
+        
+        Returns:
+            List of model names
+        """
+        return [self.model] if self.model else []
+    
+    def _format_messages_to_text(self, messages: List[Dict]) -> str:
+        """
+        Helper: Convert message list to text format
+        
+        Useful for backends that don't support chat format natively.
+        
+        Args:
+            messages: Message list
+            
+        Returns:
+            Formatted text prompt
+        """
+        result = []
+        for msg in messages:
+            role = msg.get('role', 'user').upper()
+            content = msg.get('content', '').strip()
+            if content:
+                result.append(f"{role}: {content}")
+        return "\n\n".join(result)
+    
+    def _validate_messages(self, messages: List[Dict]) -> bool:
+        """
+        Validate message format
+        
+        Args:
+            messages: Messages to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValueError: If invalid format
+        """
+        if not isinstance(messages, list):
+            raise ValueError("Messages must be a list")
+        
+        if not messages:
+            raise ValueError("Messages list cannot be empty")
+        
+        for i, msg in enumerate(messages):
+            if not isinstance(msg, dict):
+                raise ValueError(f"Message {i} must be a dictionary")
+            
+            if 'role' not in msg:
+                raise ValueError(f"Message {i} missing 'role' field")
+            
+            if 'content' not in msg:
+                raise ValueError(f"Message {i} missing 'content' field")
+            
+            if msg['role'] not in ['system', 'user', 'assistant']:
+                raise ValueError(f"Message {i} has invalid role: {msg['role']}")
+        
+        return True
+    
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get client information
+        
+        Returns:
+            Dictionary with client metadata
+        """
+        return {
+            'backend': self.__class__.__name__,
+            'model': self.model,
+            'available': self.check_connection()
+        }
+    
+    def __repr__(self) -> str:
+        """String representation"""
+        return f"{self.__class__.__name__}(model='{self.model}')"
+

mem_llm/clients/__init__.py

@@ -0,0 +1,25 @@
+"""
+LLM Clients Package
+===================
+
+Multiple LLM backend support for Mem-LLM.
+
+Available Backends:
+- OllamaClient: Local Ollama service
+- LMStudioClient: LM Studio (OpenAI-compatible)
+- GeminiClient: Google Gemini API
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+from .ollama_client import OllamaClient
+from .lmstudio_client import LMStudioClient
+from .gemini_client import GeminiClient
+
+__all__ = [
+    'OllamaClient',
+    'LMStudioClient',
+    'GeminiClient',
+]
+

mem_llm/clients/gemini_client.py

@@ -0,0 +1,381 @@
+"""
+Google Gemini LLM Client
+=========================
+
+Client for Google Gemini API (cloud service).
+
+Features:
+- Gemini 1.5 Pro, Flash, etc.
+- Fast and powerful
+- Large context window (up to 2M tokens)
+- Multimodal support (text, images, video)
+
+Setup:
+1. Get API key from: https://makersuite.google.com/app/apikey
+2. Set environment variable: export GEMINI_API_KEY="your-key"
+   Or pass api_key parameter to constructor
+
+Models:
+- gemini-1.5-pro: Most capable model
+- gemini-1.5-flash: Fastest model
+- gemini-pro: Standard model
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+import requests
+import time
+import os
+from typing import List, Dict, Optional
+import sys
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from base_llm_client import BaseLLMClient
+
+
+class GeminiClient(BaseLLMClient):
+    """
+    Google Gemini API client implementation
+    
+    Supports Gemini models via Google AI Studio API.
+    Requires API key from Google AI Studio.
+    
+    Usage:
+        # Option 1: Using environment variable
+        export GEMINI_API_KEY="your-api-key"
+        client = GeminiClient(model="gemini-2.5-flash")
+        
+        # Option 2: Direct API key
+        client = GeminiClient(
+            model="gemini-2.5-flash",
+            api_key="your-api-key"
+        )
+        
+        response = client.chat([{"role": "user", "content": "Hello!"}])
+    """
+    
+    # Available Gemini models
+    MODELS = {
+        'gemini-2.5-flash': 'Latest Gemini 2.5 Flash model (recommended)'
+    }
+    
+    def __init__(self, 
+                 model: str = "gemini-2.5-flash",
+                 api_key: Optional[str] = None,
+                 **kwargs):
+        """
+        Initialize Gemini client
+        
+        Args:
+            model: Gemini model name (default: gemini-2.5-flash)
+            api_key: Google AI API key (if None, reads from GEMINI_API_KEY env var)
+            **kwargs: Additional configuration
+        
+        Raises:
+            ValueError: If API key is not provided
+        """
+        super().__init__(model=model, **kwargs)
+        
+        # Get API key from parameter or environment
+        self.api_key = api_key or os.getenv('GEMINI_API_KEY')
+        
+        if not self.api_key:
+            raise ValueError(
+                "Gemini API key is required. "
+                "Set GEMINI_API_KEY environment variable or pass api_key parameter. "
+                "Get key from: https://makersuite.google.com/app/apikey"
+            )
+        
+        # API endpoints
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta"
+        self.chat_url = f"{self.base_url}/models/{self.model}:generateContent"
+        
+        # Add API key to URL
+        self.chat_url += f"?key={self.api_key}"
+        
+        self.logger.debug(f"Initialized Gemini client with model: {model}")
+    
+    def check_connection(self) -> bool:
+        """
+        Check if Gemini API is accessible
+        
+        Returns:
+            True if API is available
+        """
+        try:
+            # Send a minimal test request
+            test_payload = {
+                "contents": [{
+                    "parts": [{"text": "Hi"}]
+                }],
+                "generationConfig": {
+                    "maxOutputTokens": 10
+                }
+            }
+            
+            response = requests.post(
+                self.chat_url,
+                json=test_payload,
+                timeout=10
+            )
+            
+            # 200 = success, 400 might be rate limit or quota (but API is working)
+            return response.status_code in [200, 400, 429]
+            
+        except Exception as e:
+            self.logger.debug(f"Gemini connection check failed: {e}")
+            return False
+    
+    def list_models(self) -> List[str]:
+        """
+        List available Gemini models
+        
+        Returns:
+            List of model identifiers
+        """
+        return list(self.MODELS.keys())
+    
+    def chat(self, 
+             messages: List[Dict[str, str]], 
+             temperature: float = 0.7, 
+             max_tokens: int = 2000,
+             **kwargs) -> str:
+        """
+        Send chat request to Gemini API
+        
+        Args:
+            messages: Message history in OpenAI format
+            temperature: Sampling temperature (0.0-2.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional Gemini-specific parameters
+                     - top_p: Nucleus sampling (0.0-1.0)
+                     - top_k: Top-K sampling
+                     - safety_settings: Safety filter settings
+            
+        Returns:
+            Model response text
+            
+        Raises:
+            ConnectionError: If cannot connect to Gemini API
+            ValueError: If invalid parameters or API key
+        """
+        # Validate messages
+        self._validate_messages(messages)
+        
+        # Convert OpenAI format to Gemini format
+        gemini_messages = self._convert_to_gemini_format(messages)
+        
+        # Build Gemini payload
+        payload = {
+            "contents": gemini_messages,
+            "generationConfig": {
+                "temperature": temperature,
+                "maxOutputTokens": max_tokens,
+                "topP": kwargs.get("top_p", 0.95),
+                "topK": kwargs.get("top_k", 40)
+            }
+        }
+        
+        # Add safety settings if provided
+        if "safety_settings" in kwargs:
+            payload["safetySettings"] = kwargs["safety_settings"]
+        
+        # Send request with retry logic
+        max_retries = kwargs.get("max_retries", 3)
+        for attempt in range(max_retries):
+            try:
+                response = requests.post(
+                    self.chat_url,
+                    json=payload,
+                    timeout=kwargs.get("timeout", 60)
+                )
+                
+                if response.status_code == 200:
+                    response_data = response.json()
+                    
+                    # Extract content from Gemini format
+                    candidates = response_data.get('candidates', [])
+                    if not candidates:
+                        self.logger.warning("No candidates in Gemini response")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                        return ""
+                    
+                    # Get the first candidate's content
+                    content = candidates[0].get('content', {})
+                    parts = content.get('parts', [])
+                    
+                    if not parts:
+                        self.logger.warning("No parts in Gemini response")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                        return ""
+                    
+                    # Combine all text parts
+                    text_parts = [part.get('text', '') for part in parts if 'text' in part]
+                    result = ' '.join(text_parts).strip()
+                    
+                    if not result:
+                        self.logger.warning("Empty content in Gemini response")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                    
+                    # Log usage metadata if available
+                    usage_metadata = response_data.get('usageMetadata', {})
+                    if usage_metadata:
+                        self.logger.debug(
+                            f"Gemini usage - "
+                            f"prompt: {usage_metadata.get('promptTokenCount', 0)} tokens, "
+                            f"response: {usage_metadata.get('candidatesTokenCount', 0)} tokens, "
+                            f"total: {usage_metadata.get('totalTokenCount', 0)} tokens"
+                        )
+                    
+                    # Check for safety ratings/blocks
+                    finish_reason = candidates[0].get('finishReason', '')
+                    if finish_reason == 'SAFETY':
+                        self.logger.warning("Response blocked by Gemini safety filters")
+                        safety_ratings = candidates[0].get('safetyRatings', [])
+                        self.logger.debug(f"Safety ratings: {safety_ratings}")
+                    
+                    return result
+                
+                elif response.status_code == 400:
+                    # Bad request - likely API key or parameter issue
+                    error_data = response.json()
+                    error_msg = error_data.get('error', {}).get('message', response.text)
+                    self.logger.error(f"Gemini API error (400): {error_msg}")
+                    
+                    if "API_KEY" in error_msg.upper():
+                        raise ValueError(f"Invalid Gemini API key. Get key from: https://makersuite.google.com/app/apikey")
+                    
+                    raise ValueError(f"Gemini API error: {error_msg}")
+                
+                elif response.status_code == 429:
+                    # Rate limit - retry with exponential backoff
+                    self.logger.warning(f"Gemini rate limit hit (attempt {attempt + 1}/{max_retries})")
+                    if attempt < max_retries - 1:
+                        wait_time = min(30, 2.0 * (2 ** attempt))
+                        time.sleep(wait_time)
+                        continue
+                    raise ConnectionError("Gemini API rate limit exceeded. Please try again later.")
+                
+                elif response.status_code == 403:
+                    # Permission denied - quota or billing issue
+                    error_data = response.json()
+                    error_msg = error_data.get('error', {}).get('message', response.text)
+                    raise ValueError(f"Gemini API permission denied: {error_msg}")
+                
+                else:
+                    # Other errors
+                    error_msg = f"Gemini API error: {response.status_code}"
+                    try:
+                        error_data = response.json()
+                        error_detail = error_data.get('error', {}).get('message', response.text)
+                        error_msg += f" - {error_detail}"
+                    except:
+                        error_msg += f" - {response.text[:200]}"
+                    
+                    self.logger.error(error_msg)
+                    
+                    if attempt < max_retries - 1:
+                        time.sleep(1.0 * (2 ** attempt))
+                        continue
+                    raise ConnectionError(error_msg)
+                    
+            except requests.exceptions.Timeout:
+                self.logger.warning(f"Gemini request timeout (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(2.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError("Gemini API request timeout. Please try again.")
+                
+            except requests.exceptions.ConnectionError as e:
+                self.logger.warning(f"Cannot connect to Gemini API (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError("Cannot connect to Gemini API. Check your internet connection.") from e
+                
+            except (ValueError, ConnectionError):
+                # Re-raise our custom exceptions
+                raise
+                
+            except Exception as e:
+                self.logger.error(f"Unexpected error: {e}")
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                raise
+        
+        raise ConnectionError("Failed to get response after maximum retries")
+    
+    def _convert_to_gemini_format(self, messages: List[Dict[str, str]]) -> List[Dict]:
+        """
+        Convert OpenAI message format to Gemini format
+        
+        OpenAI format: [{"role": "user/assistant/system", "content": "..."}]
+        Gemini format: [{"role": "user/model", "parts": [{"text": "..."}]}]
+        
+        Args:
+            messages: Messages in OpenAI format
+            
+        Returns:
+            Messages in Gemini format
+        """
+        gemini_messages = []
+        system_prompt = None
+        
+        for msg in messages:
+            role = msg.get('role', 'user')
+            content = msg.get('content', '').strip()
+            
+            if not content:
+                continue
+            
+            # Handle system messages (Gemini doesn't have system role)
+            if role == 'system':
+                # Prepend system prompt to first user message
+                system_prompt = content
+                continue
+            
+            # Convert role: assistant -> model
+            gemini_role = 'model' if role == 'assistant' else 'user'
+            
+            # Build Gemini message
+            gemini_msg = {
+                "role": gemini_role,
+                "parts": [{"text": content}]
+            }
+            
+            # If this is the first user message and we have a system prompt,
+            # prepend system prompt to the content
+            if gemini_role == 'user' and system_prompt and not gemini_messages:
+                gemini_msg["parts"][0]["text"] = f"{system_prompt}\n\n{content}"
+                system_prompt = None  # Only use once
+            
+            gemini_messages.append(gemini_msg)
+        
+        return gemini_messages
+    
+    def get_info(self) -> Dict:
+        """
+        Get comprehensive client information
+        
+        Returns:
+            Dictionary with client metadata
+        """
+        base_info = super().get_info()
+        
+        # Add Gemini-specific info
+        base_info['api_status'] = 'configured' if self.api_key else 'missing_key'
+        base_info['model_description'] = self.MODELS.get(self.model, 'Unknown model')
+        base_info['available_models'] = self.list_models()
+        
+        return base_info
+