mem-llm 2.0.0__py3-none-any.whl

mem_llm/clients/ollama_client.py

@@ -0,0 +1,354 @@
+"""
+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
+import json
+from typing import List, Dict, Optional, Iterator
+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:3b",
+                 base_url: str = "http://localhost:11434",
+                 **kwargs):
+        """
+        Initialize Ollama client
+        
+        Args:
+            model: Model name (e.g., "llama3", "granite4:3b")
+            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 chat_stream(self, 
+                    messages: List[Dict[str, str]], 
+                    temperature: float = 0.7, 
+                    max_tokens: int = 2000,
+                    **kwargs) -> Iterator[str]:
+        """
+        Send chat request to Ollama with streaming response
+        
+        Args:
+            messages: Message history
+            temperature: Sampling temperature (0.0-1.0)
+            max_tokens: Maximum tokens in response
+            **kwargs: Additional Ollama-specific options
+            
+        Yields:
+            Response text chunks as they arrive
+            
+        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": True,  # Enable streaming
+            "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
+        if any(name in self.model.lower() for name in ['qwen', 'deepseek', 'qwq']):
+            payload["options"]["enable_thinking"] = False
+        
+        try:
+            response = requests.post(
+                self.chat_url,
+                json=payload,
+                stream=True,  # Enable streaming
+                timeout=kwargs.get("timeout", 120)
+            )
+            
+            if response.status_code == 200:
+                # Process streaming response
+                for line in response.iter_lines():
+                    if line:
+                        try:
+                            chunk_data = json.loads(line.decode('utf-8'))
+                            
+                            # Get message content
+                            message = chunk_data.get('message', {})
+                            content = message.get('content', '')
+                            
+                            if content:
+                                yield content
+                            
+                            # Check if this is the final chunk
+                            if chunk_data.get('done', False):
+                                break
+                                
+                        except json.JSONDecodeError as e:
+                            self.logger.warning(f"Failed to parse streaming chunk: {e}")
+                            continue
+            else:
+                error_msg = f"Ollama API error: {response.status_code} - {response.text}"
+                self.logger.error(error_msg)
+                raise ConnectionError(error_msg)
+                
+        except requests.exceptions.Timeout:
+            raise ConnectionError("Ollama request timeout. Check if service is running.")
+        except requests.exceptions.ConnectionError as e:
+            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 in streaming: {e}")
+            raise
+    
+    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.yaml.example

@@ -0,0 +1,52 @@
+# Memory-LLM Configuration File
+# Copy this file to config.yaml and edit as needed
+
+# Usage Mode: "personal" or "business"
+usage_mode: "personal"
+
+# LLM Settings
+llm:
+  model: "granite4:3b"
+  base_url: "http://localhost:11434"
+  temperature: 0.7
+  max_tokens: 500
+
+# Memory Settings
+memory:
+  backend: "json"  # "json" or "sql"
+  json_dir: "memories"
+  db_path: "memories.db"
+
+# System Prompt Template
+prompt:
+  template: "personal_assistant"
+  variables:
+    user_name: "User"
+    tone: "friendly"
+
+# Knowledge Base
+knowledge_base:
+  enabled: true
+  auto_load: true
+  default_kb: "ecommerce"
+  search_limit: 5
+
+# Response Settings
+response:
+  use_knowledge_base: true
+  use_memory: true
+  recent_conversations_limit: 5
+
+# Logging
+logging:
+  enabled: true
+  level: "INFO"
+  file: "mem_agent.log"
+
+# Security
+security:
+  filter_sensitive_data: true
+  rate_limit:
+    enabled: true
+    max_requests_per_minute: 60
+

mem_llm/config_from_docs.py

@@ -0,0 +1,180 @@
+"""
+Config Generator from Documents (PDF, DOCX, TXT)
+Automatically creates config.yaml from business documents
+"""
+
+import os
+from typing import Optional, Dict, Any
+import yaml
+
+
+def extract_text_from_file(file_path: str) -> str:
+    """
+    Extract text from PDF, DOCX, or TXT files
+    
+    Args:
+        file_path: Path to document
+        
+    Returns:
+        Extracted text
+    """
+    file_ext = os.path.splitext(file_path)[1].lower()
+    
+    if file_ext == '.txt':
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    
+    elif file_ext == '.pdf':
+        try:
+            import PyPDF2
+            text = []
+            with open(file_path, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                for page in reader.pages:
+                    text.append(page.extract_text())
+            return '\n'.join(text)
+        except ImportError:
+            return "⚠️ PyPDF2 not installed. Run: pip install PyPDF2"
+    
+    elif file_ext in ['.docx', '.doc']:
+        try:
+            import docx
+            doc = docx.Document(file_path)
+            text = []
+            for paragraph in doc.paragraphs:
+                text.append(paragraph.text)
+            return '\n'.join(text)
+        except ImportError:
+            return "⚠️ python-docx not installed. Run: pip install python-docx"
+    
+    else:
+        return f"⚠️ Unsupported file format: {file_ext}"
+
+
+def generate_config_from_text(text: str, company_name: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Generate config.yaml structure from text
+    
+    Args:
+        text: Extracted text from document
+        company_name: Company name (optional)
+        
+    Returns:
+        Config dictionary
+    """
+    # Simple config template
+    config = {
+        "usage_mode": "business",  # or "personal"
+        
+        "llm": {
+            "model": "granite4:3b",
+            "temperature": 0.3,
+            "max_tokens": 300,
+            "ollama_url": "http://localhost:11434"
+        },
+        
+        "memory": {
+            "use_sql": True,
+            "db_path": "memories.db",
+            "json_dir": "memories"
+        },
+        
+        "response": {
+            "use_knowledge_base": True,
+            "recent_conversations_limit": 5
+        },
+        
+        "business": {
+            "company_name": company_name or "Your Company",
+            "industry": "Technology",
+            "founded_year": "2024"
+        },
+        
+        "knowledge_base": {
+            "auto_load": True,
+            "search_limit": 5
+        },
+        
+        "logging": {
+            "level": "INFO",
+            "file": "mem_agent.log"
+        }
+    }
+    
+    # Try to extract company name from text if not provided
+    if not company_name:
+        lines = text.split('\n')[:10]  # First 10 lines
+        for line in lines:
+            if any(keyword in line.lower() for keyword in ['company', 'corp', 'inc', 'ltd']):
+                config["business"]["company_name"] = line.strip()[:50]
+                break
+    
+    return config
+
+
+def create_config_from_document(
+    doc_path: str,
+    output_path: str = "config.yaml",
+    company_name: Optional[str] = None
+) -> str:
+    """
+    Create config.yaml from a business document
+    
+    Args:
+        doc_path: Path to PDF/DOCX/TXT document
+        output_path: Output config.yaml path
+        company_name: Company name (optional)
+        
+    Returns:
+        Success message
+    """
+    if not os.path.exists(doc_path):
+        return f"❌ File not found: {doc_path}"
+    
+    # Extract text
+    print(f"📄 Reading document: {doc_path}")
+    text = extract_text_from_file(doc_path)
+    
+    if text.startswith("⚠️"):
+        return text  # Error message
+    
+    print(f"✅ Extracted {len(text)} characters")
+    
+    # Generate config
+    config = generate_config_from_text(text, company_name)
+    
+    # Save to YAML
+    with open(output_path, 'w', encoding='utf-8') as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+    
+    print(f"✅ Config created: {output_path}")
+    print(f"📌 Company: {config['business']['company_name']}")
+    
+    return f"✅ Config successfully created at {output_path}"
+
+
+# Simple CLI
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("""
+🔧 Config Generator from Documents
+
+Usage:
+    python -m mem_llm.config_from_docs <document_path> [output_path] [company_name]
+
+Examples:
+    python -m mem_llm.config_from_docs company_info.pdf
+    python -m mem_llm.config_from_docs business.docx my_config.yaml "Acme Corp"
+    python -m mem_llm.config_from_docs info.txt
+        """)
+        sys.exit(1)
+    
+    doc_path = sys.argv[1]
+    output_path = sys.argv[2] if len(sys.argv) > 2 else "config.yaml"
+    company_name = sys.argv[3] if len(sys.argv) > 3 else None
+    
+    result = create_config_from_document(doc_path, output_path, company_name)
+    print(result)
+