claude-self-reflect 3.2.4 → 3.3.0

package/mcp-server/src/decay_manager.py

@@ -0,0 +1,106 @@
+"""Decay calculation manager for Claude Self-Reflect MCP server."""
+
+import math
+from datetime import datetime, timezone
+from typing import List, Tuple, Optional
+try:
+    from .config import (
+        USE_DECAY,
+        DECAY_SCALE_DAYS,
+        DECAY_WEIGHT,
+        USE_NATIVE_DECAY,
+        logger
+    )
+except ImportError:
+    # Fallback for direct execution
+    import os
+    import logging
+    USE_DECAY = os.getenv('USE_DECAY', 'false').lower() == 'true'
+    DECAY_SCALE_DAYS = float(os.getenv('DECAY_SCALE_DAYS', '90'))
+    DECAY_WEIGHT = float(os.getenv('DECAY_WEIGHT', '0.3'))
+    USE_NATIVE_DECAY = os.getenv('USE_NATIVE_DECAY', 'false').lower() == 'true'
+    logger = logging.getLogger(__name__)
+
+class DecayManager:
+    """Manages memory decay calculations for search results."""
+    
+    def __init__(self):
+        self.scale_ms = DECAY_SCALE_DAYS * 24 * 60 * 60 * 1000
+        self.weight = DECAY_WEIGHT
+        self.use_decay = USE_DECAY
+        self.use_native = USE_NATIVE_DECAY
+    
+    def calculate_decay_score(
+        self, 
+        base_score: float, 
+        timestamp: str
+    ) -> float:
+        """Calculate decayed score for a single result."""
+        if not self.use_decay:
+            return base_score
+        
+        try:
+            # Parse timestamp
+            if timestamp.endswith('Z'):
+                timestamp = timestamp.replace('Z', '+00:00')
+            
+            result_time = datetime.fromisoformat(timestamp)
+            if result_time.tzinfo is None:
+                result_time = result_time.replace(tzinfo=timezone.utc)
+            
+            # Calculate age
+            now = datetime.now(timezone.utc)
+            age_ms = (now - result_time).total_seconds() * 1000
+            
+            # Calculate decay factor using half-life formula
+            # decay = exp(-ln(2) * age / half_life)
+            decay_factor = math.exp(-0.693147 * age_ms / self.scale_ms)
+            
+            # Apply decay with weight
+            final_score = base_score * (1 - self.weight) + base_score * self.weight * decay_factor
+            
+            return final_score
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate decay: {e}")
+            return base_score
+    
+    def apply_decay_to_results(
+        self, 
+        results: List[Tuple[float, str, dict]]
+    ) -> List[Tuple[float, str, dict]]:
+        """Apply decay to a list of results and re-sort."""
+        if not self.use_decay:
+            return results
+        
+        decayed_results = []
+        for score, id_str, payload in results:
+            timestamp = payload.get('timestamp', datetime.now().isoformat())
+            decayed_score = self.calculate_decay_score(score, timestamp)
+            decayed_results.append((decayed_score, id_str, payload))
+        
+        # Re-sort by decayed score
+        decayed_results.sort(key=lambda x: x[0], reverse=True)
+        
+        return decayed_results
+    
+    def get_native_decay_config(self) -> Optional[dict]:
+        """Get configuration for native Qdrant decay."""
+        if not self.use_native:
+            return None
+        
+        return {
+            'scale_seconds': self.scale_ms / 1000,
+            'weight': self.weight,
+            'midpoint': 0.5  # Half-life semantics
+        }
+    
+    def should_use_decay(self, explicit_setting: Optional[int] = None) -> bool:
+        """Determine if decay should be used for a query."""
+        if explicit_setting is not None:
+            if explicit_setting == 1:
+                return True
+            elif explicit_setting == 0:
+                return False
+        
+        return self.use_decay

package/mcp-server/src/embedding_manager.py

@@ -16,16 +16,16 @@ class EmbeddingManager:
     """Manages embedding models with proper cache and lock handling."""
     
     def __init__(self):
-        self.model = None
-        self.model_type = None  # 'local' or 'voyage'
+        self.local_model = None
         self.voyage_client = None
