mem-llm 1.2.0__tar.gz → 1.3.0__tar.gz

{mem_llm-1.2.0 → mem_llm-1.3.0}/CHANGELOG.md

@@ -5,6 +5,65 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2025-10-31
+
+### 🎉 Major Features
+
+- 🔌 **Multi-Backend LLM Support**: Choose your preferred LLM backend
+  - **Ollama**: Local, privacy-first, 100+ models
+  - **LM Studio**: Fast local inference with easy GUI
+  - **Google Gemini**: Powerful cloud models (gemini-2.5-flash)
+  - Unified API across all backends
+  - Seamless switching between backends
+
+- 🏗️ **Factory Pattern Architecture**: Clean, extensible design
+  - `LLMClientFactory`: Central backend management
+  - `BaseLLMClient`: Abstract interface for all backends
+  - Easy to add new backends in the future
+
+- 🔍 **Auto-Detection**: Automatically find available LLM service
+  - `auto_detect_backend=True` parameter
+  - Checks Ollama → LM Studio → other local services
+  - No manual configuration needed
+
+### 🆕 New Components
+
+- `BaseLLMClient`: Abstract base class for all LLM backends
+- `LLMClientFactory`: Factory pattern for backend creation
+- `OllamaClient` (refactored): Now inherits from BaseLLMClient
+- `LMStudioClient`: OpenAI-compatible local inference
+- `GeminiClient`: Google Gemini API integration
+
+### 📚 New Examples
+
+- `11_lmstudio_example.py`: Using LM Studio backend
+- `12_gemini_example.py`: Using Google Gemini API
+- `13_multi_backend_comparison.py`: Compare backend performance
+- `14_auto_detect_backend.py`: Auto-detection feature
+
+### 📖 New Documentation
+
+- `MULTI_BACKEND_GUIDE.md`: Comprehensive guide for multi-backend setup
+
+### 🔄 Changed
+
+- **MemAgent**: Now supports multiple backends (backward compatible)
+- **Examples**: All simplified for clarity
+- **Package structure**: Better organized with `clients/` subdirectory
+
+### ⚡ Improved
+
+- **Backward Compatibility**: All v1.2.0 code still works
+- **Error Messages**: Backend-specific troubleshooting
+- **Connection Checks**: Improved availability detection
+
+### 🧪 Testing
+
+- 16+ new tests for multi-backend support
+- Factory pattern tests
+- Backend availability checks
+- MemAgent integration tests
+
 ## [1.2.0] - 2025-10-21
 
 ### Added

{mem_llm-1.2.0/mem_llm.egg-info → mem_llm-1.3.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.2
 Name: mem-llm
-Version: 1.2.0
-Summary: Memory-enabled AI assistant with local LLM support - Now with data import/export and multi-database support
+Version: 1.3.0
+Summary: Memory-enabled AI assistant with multi-backend LLM support (Ollama, LM Studio, Gemini) - Local and cloud ready
 Author-email: "C. Emre Karataş" <karatasqemre@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/emredeveloper/Mem-LLM
 Project-URL: Bug Reports, https://github.com/emredeveloper/Mem-LLM/issues
 Project-URL: Source, https://github.com/emredeveloper/Mem-LLM
-Keywords: llm,ai,memory,agent,chatbot,ollama,local
+Keywords: llm,ai,memory,agent,chatbot,ollama,lmstudio,gemini,multi-backend,local
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.31.0
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: click>=8.1.0
+Requires-Dist: google-generativeai>=0.3.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"

{mem_llm-1.2.0 → mem_llm-1.3.0}/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:
@@ -57,9 +63,12 @@ try:
 except ImportError:
     __all_export_import__ = []
 
-__version__ = "1.2.0"
+__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
@@ -71,4 +80,4 @@ __all__ = [
     "MemAgent",
     "MemoryManager", 
     "OllamaClient",
-] + __all_tools__ + __all_pro__ + __all_cli__ + __all_security__ + __all_enhanced__ + __all_summarizer__ + __all_export_import__
+] + __all_llm_backends__ + __all_tools__ + __all_pro__ + __all_cli__ + __all_security__ + __all_enhanced__ + __all_summarizer__ + __all_export_import__

mem_llm-1.3.0/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-1.3.0/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',
+]
+