mem-llm 1.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

mem_llm/dynamic_prompt.py

@@ -0,0 +1,298 @@
+"""
+Dynamic System Prompt Builder
+=============================
+
+Builds optimized system prompts based on active features:
+- Knowledge Base enabled/disabled
+- Tools enabled/disabled
+- Memory type (JSON/SQL)
+- Usage mode (business/personal)
+- Multi-user support
+- Document processing
+
+This prevents irrelevant/context-broken responses by adapting
+the system prompt to actual capabilities.
+"""
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+
+class DynamicPromptBuilder:
+    """Builds context-aware system prompts based on active features"""
+    
+    def __init__(self):
+        self.base_instructions = {
+            "core": """You are a helpful AI assistant that maintains conversation context and provides accurate, relevant responses.
+
+⚠️ OUTPUT FORMAT:
+- If you're a thinking-enabled model (Qwen, DeepSeek, etc.), DO NOT show your internal reasoning
+- Respond DIRECTLY with the final answer only
+- Suppress any chain-of-thought or thinking process
+- Be concise and natural""",
+            
+            "concise": """
+RESPONSE GUIDELINES:
+- Keep responses SHORT and FOCUSED (1-3 sentences for simple questions)
+- Only elaborate when the user asks for details
+- Acknowledge personal information briefly ("Got it!", "Noted!")
+- Be conversational and natural""",
+            
+            "memory": """
+MEMORY AWARENESS:
+- You have access to past conversations with this user
+- Reference previous context when relevant
+- Build upon earlier discussions naturally
+- Remember user preferences and details shared""",
+            
+            "knowledge_base": """
+KNOWLEDGE BASE PRIORITY (⚠️ CRITICAL):
+1. If KNOWLEDGE BASE information is provided below, USE IT FIRST - it's authoritative!
+2. Knowledge base entries are marked with "📚 RELEVANT KNOWLEDGE"
+3. Answer from knowledge base EXACTLY as provided
+4. DO NOT make up information not in the knowledge base
+5. If knowledge base has no info, then use conversation history or say "I don't have specific information about that"
+
+RESPONSE PRIORITY:
+1️⃣ Knowledge Base (if available) ← ALWAYS FIRST!
+2️⃣ Conversation History
+3️⃣ General knowledge (if appropriate)""",
+            
+            "no_knowledge_base": """
+INFORMATION SOURCES:
+- Use conversation history to maintain context
+- Provide helpful general information when appropriate
+- Be honest when you don't have specific information""",
+            
+            "tools": """
+AVAILABLE TOOLS:
+{tool_descriptions}
+
+TOOL USAGE:
+- Use tools when user requests actions (calculator, weather, search, etc.)
+- Explain what you're doing when using a tool
+- Present tool results clearly""",
+            
+            "multi_user": """
+USER CONTEXT:
+- Each user has separate conversation history
+- Maintain appropriate boundaries between user sessions
+- Current user: {current_user}""",
+            
+            "business": """
+BUSINESS CONTEXT:
+- Company: {company_name}
+- Industry: {industry}
+- Founded: {founded_year}
+
+PROFESSIONAL STANDARDS:
+- Maintain professional tone
+- Prioritize customer satisfaction
+- Provide clear, actionable solutions
+- Escalate complex issues appropriately""",
+            
+            "personal": """
+PERSONAL ASSISTANT MODE:
+- User: {user_name}
+- Timezone: {timezone}
+
+ASSISTANCE STYLE:
+- Friendly and helpful
+- Proactive suggestions when appropriate
+- Respect user preferences and privacy""",
+        }
+    
+    def build_prompt(self, 
+                    usage_mode: str = "personal",
+                    has_knowledge_base: bool = False,
+                    has_tools: bool = False,
+                    tool_descriptions: Optional[str] = None,
+                    is_multi_user: bool = False,
+                    current_user: Optional[str] = None,
+                    business_config: Optional[Dict] = None,
+                    personal_config: Optional[Dict] = None,
+                    memory_type: str = "sql",
+                    custom_instructions: Optional[str] = None) -> str:
+        """
+        Build dynamic system prompt based on active features
+        
+        Args:
+            usage_mode: 'business' or 'personal'
+            has_knowledge_base: Whether knowledge base is active
+            has_tools: Whether tools are enabled
+            tool_descriptions: Description of available tools
+            is_multi_user: Whether multi-user mode is active
+            current_user: Current user ID
+            business_config: Business mode configuration
+            personal_config: Personal mode configuration
+            memory_type: 'json' or 'sql'
+            custom_instructions: Additional custom instructions
+            
+        Returns:
+            Complete system prompt
+        """
+        
+        sections = []
+        
+        # 1. Core identity
+        sections.append(self.base_instructions["core"])
+        
+        # 2. Mode-specific context
+        if usage_mode == "business":
+            business_info = business_config or {}
+            business_prompt = self.base_instructions["business"].format(
+                company_name=business_info.get("company_name", "Our Company"),
+                industry=business_info.get("industry", "Technology"),
+                founded_year=business_info.get("founded_year", "2020")
+            )
+            sections.append(business_prompt)
+        else:  # personal
+            personal_info = personal_config or {}
+            personal_prompt = self.base_instructions["personal"].format(
+                user_name=personal_info.get("user_name", "User"),
+                timezone=personal_info.get("timezone", "UTC")
+            )
+            sections.append(personal_prompt)
+        
+        # 3. Memory awareness
+        sections.append(self.base_instructions["memory"])
+        
+        # 4. Knowledge base instructions (CRITICAL - only if enabled!)
+        if has_knowledge_base:
+            sections.append(self.base_instructions["knowledge_base"])
+        else:
+            sections.append(self.base_instructions["no_knowledge_base"])
+        
+        # 5. Tools instructions (only if enabled)
+        if has_tools and tool_descriptions:
+            tools_prompt = self.base_instructions["tools"].format(
+                tool_descriptions=tool_descriptions
+            )
+            sections.append(tools_prompt)
+        
+        # 6. Multi-user context (only if enabled)
+        if is_multi_user and current_user:
+            multi_user_prompt = self.base_instructions["multi_user"].format(
+                current_user=current_user
+            )
+            sections.append(multi_user_prompt)
+        
+        # 7. Response guidelines
+        sections.append(self.base_instructions["concise"])
+        
+        # 8. Custom instructions (if provided)
+        if custom_instructions:
+            sections.append(f"\nADDITIONAL INSTRUCTIONS:\n{custom_instructions}")
+        
+        # 9. Current date
+        current_date = datetime.now().strftime("%Y-%m-%d %H:%M")
+        sections.append(f"\nCurrent Date/Time: {current_date}")
+        
+        # Join all sections
+        full_prompt = "\n\n".join(sections)
+        
+        return full_prompt
+    
+    def get_feature_summary(self, 
+                           has_knowledge_base: bool,
+                           has_tools: bool,
+                           is_multi_user: bool,
+                           memory_type: str) -> str:
+        """
+        Get human-readable summary of active features
+        
+        Returns:
+            Feature summary string
+        """
+        features = []
+        
+        if has_knowledge_base:
+            features.append("✅ Knowledge Base")
+        else:
+            features.append("❌ Knowledge Base")
+        
+        if has_tools:
+            features.append("✅ Tools")
+        else:
+            features.append("❌ Tools")
+        
+        if is_multi_user:
+            features.append("✅ Multi-user")
+        else:
+            features.append("⚪ Single-user")
+        
+        features.append(f"💾 Memory: {memory_type.upper()}")
+        
+        return " | ".join(features)
+
+
+# Global instance
+dynamic_prompt_builder = DynamicPromptBuilder()
+
+
+# Example usage
+if __name__ == "__main__":
+    print("=" * 70)
+    print("DYNAMIC PROMPT BUILDER - EXAMPLES")
+    print("=" * 70)
+    
+    # Example 1: Simple personal assistant (no KB, no tools)
+    print("\n📱 EXAMPLE 1: Simple Personal Assistant")
+    print("-" * 70)
+    prompt1 = dynamic_prompt_builder.build_prompt(
+        usage_mode="personal",
+        has_knowledge_base=False,
+        has_tools=False,
+        memory_type="json"
+    )
+    print(prompt1[:300] + "...")
+    
+    # Example 2: Business with Knowledge Base
+    print("\n\n🏢 EXAMPLE 2: Business with Knowledge Base")
+    print("-" * 70)
+    prompt2 = dynamic_prompt_builder.build_prompt(
+        usage_mode="business",
+        has_knowledge_base=True,
+        has_tools=False,
+        business_config={
+            "company_name": "Acme Corp",
+            "industry": "E-commerce",
+            "founded_year": "2015"
+        },
+        memory_type="sql"
+    )
+    print(prompt2[:300] + "...")
+    
+    # Example 3: Full-featured multi-user system
+    print("\n\n⚡ EXAMPLE 3: Full-Featured Multi-User System")
+    print("-" * 70)
+    prompt3 = dynamic_prompt_builder.build_prompt(
+        usage_mode="business",
+        has_knowledge_base=True,
+        has_tools=True,
+        tool_descriptions="- Calculator: Perform math calculations\n- Weather: Get current weather",
+        is_multi_user=True,
+        current_user="customer_12345",
+        business_config={
+            "company_name": "TechSupport Inc",
+            "industry": "Technology",
+            "founded_year": "2010"
+        },
+        memory_type="sql"
+    )
+    print(prompt3[:300] + "...")
+    
+    # Feature summaries
+    print("\n\n📊 FEATURE SUMMARIES")
+    print("-" * 70)
+    
+    configs = [
+        ("Simple", False, False, False, "json"),
+        ("Basic KB", True, False, False, "json"),
+        ("With Tools", True, True, False, "sql"),
+        ("Full System", True, True, True, "sql"),
+    ]
+    
+    for name, kb, tools, multi, mem in configs:
+        summary = dynamic_prompt_builder.get_feature_summary(kb, tools, multi, mem)
+        print(f"{name:15} : {summary}")