-        
+        self.model_type = None  # Default model type ('local' or 'voyage')
+
         # Configuration
         self.prefer_local = os.getenv('PREFER_LOCAL_EMBEDDINGS', 'true').lower() == 'true'
         self.voyage_key = os.getenv('VOYAGE_KEY') or os.getenv('VOYAGE_KEY-2')
         self.embedding_model = os.getenv('EMBEDDING_MODEL', 'sentence-transformers/all-MiniLM-L6-v2')
         self.download_timeout = int(os.getenv('FASTEMBED_DOWNLOAD_TIMEOUT', '30'))
-        
+
         # Set cache directory to our controlled location
         self.cache_dir = Path(__file__).parent.parent / '.fastembed-cache'
         
@@ -50,27 +50,35 @@ class EmbeddingManager:
                 logger.warning(f"Error cleaning locks: {e}")
         
     def initialize(self) -> bool:
-        """Initialize embedding model based on user preference."""
-        logger.info("Initializing embedding manager...")
-        
+        """Initialize BOTH embedding models to support mixed collections."""
+        logger.info("Initializing embedding manager for dual-mode support...")
+
         # Clean up any stale locks first
         self._clean_stale_locks()
-        
-        if self.prefer_local:
-            # User wants local - try local only, don't fallback to cloud
-            if self._try_initialize_local():
-                return True
-            logger.error("Local embeddings failed and user prefers local - not falling back to cloud")
-            return False
+
+        # Initialize both models for mixed collection support
+        local_success = self._try_initialize_local()
+        voyage_success = False
+
+        if self.voyage_key:
+            voyage_success = self._try_initialize_voyage()
+
+        # Set default model type based on preference and availability
+        if self.prefer_local and local_success:
+            self.model_type = 'local'
+            logger.info("Default model set to LOCAL embeddings")
+        elif voyage_success:
+            self.model_type = 'voyage'
+            logger.info("Default model set to VOYAGE embeddings")
+        elif local_success:
+            self.model_type = 'local'
+            logger.info("Default model set to LOCAL embeddings (fallback)")
         else:
-            # User prefers Voyage AI
-            if self.voyage_key and self._try_initialize_voyage():
-                return True
-            logger.warning("Voyage AI failed, trying local as fallback...")
-            if self._try_initialize_local():
-                return True
-            logger.error("Both Voyage AI and local embeddings failed")
+            logger.error("Failed to initialize any embedding model")
             return False
+
+        logger.info(f"Embedding models available - Local: {local_success}, Voyage: {voyage_success}")
+        return True
     
     def _try_initialize_local(self) -> bool:
         """Try to initialize local FastEmbed model with timeout and optimizations."""
@@ -119,11 +127,10 @@ class EmbeddingManager:
                     from fastembed import TextEmbedding
                     # Initialize with optimized settings
                     # Note: FastEmbed uses these environment variables internally
-                    self.model = TextEmbedding(
+                    self.local_model = TextEmbedding(
                         model_name=self.embedding_model,
                         threads=1  # Single thread per worker to prevent over-subscription
                     )
-                    self.model_type = 'local'
                     success = True
                     logger.info(f"Successfully initialized local model: {self.embedding_model} with single-thread mode")
                 except Exception as e:
@@ -177,39 +184,48 @@ class EmbeddingManager:
             logger.error(f"Failed to initialize Voyage AI: {e}")
             return False
     
-    def embed(self, texts: Union[str, List[str]], input_type: str = "document") -> Optional[List[List[float]]]:
-        """Generate embeddings using the active model."""
-        if not self.model and not self.voyage_client:
-            logger.error("No embedding model initialized")
+    def embed(self, texts: Union[str, List[str]], input_type: str = "document", force_type: str = None) -> Optional[List[List[float]]]:
+        """Generate embeddings using the specified or default model."""
+        # Determine which model to use
+        use_type = force_type if force_type else self.model_type
+        logger.debug(f"Embedding with: force_type={force_type}, self.model_type={self.model_type}, use_type={use_type}")
+
+        if use_type == 'local' and not self.local_model:
+            logger.error("Local model not initialized")
             return None
-        
+        elif use_type == 'voyage' and not self.voyage_client:
+            logger.error("Voyage client not initialized")
+            return None
+
         # Ensure texts is a list
         if isinstance(texts, str):
             texts = [texts]
-        
+
         try:
-            if self.model_type == 'local':
+            if use_type == 'local':
                 # FastEmbed returns a generator, convert to list
-                embeddings = list(self.model.embed(texts))
+                embeddings = list(self.local_model.embed(texts))
                 return [emb.tolist() for emb in embeddings]
-            
-            elif self.model_type == 'voyage':
+
+            elif use_type == 'voyage':
+                # Always use voyage-3 for consistency with collection dimensions (1024)
                 result = self.voyage_client.embed(
                     texts=texts,
-                    model="voyage-3-lite" if input_type == "query" else "voyage-3",
+                    model="voyage-3",
                     input_type=input_type
                 )
                 return result.embeddings
-            
+
         except Exception as e:
-            logger.error(f"Error generating embeddings: {e}")
+            logger.error(f"Error generating embeddings with {use_type}: {e}")
             return None
     
-    def get_vector_dimension(self) -> int:
-        """Get the dimension of embeddings."""
-        if self.model_type == 'local':
+    def get_vector_dimension(self, force_type: str = None) -> int:
+        """Get the dimension of embeddings for a specific type."""
+        use_type = force_type if force_type else self.model_type
+        if use_type == 'local':
             return 384  # all-MiniLM-L6-v2 dimension
-        elif self.model_type == 'voyage':
+        elif use_type == 'voyage':
             return 1024  # voyage-3 dimension
         return 0
     
@@ -222,6 +238,14 @@ class EmbeddingManager:
             'prefer_local': self.prefer_local,
             'has_voyage_key': bool(self.voyage_key)
         }
