claude-self-reflect 2.4.0 → 2.4.2

package/mcp-server/run-mcp-docker.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Run the MCP server in the Docker container with stdin attached
+# Using python -u for unbuffered output
+# Using server.py which supports local embeddings (not server_v2.py)
+docker exec -i claude-reflection-mcp python -u -m src

package/mcp-server/src/__main__.py

@@ -17,7 +17,8 @@ def main():
     from .server import mcp
     
     # Run the server with the specified transport
-    mcp.run(transport=args.transport)
+    # Disable FastMCP banner to prevent JSON output interference
+    mcp.run(transport=args.transport, show_banner=False)
 
 if __name__ == "__main__":
     main()

package/mcp-server/src/server.py

@@ -12,10 +12,24 @@ from fastmcp import FastMCP, Context
 from pydantic import BaseModel, Field
 from qdrant_client import AsyncQdrantClient, models
 from qdrant_client.models import (
-    PointStruct, VectorParams, Distance, 
-    FormulaQuery, DecayParamsExpression, SumExpression,
-    DatetimeExpression, DatetimeKeyExpression
+    PointStruct, VectorParams, Distance
 )
+
+# Try to import newer Qdrant API for native decay
+try:
+    from qdrant_client.models import (
+        Query, Formula, Expression, MultExpression,
+        ExpDecayExpression, DecayParamsExpression,
+        SearchRequest, NamedQuery
+    )
+    NATIVE_DECAY_AVAILABLE = True
+except ImportError:
+    # Fall back to older API
+    from qdrant_client.models import (
+        FormulaQuery, DecayParamsExpression, SumExpression,
+        DatetimeExpression, DatetimeKeyExpression
+    )
+    NATIVE_DECAY_AVAILABLE = False
 import voyageai
 from dotenv import load_dotenv
 