mem_llm/llm_client.py

@@ -5,13 +5,14 @@ Works with Granite4:tiny-h model
 
 import requests
 import json
+import time
 from typing import List, Dict, Optional
 
 
 class OllamaClient:
     """Uses local LLM model with Ollama API"""
     
-    def __init__(self, model: str = "granite4:tiny-h", 
+    def __init__(self, model: str = "granite4:3b", 
                  base_url: str = "http://localhost:11434"):
         """
         Args:
@@ -79,19 +80,37 @@ class OllamaClient:
         if system_prompt:
             payload["system"] = system_prompt
         
-        try:
-            response = requests.post(self.api_url, json=payload, timeout=60)
-            if response.status_code == 200:
-                return response.json().get('response', '').strip()
-            else:
-                return f"Error: {response.status_code} - {response.text}"
-        except Exception as e:
-            return f"Connection error: {str(e)}"
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = requests.post(self.api_url, json=payload, timeout=60)
+                if response.status_code == 200:
+                    return response.json().get('response', '').strip()
+                else:
+                    if attempt < max_retries - 1:
+                        time.sleep(1.0 * (2 ** attempt))  # Exponential backoff
+                        continue
+                    return f"Error: {response.status_code} - {response.text}"
+            except requests.exceptions.Timeout:
+                if attempt < max_retries - 1:
+                    time.sleep(2.0 * (2 ** attempt))
+                    continue
+                return "Error: Request timeout. Please check if Ollama is running."
+            except requests.exceptions.ConnectionError:
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                return "Error: Cannot connect to Ollama. Make sure Ollama service is running."
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    time.sleep(1.0 * (2 ** attempt))
+                    continue
+                return f"Connection error: {str(e)}"
     
     def chat(self, messages: List[Dict[str, str]], 
-             temperature: float = 0.7, max_tokens: int = 500) -> str:
+             temperature: float = 0.7, max_tokens: int = 2000) -> str:
         """
-        Chat format interaction
+        Chat format interaction - Compatible with ALL Ollama models
         
         Args:
             messages: Message history [{"role": "user/assistant/system", "content": "..."}]
@@ -107,14 +126,58 @@ class OllamaClient:
             "stream": False,
             "options": {
                 "temperature": temperature,
-                "num_predict": max_tokens
+                "num_predict": max_tokens,
+                "num_ctx": 4096,  # Context window
+                "top_k": 40,  # Limit vocab
+                "top_p": 0.9,  # Nucleus sampling
+                "num_thread": 8  # Parallel processing
             }
         }
         