+    
+    async def generate_embedding(self, text: str, force_type: str = None) -> Optional[List[float]]:
+        """Generate embedding for a single text (async wrapper for compatibility)."""
+        # Use the force_type if specified, otherwise use default
+        result = self.embed(text, input_type="query", force_type=force_type)
+        if result and len(result) > 0:
+            return result[0]
+        return None
 
 
 # Global instance

package/mcp-server/src/embeddings_old.py

@@ -0,0 +1,141 @@
+"""Embedding generation module for Claude Self-Reflect MCP server."""
+
+import os
+import voyageai
+from typing import Dict, List, Optional, Any
+from fastembed import TextEmbedding
+from config import (
+    VOYAGE_API_KEY, 
+    VOYAGE_MODEL, 
+    LOCAL_MODEL,
+    PREFER_LOCAL_EMBEDDINGS,
+    logger
+)
+
+class EmbeddingManager:
+    """Manages embedding generation for both local and Voyage AI models."""
+    
+    def __init__(self):
+        self.local_model = None
+        self.voyage_client = None
+        self.embedding_cache = {}
+        
+        # Initialize based on preference
+        if PREFER_LOCAL_EMBEDDINGS or not VOYAGE_API_KEY:
+            self._init_local_model()
+        
+        if VOYAGE_API_KEY:
+            self._init_voyage_client()
+    
+    def _init_local_model(self):
+        """Initialize local FastEmbed model."""
+        try:
+            self.local_model = TextEmbedding(
+                model_name=LOCAL_MODEL,
+                cache_dir=str(os.path.expanduser("~/.cache/fastembed"))
+            )
+            logger.info(f"Initialized local embedding model: {LOCAL_MODEL}")
+        except Exception as e:
+            logger.error(f"Failed to initialize local model: {e}")
+    
+    def _init_voyage_client(self):
+        """Initialize Voyage AI client."""
+        try:
+            self.voyage_client = voyageai.Client(api_key=VOYAGE_API_KEY)
+            logger.info("Initialized Voyage AI client")
+        except Exception as e:
+            logger.error(f"Failed to initialize Voyage client: {e}")
+    
+    async def generate_embedding(
+        self, 
+        text: str, 
+        embedding_type: Optional[str] = None
+    ) -> Optional[List[float]]:
+        """Generate embedding for text using specified or default model."""
+        
+        # Use cache if available
+        cache_key = f"{embedding_type or 'default'}:{text[:100]}"
+        if cache_key in self.embedding_cache:
+            return self.embedding_cache[cache_key]
+        
+        # Determine which model to use
+        use_local = True
+        if embedding_type:
+            use_local = 'local' in embedding_type
+        elif not PREFER_LOCAL_EMBEDDINGS and self.voyage_client:
+            use_local = False
+        
+        try:
+            if use_local and self.local_model:
+                # Generate local embedding
+                embeddings = list(self.local_model.embed([text]))
+                if embeddings:
+                    embedding = list(embeddings[0])
+                    self.embedding_cache[cache_key] = embedding
+                    return embedding
+            
+            elif self.voyage_client:
+                # Generate Voyage embedding
+                result = self.voyage_client.embed(
+                    [text], 
+                    model=VOYAGE_MODEL,
+                    input_type="document"
+                )
+                if result.embeddings:
+                    embedding = result.embeddings[0]
+                    self.embedding_cache[cache_key] = embedding
+                    return embedding
+            
+        except Exception as e:
+            logger.error(f"Failed to generate embedding: {e}")
+        
+        return None
+    
+    async def generate_embeddings_batch(
+        self, 
+        texts: List[str], 
+        embedding_type: Optional[str] = None
+    ) -> Dict[str, List[float]]:
+        """Generate embeddings for multiple texts efficiently."""
+        results = {}
+        
+        # Determine which model to use
+        use_local = True
+        if embedding_type:
+            use_local = 'local' in embedding_type
+        elif not PREFER_LOCAL_EMBEDDINGS and self.voyage_client:
+            use_local = False
+        
+        try:
+            if use_local and self.local_model:
+                # Batch process with local model
+                embeddings = list(self.local_model.embed(texts))
+                for text, embedding in zip(texts, embeddings):
+                    results[text] = list(embedding)
+            
+            elif self.voyage_client:
+                # Batch process with Voyage
+                result = self.voyage_client.embed(
+                    texts,
+                    model=VOYAGE_MODEL,
+                    input_type="document"
+                )
+                for text, embedding in zip(texts, result.embeddings):
+                    results[text] = embedding
+        
+        except Exception as e:
+            logger.error(f"Failed to generate batch embeddings: {e}")
+        
+        return results
+    
+    def get_embedding_dimension(self, embedding_type: str = "local") -> int:
+        """Get the dimension of embeddings for a given type."""
+        if "local" in embedding_type:
+            return 384  # all-MiniLM-L6-v2 dimension
+        else:
+            return 1024  # voyage-3-lite dimension
+    
+    def clear_cache(self):
+        """Clear the embedding cache."""
+        self.embedding_cache.clear()
+        logger.info("Cleared embedding cache")

