mem-llm 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

mem_llm/memory_db.py

@@ -9,15 +9,32 @@ import threading
 from datetime import datetime
 from typing import Dict, List, Optional, Tuple
 from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Optional vector store support
+try:
+    from .vector_store import create_vector_store, VectorStore
+    VECTOR_STORE_AVAILABLE = True
+except ImportError:
+    VECTOR_STORE_AVAILABLE = False
+    VectorStore = None
 
 
 class SQLMemoryManager:
     """SQLite-based memory management system with thread-safety"""
     
-    def __init__(self, db_path: str = "memories/memories.db"):
+    def __init__(self, db_path: str = "memories/memories.db",
+                 enable_vector_search: bool = False,
+                 vector_store_type: str = "chroma",
+                 embedding_model: str = "all-MiniLM-L6-v2"):
         """
         Args:
             db_path: SQLite database file path
+            enable_vector_search: Enable vector/semantic search (optional)
+            vector_store_type: Type of vector store ('chroma', etc.)
+            embedding_model: Embedding model name (sentence-transformers)
         """
         self.db_path = Path(db_path)
         
@@ -29,6 +46,35 @@ class SQLMemoryManager:
         self.conn = None
         self._lock = threading.RLock()  # Reentrant lock for thread safety
         self._init_database()
+        
+        # Vector store (optional)
+        self.enable_vector_search = enable_vector_search
+        self.vector_store: Optional[VectorStore] = None
+        
+        if enable_vector_search:
+            if not VECTOR_STORE_AVAILABLE:
+                logger.warning(
+                    "Vector search requested but dependencies not available. "
+                    "Install with: pip install chromadb sentence-transformers"
+                )
+                self.enable_vector_search = False
+            else:
+                try:
+                    persist_dir = str(db_dir / "vector_store")
+                    self.vector_store = create_vector_store(
+                        store_type=vector_store_type,
+                        collection_name="knowledge_base",
+                        persist_directory=persist_dir,
+                        embedding_model=embedding_model
+                    )
+                    if self.vector_store:
+                        logger.info(f"Vector search enabled: {vector_store_type}")
+                    else:
+                        logger.warning("Failed to initialize vector store, falling back to keyword search")
+                        self.enable_vector_search = False
+                except Exception as e:
+                    logger.error(f"Error initializing vector store: {e}")
+                    self.enable_vector_search = False
     
     def _init_database(self) -> None:
         """Create database and tables"""
@@ -312,22 +358,44 @@ class SQLMemoryManager:
         """, (category, question, answer, 
               json.dumps(keywords or []), priority))
         
+        kb_id = cursor.lastrowid
         self.conn.commit()
-        return cursor.lastrowid
+        
+        # Sync to vector store if enabled
+        if self.enable_vector_search and self.vector_store:
+            try:
+                self._sync_to_vector_store(kb_id)
+            except Exception as e:
+                logger.warning(f"Failed to sync KB entry to vector store: {e}")
+        
+        return kb_id
     
     def search_knowledge(self, query: str, category: Optional[str] = None,
-                        limit: int = 5) -> List[Dict]:
+                        limit: int = 5, use_vector_search: Optional[bool] = None) -> List[Dict]:
         """
-        Bilgi bankasında arama yapar (gelişmiş keyword matching)
+        Bilgi bankasında arama yapar (keyword matching veya semantic search)
         
         Args:
             query: Arama sorgusu
             category: Kategori filtresi (opsiyonel)
             limit: Maksimum sonuç sayısı