+        # For thinking-enabled models (like qwen3), disable thinking mode
+        # to get direct answers instead of reasoning process
+        if 'qwen' in self.model.lower() or 'deepseek' in self.model.lower():
+            payload["options"]["enable_thinking"] = False
+        
         try:
-            response = requests.post(self.chat_url, json=payload, timeout=60)
+            response = requests.post(self.chat_url, json=payload, timeout=120)
             if response.status_code == 200:
-                return response.json().get('message', {}).get('content', '').strip()
+                response_data = response.json()
+                message = response_data.get('message', {})
+                
+                # Get content - primary response field
+                result = message.get('content', '').strip()
+                
+                # Fallback: If content is empty but thinking exists
+                # This happens when thinking mode couldn't be disabled
+                if not result and message.get('thinking'):
+                    thinking = message.get('thinking', '')
+                    
+                    # Try to extract the actual answer from thinking process
+                    # Usually the answer is at the end after reasoning
+                    if thinking:
+                        # Split by common patterns that indicate final answer
+                        for separator in ['\n\nAnswer:', '\n\nFinal answer:', 
+                                        '\n\nResponse:', '\n\nSo the answer is:',
+                                        '\n\n---\n', '\n\nOkay,']:
+                            if separator in thinking:
+                                parts = thinking.split(separator)
+                                if len(parts) > 1:
+                                    result = parts[-1].strip()
+                                    break
+                        
+                        # If no separator found, try to get last meaningful paragraph
+                        if not result:
+                            paragraphs = [p.strip() for p in thinking.split('\n\n') if p.strip()]
+                            if paragraphs:
+                                # Take the last paragraph as likely answer
+                                last_para = paragraphs[-1]
+                                # Avoid meta-commentary like "Wait, let me think..."
+                                if not any(word in last_para.lower() for word in 
+                                         ['wait', 'hmm', 'let me', 'thinking', 'okay']):
+                                    result = last_para
+                
+                return result
             else:
                 return f"Error: {response.status_code} - {response.text}"
         except Exception as e:

