mem-llm 1.0.7__py3-none-any.whl → 1.0.11__py3-none-any.whl

mem_llm/__init__.py

@@ -17,19 +17,25 @@ except ImportError:
 # Pro version imports (optional)
 try:
     from .memory_db import SQLMemoryManager
-    from .prompt_templates import prompt_manager
     from .config_manager import get_config
     from .config_from_docs import create_config_from_document
-    __all_pro__ = ["SQLMemoryManager", "prompt_manager", "get_config", "create_config_from_document"]
+    from .dynamic_prompt import dynamic_prompt_builder
+    __all_pro__ = ["SQLMemoryManager", "get_config", "create_config_from_document", "dynamic_prompt_builder"]
 except ImportError:
     __all_pro__ = []
 
-__version__ = "1.0.7"
+__version__ = "1.0.11"
 __author__ = "C. Emre Karataş"
 
+# CLI
+try:
+    from .cli import cli
+    __all_cli__ = ["cli"]
+except ImportError:
+    __all_cli__ = []
+
 __all__ = [
     "MemAgent",
-    "MemoryManager",
+    "MemoryManager", 
     "OllamaClient",
-] + __all_tools__ + __all_pro__
-
+] + __all_tools__ + __all_pro__ + __all_cli__

mem_llm/cli.py