+            use_vector_search: Force vector search (None = auto-detect)
             
         Returns:
             Bulunan kayıtlar
         """
+        # Use vector search if enabled and available
+        if use_vector_search is None:
+            use_vector_search = self.enable_vector_search
+        
+        if use_vector_search and self.vector_store:
+            return self._vector_search(query, category, limit)
+        else:
+            return self._keyword_search(query, category, limit)
+    
+    def _keyword_search(self, query: str, category: Optional[str] = None,
+                       limit: int = 5) -> List[Dict]:
+        """Traditional keyword-based search"""
         cursor = self.conn.cursor()
         
         # Extract important keywords from query (remove question words)
@@ -378,6 +446,120 @@ class SQLMemoryManager:
         
         return [dict(row) for row in cursor.fetchall()]
     
+    def _vector_search(self, query: str, category: Optional[str] = None,
+                      limit: int = 5) -> List[Dict]:
+        """Vector-based semantic search"""
+        if not self.vector_store:
+            return []
+        
+        # Prepare metadata filter
+        filter_metadata = None
+        if category:
+            filter_metadata = {"category": category}
+        
+        # Search in vector store
+        vector_results = self.vector_store.search(
+            query=query,
+            limit=limit * 2,  # Get more results to filter by category if needed
+            filter_metadata=filter_metadata
+        )
+        
+        # Map vector results back to KB format
+        results = []
+        for result in vector_results[:limit]:
+            # Extract metadata
+            metadata = result.get('metadata', {})
+            
+            results.append({
+                'category': metadata.get('category', ''),
+                'question': metadata.get('question', ''),
+                'answer': result.get('text', ''),
+                'priority': metadata.get('priority', 0),
+                'score': result.get('score', 0.0),  # Similarity score
+                'vector_search': True
+            })
+        
+        return results
+    
+    def _sync_to_vector_store(self, kb_id: int) -> None:
+        """Sync a single KB entry to vector store"""
+        if not self.vector_store:
+            return
+        
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            SELECT id, category, question, answer, keywords, priority
+            FROM knowledge_base
+            WHERE id = ?
+        """, (kb_id,))
+        
+        row = cursor.fetchone()
+        if row:
+            doc = {
+                'id': str(row['id']),
+                'text': f"{row['question']}\n{row['answer']}",  # Combine for better search
+                'metadata': {
+                    'category': row['category'],
+                    'question': row['question'],
+                    'answer': row['answer'],
+                    'keywords': row['keywords'],
+                    'priority': row['priority'],
+                    'kb_id': row['id']
+                }
+            }
+            self.vector_store.add_documents([doc])
+    
+    def sync_all_kb_to_vector_store(self) -> int:
+        """
+        Sync all existing KB entries to vector store
+        
+        Returns:
+            Number of entries synced
+        """
+        if not self.vector_store:
+            return 0
+        
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            SELECT id, category, question, answer, keywords, priority
+            FROM knowledge_base
+            WHERE active = 1
+        """)
+        
+        rows = cursor.fetchall()
+        documents = []
+        
+        for row in rows:
+            doc = {
+                'id': str(row['id']),
+                'text': f"{row['question']}\n{row['answer']}",
+                'metadata': {
+                    'category': row['category'],
+                    'question': row['question'],
+                    'answer': row['answer'],
+                    'keywords': row['keywords'],
+                    'priority': row['priority'],
+                    'kb_id': row['id']
+                }
+            }
+            documents.append(doc)
+        
+        if documents:
+            try:
+                # Add in batches for better performance
+                batch_size = 100
+                for i in range(0, len(documents), batch_size):
+                    batch = documents[i:i + batch_size]
+                    self.vector_store.add_documents(batch)
+                    logger.debug(f"Synced {len(batch)} KB entries to vector store")
+                
+                logger.info(f"Synced {len(documents)} KB entries to vector store")
+            except Exception as e:
+                logger.error(f"Error syncing KB to vector store: {e}")
+                return 0
+        
+        return len(documents)
+    
     def get_statistics(self) -> Dict:
         """
         Genel istatistikleri döndürür

mem_llm/memory_manager.py

@@ -43,7 +43,16 @@ class MemoryManager:
             with open(user_file, 'r', encoding='utf-8') as f:
                 data = json.load(f)
                 self.conversations[user_id] = data.get('conversations', [])
-                self.user_profiles[user_id] = data.get('profile', {})
+                profile = data.get('profile', {})
+                
+                # Parse preferences if it's a JSON string (legacy format)
+                if isinstance(profile.get('preferences'), str):
+                    try:
+                        profile['preferences'] = json.loads(profile['preferences'])
+                    except:
+                        profile['preferences'] = {}
+                
+                self.user_profiles[user_id] = profile
                 return data
         else:
             # Create empty memory for new user

mem_llm/response_metrics.py

@@ -0,0 +1,221 @@
+"""
+Response Metrics Module
+=======================
+
+Tracks and analyzes LLM response quality metrics including:
+- Response latency
+- Confidence scoring
+- Knowledge base usage
+- Source tracking
+"""
+
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+import json
+
+
+@dataclass
+class ChatResponse:
+    """
+    Comprehensive response object with quality metrics
+    
+    Attributes:
+        text: The actual response text
+        confidence: Confidence score 0.0-1.0 (higher = more confident)
+        source: Response source ("knowledge_base", "model", "tool", "hybrid")
+        latency: Response time in milliseconds
+        timestamp: When the response was generated
+        kb_results_count: Number of KB results used (0 if none)
+        metadata: Additional context (model name, temperature, etc.)
+    """
+    text: str
+    confidence: float
+    source: str
+    latency: float
+    timestamp: datetime
+    kb_results_count: int = 0
+    metadata: Optional[Dict[str, Any]] = None
+    
+    def __post_init__(self):
+        """Validate metrics after initialization"""
+        # Ensure confidence is in valid range
+        if not 0.0 <= self.confidence <= 1.0:
+            raise ValueError(f"Confidence must be between 0.0 and 1.0, got {self.confidence}")
+        
+        # Validate source
+        valid_sources = ["knowledge_base", "model", "tool", "hybrid"]
+        if self.source not in valid_sources:
+            raise ValueError(f"Source must be one of {valid_sources}, got {self.source}")
+        
+        # Ensure latency is positive
+        if self.latency < 0:
+            raise ValueError(f"Latency cannot be negative, got {self.latency}")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        data = asdict(self)
+        data['timestamp'] = self.timestamp.isoformat()
+        return data
+    
+    def to_json(self) -> str:
+        """Convert to JSON string"""
+        return json.dumps(self.to_dict(), ensure_ascii=False, indent=2)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ChatResponse':
+        """Create ChatResponse from dictionary"""
+        data['timestamp'] = datetime.fromisoformat(data['timestamp'])
+        return cls(**data)
+    
+    def get_quality_label(self) -> str:
+        """Get human-readable quality label"""
+        if self.confidence >= 0.90:
+            return "Excellent"
+        elif self.confidence >= 0.80:
+            return "High"
+        elif self.confidence >= 0.65:
+            return "Medium"
+        elif self.confidence >= 0.50:
+            return "Low"
+        else:
+            return "Very Low"
+    
+    def is_fast(self, threshold_ms: float = 1000.0) -> bool:
+        """Check if response was fast (< threshold)"""
+        return self.latency < threshold_ms
+    
+    def __str__(self) -> str:
+        """Human-readable string representation"""
+        return (
+            f"ChatResponse(text_length={len(self.text)}, "
+            f"confidence={self.confidence:.2f}, "
+            f"source={self.source}, "
+            f"latency={self.latency:.0f}ms, "
+            f"quality={self.get_quality_label()})"
+        )
+
+
+class ResponseMetricsAnalyzer:
+    """Analyzes and aggregates response metrics over time"""
+    
+    def __init__(self):
+        self.metrics_history: List[ChatResponse] = []
+    
+    def add_metric(self, response: ChatResponse) -> None:
+        """Add a response metric to history"""
+        self.metrics_history.append(response)
+    
+    def get_average_latency(self, last_n: Optional[int] = None) -> float:
+        """Calculate average latency for last N responses"""
+        metrics = self.metrics_history[-last_n:] if last_n else self.metrics_history
+        if not metrics:
+            return 0.0
+        return sum(m.latency for m in metrics) / len(metrics)
+    
+    def get_average_confidence(self, last_n: Optional[int] = None) -> float:
+        """Calculate average confidence for last N responses"""
+        metrics = self.metrics_history[-last_n:] if last_n else self.metrics_history
+        if not metrics:
+            return 0.0
+        return sum(m.confidence for m in metrics) / len(metrics)
+    
+    def get_kb_usage_rate(self, last_n: Optional[int] = None) -> float:
+        """Calculate knowledge base usage rate (0.0-1.0)"""
+        metrics = self.metrics_history[-last_n:] if last_n else self.metrics_history
+        if not metrics:
+            return 0.0
+        kb_used = sum(1 for m in metrics if m.kb_results_count > 0)
+        return kb_used / len(metrics)
+    
+    def get_source_distribution(self, last_n: Optional[int] = None) -> Dict[str, int]:
+        """Get distribution of response sources"""
+        metrics = self.metrics_history[-last_n:] if last_n else self.metrics_history
+        distribution = {}
+        for metric in metrics:
+            distribution[metric.source] = distribution.get(metric.source, 0) + 1
+        return distribution
+    
+    def get_summary(self, last_n: Optional[int] = None) -> Dict[str, Any]:
+        """Get comprehensive metrics summary"""
+        metrics = self.metrics_history[-last_n:] if last_n else self.metrics_history
+        
+        if not metrics:
+            return {
+                "total_responses": 0,
+                "avg_latency_ms": 0.0,
+                "avg_confidence": 0.0,
+                "kb_usage_rate": 0.0,
+                "source_distribution": {},
+                "fast_response_rate": 0.0
+            }
+        
+        fast_responses = sum(1 for m in metrics if m.is_fast())
+        
+        return {
+            "total_responses": len(metrics),
+            "avg_latency_ms": round(self.get_average_latency(last_n), 2),
+            "avg_confidence": round(self.get_average_confidence(last_n), 3),
+            "kb_usage_rate": round(self.get_kb_usage_rate(last_n), 3),
+            "source_distribution": self.get_source_distribution(last_n),
+            "fast_response_rate": round(fast_responses / len(metrics), 3),
+            "quality_distribution": self._get_quality_distribution(metrics)
+        }
+    
+    def _get_quality_distribution(self, metrics: List[ChatResponse]) -> Dict[str, int]:
+        """Get distribution of quality labels"""
+        distribution = {}
+        for metric in metrics:
+            quality = metric.get_quality_label()
+            distribution[quality] = distribution.get(quality, 0) + 1
+        return distribution
+    
+    def clear_history(self) -> None:
+        """Clear all metrics history"""
+        self.metrics_history.clear()
+
+
+def calculate_confidence(
+    kb_results_count: int,
+    temperature: float,
+    used_memory: bool,
+    response_length: int
+) -> float:
+    """
+    Calculate confidence score based on multiple factors
+    
+    Args:
+        kb_results_count: Number of KB results used
+        temperature: Model temperature setting
+        used_memory: Whether conversation memory was used
+        response_length: Length of response in characters
+        
+    Returns:
+        Confidence score between 0.0 and 1.0
+    """
+    base_confidence = 0.50
+    
+    # KB contribution (0-0.35)
+    if kb_results_count > 0:
+        kb_boost = min(0.35, 0.10 + (kb_results_count * 0.05))
+        base_confidence += kb_boost
+    
+    # Memory contribution (0-0.10)
+    if used_memory:
+        base_confidence += 0.10
+    
+    # Temperature factor (lower temp = higher confidence)
+    # Temperature usually 0.0-1.0, we give 0-0.15 boost
+    temp_factor = (1.0 - min(temperature, 1.0)) * 0.15
+    base_confidence += temp_factor
+    
+    # Response length factor (very short = lower confidence)
+    # Penalize very short responses (< 20 chars)
+    if response_length < 20:
+        base_confidence *= 0.8
+    elif response_length < 50:
+        base_confidence *= 0.9
+    
+    # Ensure confidence stays in valid range
+    return max(0.0, min(1.0, base_confidence))
+