mem_llm/llm_client_factory.py

@@ -0,0 +1,260 @@
+"""
+LLM Client Factory
+==================
+
+Factory pattern for creating LLM clients.
+Supports multiple backends with automatic detection.
+
+Supported Backends:
+- Ollama: Local Ollama service
+- LM Studio: Local LM Studio server
+
+Usage:
+    # Create specific backend
+    client = LLMClientFactory.create('ollama', model='llama3')
+    
+    # Auto-detect available backend
+    client = LLMClientFactory.auto_detect()
+    
+    # Get all available backends
+    backends = LLMClientFactory.get_available_backends()
+
+Author: C. Emre Karataş
+Version: 1.3.0
+"""
+
+from typing import Optional, Dict, List, Any
+import logging
+
+from .clients.ollama_client import OllamaClient
+from .clients.lmstudio_client import LMStudioClient
+from .base_llm_client import BaseLLMClient
+
+
+class LLMClientFactory:
+    """
+    Factory for creating LLM clients
+    
+    Provides unified interface for creating different LLM backends.
+    Supports auto-detection of available local services.
+    """
+    
+    # Registry of supported backends
+    BACKENDS = {
+        'ollama': {
+            'class': OllamaClient,
+            'description': 'Local Ollama service',
+            'type': 'local',
+            'default_url': 'http://localhost:11434',
+            'default_model': 'granite4:3b'
+        },
+        'lmstudio': {
+            'class': LMStudioClient,
+            'description': 'LM Studio local server (OpenAI-compatible)',
+            'type': 'local',
+            'default_url': 'http://localhost:1234',
+            'default_model': 'local-model'
+        }
+    }
+    
+    @staticmethod
+    def create(backend: str, model: Optional[str] = None, **kwargs) -> BaseLLMClient:
+        """
+        Create LLM client for specified backend
+        
+        Args:
+            backend: Backend name ('ollama', 'lmstudio')
+            model: Model name (uses default if None)
+            **kwargs: Backend-specific configuration
+                     - base_url: API endpoint (for local backends)
+                     - temperature: Default temperature
+                     - max_tokens: Default max tokens
+            
+        Returns:
+            Configured LLM client
+            
+        Raises:
+            ValueError: If backend is not supported
+            
+        Examples:
+            # Ollama
+            client = LLMClientFactory.create('ollama', model='llama3')
+            
+            # LM Studio
+            client = LLMClientFactory.create(
+                'lmstudio',
+                model='llama-3-8b',
+                base_url='http://localhost:1234'
+            )
+        """
+        backend = backend.lower()
+        
+        if backend not in LLMClientFactory.BACKENDS:
+            available = ', '.join(LLMClientFactory.BACKENDS.keys())
+            raise ValueError(
+                f"Unsupported backend: '{backend}'. "
+                f"Available backends: {available}"
+            )
+        
+        backend_info = LLMClientFactory.BACKENDS[backend]
+        client_class = backend_info['class']
+        
+        # Use default model if not specified
+        if not model:
+            model = backend_info.get('default_model')
+        
+        # Add default base_url for local backends if not provided
+        if backend_info['type'] == 'local' and 'base_url' not in kwargs:
+            kwargs['base_url'] = backend_info.get('default_url')
+        
+        # Create and return client
+        try:
+            return client_class(model=model, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Failed to create {backend} client: {str(e)}") from e
+    
+    @staticmethod
+    def auto_detect(preferred_backends: Optional[List[str]] = None) -> Optional[BaseLLMClient]:
+        """
+        Auto-detect available LLM service
+        
+        Checks common local services and returns the first available one.
+        Useful for applications that should work with any available backend.
+        
+        Args:
+            preferred_backends: List of backends to check in order
+                              (if None, checks all in default order)
+        
+        Returns:
+            First available LLM client, or None if none available
+            
+        Example:
+            # Try to find any available backend
+            client = LLMClientFactory.auto_detect()
+            if client:
+                print(f"Using {client.get_info()['backend']}")
+            else:
+                print("No LLM service found")
+            
+            # Try specific backends in order
+            client = LLMClientFactory.auto_detect(['lmstudio', 'ollama'])
+        """
+        logger = logging.getLogger('LLMClientFactory')
+        
+        # Default check order: local services first
+        if preferred_backends is None:
+            preferred_backends = ['ollama', 'lmstudio']
+        
+        for backend_name in preferred_backends:
+            if backend_name not in LLMClientFactory.BACKENDS:
+                logger.warning(f"Unknown backend in auto-detect: {backend_name}")
+                continue
+            
+            backend_info = LLMClientFactory.BACKENDS[backend_name]
+            
+            # Skip cloud services in auto-detect (they require API keys)
+            if backend_info['type'] == 'cloud':
+                logger.debug(f"Skipping cloud backend in auto-detect: {backend_name}")
+                continue
+            
+            try:
+                # Try to create client with defaults
+                client = LLMClientFactory.create(backend_name)
+                
+                # Check if service is actually running
+                if client.check_connection():
+                    logger.info(f"✅ Detected {backend_name} at {backend_info.get('default_url')}")
+                    return client
+                else:
+                    logger.debug(f"Service not running: {backend_name}")
+                    
+            except Exception as e:
+                logger.debug(f"Failed to detect {backend_name}: {e}")
+                continue
+        
+        logger.warning("⚠️  No local LLM service detected")
+        return None
+    
+    @staticmethod
+    def get_available_backends() -> List[Dict[str, Any]]:
+        """
+        Get list of all supported backends with their info
+        
+        Returns:
+            List of backend information dictionaries
+            
+        Example:
+            backends = LLMClientFactory.get_available_backends()
+            for backend in backends:
+                print(f"{backend['name']}: {backend['description']}")
+        """
+        result = []
+        
+        for name, info in LLMClientFactory.BACKENDS.items():
+            backend_dict = {
+                'name': name,
+                'description': info['description'],
+                'type': info['type'],
+                'default_model': info.get('default_model'),
+                'requires_api_key': info.get('requires_api_key', False)
+            }
+            
+            if info['type'] == 'local':
+                backend_dict['default_url'] = info.get('default_url')
+            
+            result.append(backend_dict)
+        
+        return result
+    
+    @staticmethod
+    def check_backend_availability(backend: str, **kwargs) -> bool:
+        """
+        Check if a specific backend is available
+        
+        Args:
+            backend: Backend name
+            **kwargs: Configuration for creating the client
+            
+        Returns:
+            True if backend is available and responding
+            
+        Example:
+            # Check if Ollama is running
+            if LLMClientFactory.check_backend_availability('ollama'):
+                print("Ollama is available")
+            
+            # Check custom LM Studio URL
+            if LLMClientFactory.check_backend_availability(
+                'lmstudio',
+                base_url='http://localhost:5000'
+            ):
+                print("LM Studio is available")
+        """
+        try:
+            client = LLMClientFactory.create(backend, **kwargs)
+            return client.check_connection()
+        except Exception:
+            return False
+    
+    @staticmethod
+    def get_backend_info(backend: str) -> Dict[str, Any]:
+        """
+        Get information about a specific backend
+        
+        Args:
+            backend: Backend name
+            
+        Returns:
+            Backend information dictionary
+            
+        Raises:
+            ValueError: If backend not found
+        """
+        if backend not in LLMClientFactory.BACKENDS:
+            raise ValueError(f"Unknown backend: {backend}")
+        
+        info = LLMClientFactory.BACKENDS[backend].copy()
+        # Remove class reference for JSON serialization
+        info.pop('class', None)
+        return info
+