package/mcp-server/src/models.py

@@ -0,0 +1,64 @@
+"""Pydantic models for Claude Self-Reflect MCP server."""
+
+from typing import Optional, List, Dict, Any, Set
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+class SearchResult(BaseModel):
+    """Model for search results."""
+    id: str
+    score: float
+    timestamp: str
+    role: str
+    excerpt: str
+    project_name: str
+    conversation_id: Optional[str] = None
+    base_conversation_id: Optional[str] = None
+    collection_name: str
+    raw_payload: Optional[Dict[str, Any]] = None
+    code_patterns: Optional[Dict[str, List[str]]] = None
+    files_analyzed: Optional[List[str]] = None
+    files_edited: Optional[List[str]] = None
+    tools_used: Optional[List[str]] = None
+    concepts: Optional[List[str]] = None
+
+class ConversationGroup(BaseModel):
+    """Model for grouped conversations."""
+    conversation_id: str
+    base_conversation_id: str
+    timestamp: datetime
+    message_count: int
+    excerpts: List[str]
+    files: Set[str] = Field(default_factory=set)
+    tools: Set[str] = Field(default_factory=set)
+    concepts: Set[str] = Field(default_factory=set)
+
+class WorkSession(BaseModel):
+    """Model for work sessions."""
+    start_time: datetime
+    end_time: datetime
+    conversations: List[ConversationGroup]
+    total_messages: int
+    files_touched: Set[str] = Field(default_factory=set)
+    tools_used: Set[str] = Field(default_factory=set)
+    concepts: Set[str] = Field(default_factory=set)
+
+class ActivityStats(BaseModel):
+    """Model for activity statistics."""
+    total_conversations: int
+    total_messages: int
+    unique_files: int
+    unique_tools: int
+    peak_hour: Optional[str] = None
+    peak_day: Optional[str] = None
+
+class TimelineEntry(BaseModel):
+    """Model for timeline entries."""
+    period: str
+    start_time: datetime
+    end_time: datetime
+    conversation_count: int
+    message_count: int
+    files: Set[str] = Field(default_factory=set)
+    tools: Set[str] = Field(default_factory=set)
+    concepts: Set[str] = Field(default_factory=set)