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

mem_llm/clients/lmstudio_client.py

@@ -0,0 +1,280 @@
+"""
+LM Studio LLM Client
+====================
+
+Client for LM Studio local inference server.
+LM Studio uses OpenAI-compatible API format.
+
+Features:
+- OpenAI-compatible API
+- Fast local inference
+- Easy model switching
+- GPU acceleration support
+
+Installation:
+1. Download LM Studio from https://lmstudio.ai
+2. Load a model
+3. Start local server (default: http://localhost:1234)
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+import requests
+import time
+from typing import List, Dict, Optional
+import sys
+import os
+
+# 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 LMStudioClient(BaseLLMClient):
+    """
+    LM Studio client implementation
+    
+    LM Studio provides an OpenAI-compatible API for local models.
+    This client works with any model loaded in LM Studio.
+    
+    Usage:
+        client = LMStudioClient(
+            model="local-model",  # or specific model name
+            base_url="http://localhost:1234"
+        )
+        response = client.chat([{"role": "user", "content": "Hello!"}])
+    """
+    
+    def __init__(self, 
+                 model: str = "local-model",
+                 base_url: str = "http://localhost:1234",
+                 **kwargs):
+        """
+        Initialize LM Studio client
+        
+        Args:
+            model: Model identifier (use "local-model" for default loaded model)
+            base_url: LM Studio server URL (default: http://localhost:1234)
+            **kwargs: Additional configuration
+        """
+        super().__init__(model=model, **kwargs)
+        self.base_url = base_url.rstrip('/')
+        self.chat_url = f"{self.base_url}/v1/chat/completions"
+        self.models_url = f"{self.base_url}/v1/models"
+        
+        self.logger.debug(f"Initialized LM Studio client: {base_url}, model: {model}")
+    
+    def check_connection(self) -> bool:
+        """
+        Check if LM Studio server is running
+        
+        Returns:
+            True if server is available
+        """
+        try:
+            response = requests.get(self.models_url, timeout=5)
+            return response.status_code == 200
+        except Exception as e:
+            self.logger.debug(f"LM Studio connection check failed: {e}")
+            return False
+    
+    def list_models(self) -> List[str]:
+        """
+        List available models in LM Studio
+        
+        Returns:
+            List of model identifiers
+        """
+        try:
+            response = requests.get(self.models_url, timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                models = data.get('data', [])
+                return [model.get('id', '') for model in models if model.get('id')]
+            return []
+        except Exception as e:
+            self.logger.error(f"Failed to list models: {e}")
+            return []
+    
+    def chat(self, 
+             messages: List[Dict[str, str]], 
+             temperature: float = 0.7, 
+             max_tokens: int = 2000,
+             **kwargs) -> str:
+        """
+        Send chat request to LM Studio
+        
+        Uses OpenAI-compatible chat completions endpoint.
+        
+        Args:
+            messages: Message history in OpenAI format
+            temperature: Sampling temperature (0.0-2.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional OpenAI-compatible parameters
+                     - top_p: Nucleus sampling (0.0-1.0)
+                     - frequency_penalty: (-2.0 to 2.0)
+                     - presence_penalty: (-2.0 to 2.0)
+                     - stream: Enable streaming (bool)
+            
+        Returns:
+            Model response text
+            
+        Raises:
+            ConnectionError: If cannot connect to LM Studio
+            ValueError: If invalid parameters
+        """
+        # Validate messages
+        self._validate_messages(messages)
+        
+        # Build OpenAI-compatible payload
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": kwargs.get("stream", False)
+        }
+        
+        # Add optional parameters
+        if "top_p" in kwargs:
+            payload["top_p"] = kwargs["top_p"]
+        if "frequency_penalty" in kwargs:
+            payload["frequency_penalty"] = kwargs["frequency_penalty"]
+        if "presence_penalty" in kwargs:
+            payload["presence_penalty"] = kwargs["presence_penalty"]
+        if "stop" in kwargs:
+            payload["stop"] = kwargs["stop"]
+        
+        # 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", 120)
+                )
+                
+                if response.status_code == 200:
+                    response_data = response.json()
+                    
+                    # Extract content from OpenAI format
+                    choices = response_data.get('choices', [])
+                    if not choices:
+                        self.logger.warning("No choices in LM Studio response")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                        return ""
+                    
+                    # Get the message content
+                    message = choices[0].get('message', {})
+                    content = message.get('content', '').strip()
+                    
+                    if not content:
+                        self.logger.warning("Empty content in LM Studio response")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                    
+                    # Log usage statistics if available
+                    usage = response_data.get('usage', {})
+                    if usage:
+                        self.logger.debug(
+                            f"LM Studio usage - "
+                            f"prompt: {usage.get('prompt_tokens', 0)} tokens, "
+                            f"completion: {usage.get('completion_tokens', 0)} tokens, "
+                            f"total: {usage.get('total_tokens', 0)} tokens"
+                        )
+                    
+                    return content
+                    
+                else:
+                    error_msg = f"LM Studio API error: {response.status_code}"
+                    try:
+                        error_data = response.json()
+                        error_detail = error_data.get('error', {})
+                        if isinstance(error_detail, dict):
+                            error_msg += f" - {error_detail.get('message', response.text)}"
+                        else:
+                            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"LM Studio request timeout (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(2.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError("LM Studio request timeout. Check if server is running.")
+                
+            except requests.exceptions.ConnectionError as e:
+                self.logger.warning(f"Cannot connect to LM Studio (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError(
+                    f"Cannot connect to LM Studio at {self.base_url}. "
+                    "Make sure LM Studio is running and server is started."
+                ) from e
+                
+            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 get_model_info(self) -> Dict:
+        """
+        Get information about currently loaded model
+        
+        Returns:
+            Dictionary with model information
+        """
+        try:
+            response = requests.get(self.models_url, timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                models = data.get('data', [])
+                
+                # Find our model or return first one
+                for model in models:
+                    if model.get('id') == self.model:
+                        return model
+                
+                # Return first model if ours not found
+                return models[0] if models else {}
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to get model info: {e}")
+            return {}
+    
+    def get_info(self) -> Dict:
+        """
+        Get comprehensive client information
+        
+        Returns:
+            Dictionary with client and model metadata
+        """
+        base_info = super().get_info()
+        
+        # Add LM Studio specific info
+        if self.check_connection():
+            model_info = self.get_model_info()
+            base_info['model_details'] = model_info
+            base_info['available_models'] = self.list_models()
+        
+        return base_info
+

mem_llm/clients/ollama_client.py

@@ -0,0 +1,268 @@
+"""
+Ollama LLM Client
+=================
+
+Client for local Ollama service.
+Supports all Ollama models (Llama3, Granite, Qwen3, DeepSeek, etc.)
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+import requests
+import time
+from typing import List, Dict, Optional
+import sys
+import os
+
+# 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 OllamaClient(BaseLLMClient):
+    """
+    Ollama LLM client implementation
+    
+    Supports:
+    - All Ollama models
+    - Chat and generate modes
+    - Thinking mode detection (Qwen3, DeepSeek)
+    - Automatic retry with exponential backoff
+    """
+    
+    def __init__(self, 
+                 model: str = "granite4:tiny-h",
+                 base_url: str = "http://localhost:11434",
+                 **kwargs):
+        """
+        Initialize Ollama client
+        
+        Args:
+            model: Model name (e.g., "llama3", "granite4:tiny-h")
+            base_url: Ollama API URL
+            **kwargs: Additional configuration
+        """
+        super().__init__(model=model, **kwargs)
+        self.base_url = base_url
+        self.api_url = f"{base_url}/api/generate"
+        self.chat_url = f"{base_url}/api/chat"
+        self.tags_url = f"{base_url}/api/tags"
+        
+        self.logger.debug(f"Initialized Ollama client: {base_url}, model: {model}")
+    
+    def check_connection(self) -> bool:
+        """
+        Check if Ollama service is running
+        
+        Returns:
+            True if service is available
+        """
+        try:
+            response = requests.get(self.tags_url, timeout=5)
+            return response.status_code == 200
+        except Exception as e:
+            self.logger.debug(f"Ollama connection check failed: {e}")
+            return False
+    
+    def list_models(self) -> List[str]:
+        """
+        List available Ollama models
+        
+        Returns:
+            List of model names
+        """
+        try:
+            response = requests.get(self.tags_url, timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                return [model['name'] for model in data.get('models', [])]
+            return []
+        except Exception as e:
+            self.logger.error(f"Failed to list models: {e}")
+            return []
+    
+    def chat(self, 
+             messages: List[Dict[str, str]], 
+             temperature: float = 0.7, 
+             max_tokens: int = 2000,
+             **kwargs) -> str:
+        """
+        Send chat request to Ollama
+        
+        Args:
+            messages: Message history
+            temperature: Sampling temperature (0.0-1.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional Ollama-specific options
+            
+        Returns:
+            Model response text
+            
+        Raises:
+            ConnectionError: If cannot connect to Ollama
+            ValueError: If invalid parameters
+        """
+        # Validate messages
+        self._validate_messages(messages)
+        
+        # Build payload
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens,
+                "num_ctx": kwargs.get("num_ctx", 4096),
+                "top_k": kwargs.get("top_k", 40),
+                "top_p": kwargs.get("top_p", 0.9),
+                "num_thread": kwargs.get("num_thread", 8)
+            }
+        }
+        
+        # Disable thinking mode for thinking-enabled models
+        # (Qwen3, DeepSeek) to get direct answers
+        if any(name in self.model.lower() for name in ['qwen', 'deepseek', 'qwq']):
+            payload["options"]["enable_thinking"] = False
+        
+        # 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", 120)
+                )
+                
+                if response.status_code == 200:
+                    response_data = response.json()
+                    message = response_data.get('message', {})
+                    
+                    # Get content - primary response field
+                    result = message.get('content', '').strip()
+                    
+                    # Fallback: Extract from thinking if content is empty
+                    if not result and message.get('thinking'):
+                        result = self._extract_from_thinking(message.get('thinking', ''))
+                    
+                    if not result:
+                        self.logger.warning("Empty response from Ollama")
+                        if attempt < max_retries - 1:
+                            time.sleep(1.0 * (2 ** attempt))
+                            continue
+                    
+                    return result
+                else:
+                    error_msg = f"Ollama API error: {response.status_code} - {response.text}"
+                    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"Ollama request timeout (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(2.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError("Ollama request timeout. Check if service is running.")
+                
+            except requests.exceptions.ConnectionError as e:
+                self.logger.warning(f"Cannot connect to Ollama (attempt {attempt + 1}/{max_retries})")
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                raise ConnectionError(f"Cannot connect to Ollama at {self.base_url}. Make sure service is running.") from e
+                
+            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 _extract_from_thinking(self, thinking: str) -> str:
+        """
+        Extract actual answer from thinking process
+        
+        Some models output reasoning process instead of direct answer.
+        This extracts the final answer from that process.
+        
+        Args:
+            thinking: Thinking process text
+            
+        Returns:
+            Extracted answer
+        """
+        if not thinking:
+            return ""
+        
+        # Try to find answer after common separators
+        for separator in ['\n\nAnswer:', '\n\nFinal answer:', 
+                         '\n\nResponse:', '\n\nSo the answer is:',
+                         '\n\n---\n', '\n\nOkay,', '\n\nTherefore,']:
+            if separator in thinking:
+                parts = thinking.split(separator)
+                if len(parts) > 1:
+                    return parts[-1].strip()
+        
+        # Fallback: Get last meaningful paragraph
+        paragraphs = [p.strip() for p in thinking.split('\n\n') if p.strip()]
+        if paragraphs:
+            last_para = paragraphs[-1]
+            # Avoid meta-commentary
+            if not any(word in last_para.lower() 
+                      for word in ['wait', 'hmm', 'let me', 'thinking', 'okay']):
+                return last_para
+        
+        # If nothing else works, return the whole thinking
+        return thinking
+    
+    def generate_with_memory_context(self, 
+                                    user_message: str, 
+                                    memory_summary: str,
+                                    recent_conversations: List[Dict]) -> str:
+        """
+        Generate response with memory context
+        
+        This is a specialized method for MemAgent integration.
+        
+        Args:
+            user_message: User's message
+            memory_summary: Summary of past interactions
+            recent_conversations: Recent conversation history
+            
+        Returns:
+            Context-aware response
+        """
+        # Build system prompt
+        system_prompt = """You are a helpful customer service assistant.
+You can remember past conversations with users.
+Give short, clear and professional answers.
+Use past interactions intelligently."""
+        
+        # Build message history
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Add memory summary
+        if memory_summary and memory_summary != "No interactions with this user yet.":
+            messages.append({
+                "role": "system",
+                "content": f"User history:\n{memory_summary}"
+            })
+        
+        # Add recent conversations (last 3)
+        for conv in recent_conversations[-3:]:
+            messages.append({"role": "user", "content": conv.get('user_message', '')})
+            messages.append({"role": "assistant", "content": conv.get('bot_response', '')})
+        
+        # Add current message
+        messages.append({"role": "user", "content": user_message})
+        
+        return self.chat(messages, temperature=0.7)
+

mem_llm/config_manager.py

@@ -43,7 +43,7 @@ class ConfigManager:
             "memory": {
                 "backend": "sql",
                 "json_dir": "memories",
-                "db_path": "memories.db",
+                "db_path": "memories/memories.db",
                 "max_conversations_per_user": 1000,
                 "auto_cleanup": True,
                 "cleanup_after_days": 90