@@ -0,0 +1,254 @@
+"""
+Command Line Interface for Mem-LLM
+Interactive chat, statistics, and data management
+"""
+
+import click
+import json
+import sys
+from typing import Optional
+from .mem_agent import MemAgent
+from . import __version__
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="mem-llm")
+def cli():
+    """
+    Mem-LLM - Memory-enabled AI Assistant CLI
+    
+    A powerful command-line interface for interacting with your AI assistant.
+    """
+    pass
+
+
+@cli.command()
+@click.option('--user', '-u', default='default', help='User ID for the chat session')
+@click.option('--model', '-m', default='granite4:tiny-h', help='LLM model to use')
+@click.option('--sql/--json', default=False, help='Use SQL (default: JSON)')
+@click.option('--config', '-c', type=click.Path(exists=True), help='Config file path')
+def chat(user: str, model: str, sql: bool, config: Optional[str]):
+    """
+    Start an interactive chat session
+    
+    Examples:
+        mem-llm chat --user john
+        mem-llm chat --user alice --sql
+        mem-llm chat --config config.yaml
+    """
+    click.echo("🤖 Mem-LLM Interactive Chat")
+    click.echo("=" * 60)
+    
+    # Initialize agent
+    try:
+        if config:
+            agent = MemAgent(config_file=config)
+        else:
+            agent = MemAgent(model=model, use_sql=sql)
+        
+        # Check setup
+        status = agent.check_setup()
+        if status['status'] != 'ready':
+            click.echo("\n❌ Setup Error!", err=True)
+            if not status['ollama_running']:
+                click.echo("   → Ollama service is not running", err=True)
+                click.echo("   → Start it with: ollama serve", err=True)
+            elif not status['model_ready']:
+                click.echo(f"   → Model '{model}' not found", err=True)
+                click.echo(f"   → Download it with: ollama pull {model}", err=True)
+            sys.exit(1)
+        
+        agent.set_user(user)
+        
+        click.echo(f"\n✅ Chat session started")
+        click.echo(f"   User: {user}")
+        click.echo(f"   Model: {model}")
+        click.echo(f"   Memory: {'SQL' if sql else 'JSON'}")
+        click.echo("\nType your message and press Enter. Commands:")
+        click.echo("  /profile  - Show user profile")
+        click.echo("  /stats    - Show statistics")
+        click.echo("  /history  - Show recent conversations")
+        click.echo("  /exit     - Exit chat\n")
+        
+        # Chat loop
+        while True:
+            try:
+                message = input(f"\n{user}> ").strip()
+                
+                if not message:
+                    continue
+                
+                # Handle commands
+                if message.lower() in ['/exit', '/quit', 'exit', 'quit']:
+                    click.echo("\n👋 Goodbye!")
+                    break
+                
+                elif message.lower() == '/profile':
+                    profile = agent.get_user_profile()
+                    click.echo("\n👤 User Profile:")
+                    click.echo(json.dumps(profile, indent=2, ensure_ascii=False))
+                    continue
+                
+                elif message.lower() == '/stats':
+                    stats = agent.get_statistics()
+                    click.echo("\n📊 Statistics:")
+                    click.echo(json.dumps(stats, indent=2, ensure_ascii=False))
+                    continue
+                
+                elif message.lower() == '/history':
+                    if hasattr(agent.memory, 'get_recent_conversations'):
+                        convs = agent.memory.get_recent_conversations(user, 5)
+                        click.echo("\n📜 Recent Conversations:")
+                        for i, conv in enumerate(convs, 1):
+                            click.echo(f"\n{i}. [{conv.get('timestamp', 'N/A')}]")
+                            click.echo(f"   You: {conv.get('user_message', '')[:100]}")
+                            click.echo(f"   Bot: {conv.get('bot_response', '')[:100]}")
+                    continue
+                
+                # Regular chat
+                response = agent.chat(message)
+                click.echo(f"\n🤖 Bot> {response}")
+                
+            except KeyboardInterrupt:
+                click.echo("\n\n👋 Goodbye!")
+                break
+            except EOFError:
+                click.echo("\n\n👋 Goodbye!")
+                break
+    
+    except Exception as e:
+        click.echo(f"\n❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.option('--user', '-u', help='User ID (optional, shows all users if not specified)')
+@click.option('--sql/--json', default=False, help='Use SQL (default: JSON)')
+def stats(user: Optional[str], sql: bool):
+    """
+    Show memory statistics
+    
+    Examples:
+        mem-llm stats
+        mem-llm stats --user john
+        mem-llm stats --sql
+    """
+    try:
+        agent = MemAgent(use_sql=sql)
+        
+        if user:
+            agent.set_user(user)
+            profile = agent.get_user_profile()
+            click.echo(f"\n👤 User Profile: {user}")
+            click.echo("=" * 60)
+            click.echo(json.dumps(profile, indent=2, ensure_ascii=False))
+        else:
+            stats = agent.get_statistics()
+            click.echo("\n📊 Memory Statistics")
+            click.echo("=" * 60)
+            click.echo(json.dumps(stats, indent=2, ensure_ascii=False))
+    
+    except Exception as e:
+        click.echo(f"\n❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument('user')
+@click.option('--format', '-f', type=click.Choice(['json', 'txt']), default='json', help='Export format')
+@click.option('--output', '-o', type=click.Path(), help='Output file (default: stdout)')
+@click.option('--sql/--json', default=False, help='Use SQL (default: JSON)')
+def export(user: str, format: str, output: Optional[str], sql: bool):
+    """
+    Export user conversation data
+    
+    Examples:
+        mem-llm export john
+        mem-llm export john --format txt
+        mem-llm export john --output john_data.json
+    """
+    try:
+        agent = MemAgent(use_sql=sql)
+        agent.set_user(user)
+        
+        data = agent.export_memory(format=format)
+        
+        if output:
+            with open(output, 'w', encoding='utf-8') as f:
+                f.write(data)
+            click.echo(f"✅ Exported to: {output}")
+        else:
+            click.echo(data)
+    
+    except Exception as e:
+        click.echo(f"\n❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.option('--model', '-m', default='granite4:tiny-h', help='Model to check')
+def check(model: str):
+    """
+    Check if Ollama and model are ready
+    
+    Example:
+        mem-llm check
+        mem-llm check --model llama3.2:3b
+    """
+    try:
+        agent = MemAgent(model=model)
+        status = agent.check_setup()
+        
+        click.echo("\n🔍 System Check")
+        click.echo("=" * 60)
+        click.echo(f"Ollama Running:    {'✅' if status['ollama_running'] else '❌'}")
+        click.echo(f"Target Model:      {status['target_model']}")
+        click.echo(f"Model Ready:       {'✅' if status['model_ready'] else '❌'}")
+        click.echo(f"Memory Backend:    {status['memory_backend']}")
+        click.echo(f"Total Users:       {status['total_users']}")
+        click.echo(f"Total Chats:       {status['total_interactions']}")
+        click.echo(f"KB Entries:        {status['kb_entries']}")
+        
+        if status['available_models']:
+            click.echo(f"\nAvailable Models:")
+            for m in status['available_models']:
+                click.echo(f"  • {m}")
+        
+        click.echo(f"\nStatus: {'✅ READY' if status['status'] == 'ready' else '❌ NOT READY'}")
+        
+        if status['status'] != 'ready':
+            sys.exit(1)
+    
+    except Exception as e:
+        click.echo(f"\n❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument('user')
+@click.confirmation_option(prompt='Are you sure you want to delete all data for this user?')
+@click.option('--sql/--json', default=False, help='Use SQL (default: JSON)')
+def clear(user: str, sql: bool):
+    """
+    Clear all data for a user (requires confirmation)
+    
+    Example:
+        mem-llm clear john
+    """
+    try:
+        agent = MemAgent(use_sql=sql)
+        result = agent.clear_user_data(user, confirm=True)
+        click.echo(f"✅ {result}")
+    
+    except Exception as e:
+        click.echo(f"\n❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+def main():
+    """Entry point for the CLI"""
+    cli()
+
+
+if __name__ == '__main__':
+    main()

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

@@ -89,9 +89,9 @@ class OllamaClient:
             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": "..."}]
@@ -108,17 +108,57 @@ class OllamaClient:
             "options": {
                 "temperature": temperature,
                 "num_predict": max_tokens,
-                "num_ctx": 2048,  # Context window
+                "num_ctx": 4096,  # Context window
                 "top_k": 40,  # Limit vocab
                 "top_p": 0.9,  # Nucleus sampling
-                "stop": ["\n\n\n", "---"]  # Stop sequences
+                "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: