mem-llm 2.0.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/knowledge_loader.py

@@ -0,0 +1,88 @@
+"""
+Knowledge Base Loader
+Loads pre-prepared problem/solution database into the system
+"""
+
+import json
+try:
+    import yaml
+except ImportError:
+    import pyyaml as yaml
+from pathlib import Path
+from typing import List, Dict, Optional
+from .memory_db import SQLMemoryManager
+
+
+class KnowledgeLoader:
+    """Knowledge base management and loading"""
+    
+    def __init__(self, db_manager: SQLMemoryManager):
+        """
+        Args:
+            db_manager: SQL memory manager
+        """
+        self.db = db_manager
+    
+    def load_from_json(self, file_path: str) -> int:
+        """Load knowledge base from JSON file"""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        count = 0
+        for entry in data.get('knowledge_base', []):
+            self.db.add_knowledge(
+                category=entry['category'],
+                question=entry['question'],
+                answer=entry['answer'],
+                keywords=entry.get('keywords', []),
+                priority=entry.get('priority', 0)
+            )
+            count += 1
+        
+        return count
+    
+    def load_default_ecommerce_kb(self) -> int:
+        """Load default e-commerce knowledge base"""
+        knowledge = [
+            {
+                "category": "shipping",
+                "question": "When will my order arrive?",
+                "answer": "Orders are shipped within 2-3 business days and delivered within 3-5 business days.",
+                "keywords": ["shipping", "delivery", "time"],
+                "priority": 10
+            },
+            {
+                "category": "return",
+                "question": "How do I return a product?",
+                "answer": "You can return products within 14 days. Create a return request from My Orders page.",
+                "keywords": ["return", "refund"],
+                "priority": 10
+            },
+        ]
+        
+        count = 0
+        for entry in knowledge:
+            self.db.add_knowledge(**entry)
+            count += 1
+        
+        return count
+    
+    def load_default_tech_support_kb(self) -> int:
+        """Load default tech support knowledge base"""
+        knowledge = [
+            {
+                "category": "connection",
+                "question": "Cannot connect to internet",
+                "answer": "1) Restart your modem/router 2) Check Wi-Fi password 3) Try other devices",
+                "keywords": ["internet", "connection", "wifi"],
+                "priority": 10
+            },
+        ]
+        
+        count = 0
+        for entry in knowledge:
+            self.db.add_knowledge(**entry)
+            count += 1
+        
+        return count
+

mem_llm/llm_client.py

@@ -0,0 +1,225 @@
+"""
+LLM Client - Local model integration with Ollama
+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:3b", 
+                 base_url: str = "http://localhost:11434"):
+        """
+        Args:
+            model: Model name to use
+            base_url: Ollama API URL
+        """
+        self.model = model
+        self.base_url = base_url
+        self.api_url = f"{base_url}/api/generate"
+        self.chat_url = f"{base_url}/api/chat"
+        
+    def check_connection(self) -> bool:
+        """
+        Checks if Ollama service is running
+        
+        Returns:
+            Is service running?
+        """
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            return response.status_code == 200
+        except:
+            return False
+    
+    def list_models(self) -> List[str]:
+        """
+        List available models
+        
+        Returns:
+            List of model names
+        """
+        try:
+            response = requests.get(f"{self.base_url}/api/tags")
+            if response.status_code == 200:
+                data = response.json()
+                return [model['name'] for model in data.get('models', [])]
+            return []
+        except:
+            return []
+    
+    def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                 temperature: float = 0.7, max_tokens: int = 500) -> str:
+        """
+        Generate simple text
+        
+        Args:
+            prompt: User prompt (not AI system prompt)
+            system_prompt: AI system prompt
+            temperature: Creativity level (0-1)
+            max_tokens: Maximum token count
+            
+        Returns:
+            Model output
+        """
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens
+            }
+        }
+        
+        if system_prompt:
+            payload["system"] = system_prompt
+        
+        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 = 2000) -> str:
+        """
+        Chat format interaction - Compatible with ALL Ollama models
+        
+        Args:
+            messages: Message history [{"role": "user/assistant/system", "content": "..."}]
+            temperature: Creativity level
+            max_tokens: Maximum token count
+            
+        Returns:
+            Model response
+        """
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "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=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: 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:
+            return f"Connection error: {str(e)}"
+    
+    def generate_with_memory_context(self, user_message: str, 
+                                     memory_summary: str,
+                                     recent_conversations: List[Dict]) -> str:
+        """
+        Generate response with memory context
+        
+        Args:
+            user_message: User's message
+            memory_summary: User memory summary
+            recent_conversations: Recent conversations
+            
+        Returns:
+            Context-aware response
+        """
+        # Create 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."""
+        
+        # Create 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
+        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)
+