@@ -176,11 +190,56 @@ async def reflect_on_past(
         # Search each collection
         for collection_name in all_collections:
             try:
-                if should_use_decay and USE_NATIVE_DECAY:
-                    # Use native Qdrant decay
-                    await ctx.debug(f"Using NATIVE Qdrant decay for {collection_name}")
+                if should_use_decay and USE_NATIVE_DECAY and NATIVE_DECAY_AVAILABLE:
+                    # Use native Qdrant decay with newer API
+                    await ctx.debug(f"Using NATIVE Qdrant decay (new API) for {collection_name}")
+                    
+                    # Build the query with native Qdrant decay formula using newer API
+                    query_obj = Query(
+                        nearest=query_embedding,
+                        formula=Formula(
+                            sum=[
+                                # Original similarity score
+                                Expression(variable="score"),
+                                # Decay boost term
+                                Expression(
+                                    mult=MultExpression(
+                                        mult=[
+                                            # Decay weight
+                                            Expression(constant=DECAY_WEIGHT),
+                                            # Exponential decay function
+                                            Expression(
+                                                exp_decay=DecayParamsExpression(
+                                                    # Use timestamp field for decay
+                                                    x=Expression(datetime_key="timestamp"),
+                                                    # Decay from current time (server-side)
+                                                    target=Expression(datetime="now"),
+                                                    # Scale in milliseconds
+                                                    scale=DECAY_SCALE_DAYS * 24 * 60 * 60 * 1000,
+                                                    # Standard exponential decay midpoint
+                                                    midpoint=0.5
+                                                )
+                                            )
+                                        ]
+                                    )
+                                )
+                            ]
+                        )
+                    )
+                    
+                    # Execute query with native decay (new API)
+                    results = await qdrant_client.query_points(
+                        collection_name=collection_name,
+                        query=query_obj,
+                        limit=limit,
+                        score_threshold=min_score,
+                        with_payload=True
+                    )
+                elif should_use_decay and USE_NATIVE_DECAY and not NATIVE_DECAY_AVAILABLE:
+                    # Use native Qdrant decay with older API
+                    await ctx.debug(f"Using NATIVE Qdrant decay (legacy API) for {collection_name}")
                     
-                    # Build the query with native Qdrant decay formula
+                    # Build the query with native Qdrant decay formula using older API
                     query_obj = FormulaQuery(
                         nearest=query_embedding,
                         formula=SumExpression(

package/mcp-server/src/server_v2.py

@@ -42,11 +42,11 @@ DECAY_SCALE_DAYS = float(os.getenv('DECAY_SCALE_DAYS', '90'))
 # Initialize Voyage AI client
 voyage_client = voyageai.Client(api_key=VOYAGE_API_KEY) if VOYAGE_API_KEY else None
 
-# Debug environment loading
-print(f"[DEBUG] Qdrant Native Decay Server v2.0.0")
-print(f"[DEBUG] ENABLE_MEMORY_DECAY: {ENABLE_MEMORY_DECAY}")
-print(f"[DEBUG] DECAY_WEIGHT: {DECAY_WEIGHT}")
-print(f"[DEBUG] DECAY_SCALE_DAYS: {DECAY_SCALE_DAYS}")
+# Debug environment loading (disabled for production)
+# print(f"[DEBUG] Qdrant Native Decay Server v2.0.0")
+# print(f"[DEBUG] ENABLE_MEMORY_DECAY: {ENABLE_MEMORY_DECAY}")
+# print(f"[DEBUG] DECAY_WEIGHT: {DECAY_WEIGHT}")
+# print(f"[DEBUG] DECAY_SCALE_DAYS: {DECAY_SCALE_DAYS}")
 
 
 class SearchResult(BaseModel):
@@ -246,5 +246,9 @@ async def store_reflection(
         return f"Failed to store reflection: {str(e)}"
 
 
-# Debug output
-print(f"[DEBUG] FastMCP server v2.0.0 created with native Qdrant decay")
+# Debug output (disabled for production)
+# print(f"[DEBUG] FastMCP server v2.0.0 created with native Qdrant decay")
+
+# Run the server when executed as main module
+if __name__ == "__main__":
+    mcp.run(transport="stdio", show_banner=False)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",
@@ -32,8 +32,12 @@
     "mcp-server/src/**/*.py",
     "mcp-server/pyproject.toml",
     "mcp-server/run-mcp.sh",
+    "mcp-server/run-mcp-docker.sh",
     "scripts/import-*.py",
     ".claude/agents/*.md",
+    "docker-compose.yaml",
+    "Dockerfile.*",
+    ".env.example",
     "README.md",
     "LICENSE"
   ],

package/scripts/import-conversations-unified.py

@@ -19,6 +19,12 @@ from qdrant_client.models import (
     Filter, FieldCondition, MatchValue
 )
 
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential,
+)
+
 # Configuration
 QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
 LOGS_DIR = os.getenv("LOGS_DIR", "/logs")
@@ -54,6 +60,15 @@ else:
 # Initialize Qdrant client
 client = QdrantClient(url=QDRANT_URL)
 
+
+def log_retry_state(retry_state):
+    print(f"Retrying function '{retry_state.fn.__name__}' for the {retry_state.attempt_number} time.")
+    print(f"----> Waiting for {retry_state.next_action.sleep} seconds before next attempt.")
+
+@retry(wait=wait_random_exponential(multiplier=2, min=30, max=120), stop=stop_after_attempt(6), before_sleep=log_retry_state)
+def embed_with_backoff(**kwargs):
+    return voyage_client.embed(**kwargs)
+
 def generate_embeddings(texts: List[str]) -> List[List[float]]:
     """Generate embeddings for a list of texts."""
     if PREFER_LOCAL_EMBEDDINGS or not VOYAGE_API_KEY:
@@ -62,7 +77,7 @@ def generate_embeddings(texts: List[str]) -> List[List[float]]:
         return [embedding.tolist() for embedding in embeddings]
     else:
         # Voyage AI embeddings
-        result = voyage_client.embed(
+        result = embed_with_backoff(
             texts=texts,
             model="voyage-3-large",
             input_type="document"