Merge pull request #33 from raold/feature/multimodal-local-embeddings

Feature/multimodal local embeddings

Author: raold

.claude/settings.local.json

@@ -88,7 +88,9 @@
       "Bash(taskkill:*)",
       "Bash(timeout 30 python llava/llava_api.py)",
       "Bash(cmd.exe:*)",
-      "WebFetch(domain:huggingface.co)"
+      "WebFetch(domain:huggingface.co)",
+      "Bash(git mv:*)",
+      "Bash(sed:*)"
     ],
     "deny": []
   }

.gitignore

@@ -151,4 +151,5 @@ temp/
 # !Makefile
 # !README.md
 # !LICENSE
-# !DIRECTORY_STRUCTURE.md
+# !DIRECTORY_STRUCTURE.mdgoogle_credentials.json
+google_credentials.json

app/adapters/cipher_adapter.py

@@ -8,23 +8,20 @@
 Note: This is an OPTIONAL component. Second Brain works perfectly without Cipher.
 """
 
-import asyncio
-import json
 from datetime import datetime
-from typing import List, Dict, Any, Optional
+from typing import Any, Dict, List, Optional
+
 import httpx
-from pathlib import Path
 
+from app.core.logging import get_logger
 from app.interfaces.sync_provider import (
-    ISyncProvider, 
-    SyncProviderConfig, 
-    SyncResult, 
-    SyncStatus,
+    ConflictResolution,
     HealthStatus,
-    ConflictResolution
+    ISyncProvider,
+    SyncProviderConfig,
+    SyncResult,
+    SyncStatus,
 )
-from app.core.logging import get_logger
-from app.models.memory import Memory
 
 logger = get_logger(__name__)
 
@@ -41,130 +38,130 @@ class CipherAdapter(ISyncProvider):
     
     This adapter enables bi-directional sync between Second Brain and Cipher.
     """
-    
+
     def __init__(self, config: SyncProviderConfig):
         super().__init__(config)
         self.client: Optional[httpx.AsyncClient] = None
         self.mcp_socket: Optional[Any] = None  # MCP WebSocket connection
-        
+
         # Cipher-specific settings
         self.cipher_url = config.custom_settings.get(
-            "cipher_url", 
+            "cipher_url",
             "http://localhost:3000"  # Default Cipher server
         )
         self.api_key = config.custom_settings.get("api_key")
         self.workspace_id = config.custom_settings.get("workspace_id")
         self.enable_mcp = config.custom_settings.get("enable_mcp", True)
-    
+
     @property
     def name(self) -> str:
         return "cipher"
-    
+
     async def connect(self) -> None:
         """Connect to Cipher server"""
         try:
             # Create HTTP client
             headers = {}
             if self.api_key:
                 headers["Authorization"] = f"Bearer {self.api_key}"
-                
+
             self.client = httpx.AsyncClient(
                 base_url=self.cipher_url,
                 headers=headers,
                 timeout=self.config.timeout
             )
-            
+
             # Test connection
             response = await self.client.get("/health")
             response.raise_for_status()
-            
+
             # Connect to MCP WebSocket if enabled
             if self.enable_mcp:
                 await self._connect_mcp()
-            
+
             self._connected = True
             logger.info(f"Connected to Cipher at {self.cipher_url}")
-            
+
         except Exception as e:
             logger.error(f"Failed to connect to Cipher: {e}")
             raise ConnectionError(f"Cannot connect to Cipher: {e}")
-    
+
     async def _connect_mcp(self) -> None:
         """Connect to Cipher's MCP WebSocket for real-time sync"""
         # MCP connection implementation would go here
         # This is a placeholder for the actual MCP protocol implementation
         logger.info("MCP connection initialized (placeholder)")
-    
+
     async def disconnect(self) -> None:
         """Disconnect from Cipher"""
         if self.client:
             await self.client.aclose()
             self.client = None
-            
+
         if self.mcp_socket:
             # Close MCP WebSocket
             pass
-            
+
         self._connected = False
         logger.info("Disconnected from Cipher")
-    
+
     async def push_memory(self, memory: Dict[str, Any]) -> bool:
         """Push a single memory to Cipher"""
         if not self.should_sync(memory):
             return True
-            
+
         try:
             # Transform to Cipher format
             cipher_memory = self._to_cipher_format(memory)
-            
+
             # Determine which system (1 or 2) based on memory type
             endpoint = "/api/memories"
             if memory.get("type") == "reasoning":
                 endpoint = "/api/reasoning"
-            
+
             response = await self.client.post(
                 endpoint,
                 json=cipher_memory
             )
             response.raise_for_status()
-            
+
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to push memory to Cipher: {e}")
             return False
-    
+
     async def push_batch(self, memories: List[Dict[str, Any]]) -> SyncResult:
         """Push multiple memories to Cipher"""
         result = SyncResult(status=SyncStatus.SUCCESS)
-        
+
         # Filter memories
         memories_to_sync = [m for m in memories if self.should_sync(m)]
-        
+
         # Split into batches
         for i in range(0, len(memories_to_sync), self.config.batch_size):
             batch = memories_to_sync[i:i + self.config.batch_size]
-            
+
             try:
                 # Transform batch
                 cipher_batch = [self._to_cipher_format(m) for m in batch]
-                
+
                 # Bulk upload
                 response = await self.client.post(
                     "/api/memories/bulk",
                     json={"memories": cipher_batch}
                 )
                 response.raise_for_status()
-                
+
                 result.pushed += len(batch)
-                
+
             except Exception as e:
                 logger.error(f"Failed to push batch to Cipher: {e}")
                 result.errors.append(str(e))
                 result.status = SyncStatus.PARTIAL
-        
+
         return result
-    
+
     async def pull_changes(self, since: Optional[datetime] = None) -> List[Dict[str, Any]]:
         """Pull changes from Cipher"""
         try:
@@ -173,30 +170,30 @@ async def pull_changes(self, since: Optional[datetime] = None) -> List[Dict[str,
                 params["since"] = since.isoformat()
             if self.workspace_id:
                 params["workspace_id"] = self.workspace_id
-            
+
             response = await self.client.get(
                 "/api/memories/changes",
                 params=params
             )
             response.raise_for_status()
-            
+
             cipher_memories = response.json().get("memories", [])
-            
+
             # Transform from Cipher format
             return [self._from_cipher_format(m) for m in cipher_memories]
-            
+
         except Exception as e:
             logger.error(f"Failed to pull changes from Cipher: {e}")
             return []
-    
+
     async def resolve_conflict(
-        self, 
-        local: Dict[str, Any], 
+        self,
+        local: Dict[str, Any],
         remote: Dict[str, Any]
     ) -> Dict[str, Any]:
         """Resolve conflicts between local and remote memories"""
         strategy = self.config.conflict_resolution
-        
+
         if strategy == ConflictResolution.LOCAL_WINS:
             return local
         elif strategy == ConflictResolution.REMOTE_WINS:
@@ -211,22 +208,22 @@ async def resolve_conflict(
             return local if local_updated >= remote_updated else remote
         else:
             # Manual resolution - for now, default to local
-            logger.warning(f"Manual conflict resolution not implemented, using local")
+            logger.warning("Manual conflict resolution not implemented, using local")
             return local
-    
+
     async def health_check(self) -> HealthStatus:
         """Check Cipher connection health"""
         if not self._connected:
             return HealthStatus(
                 healthy=False,
                 error_message="Not connected"
             )
-        
+
         try:
             start = datetime.now()
             response = await self.client.get("/health")
             latency_ms = (datetime.now() - start).total_seconds() * 1000
-            
+
             if response.status_code == 200:
                 data = response.json()
                 return HealthStatus(
@@ -240,13 +237,13 @@ async def health_check(self) -> HealthStatus:
                     healthy=False,
                     error_message=f"Health check failed: {response.status_code}"
                 )
-                
+
         except Exception as e:
             return HealthStatus(
                 healthy=False,
                 error_message=f"Health check error: {str(e)}"
             )
-    
+
     def _to_cipher_format(self, memory: Dict[str, Any]) -> Dict[str, Any]:
         """Convert Second Brain memory to Cipher format"""
         # Map our format to Cipher's expected format
@@ -262,22 +259,22 @@ def _to_cipher_format(self, memory: Dict[str, Any]) -> Dict[str, Any]:
                 "updated_at": memory.get("updated_at"),
             }
         }
-        
+
         # Add embedding if available
         if "embedding" in memory:
             cipher_memory["embedding"] = memory["embedding"]
-        
+
         # Add workspace ID if configured
         if self.workspace_id:
             cipher_memory["workspace_id"] = self.workspace_id
-        
+
         # Map specific fields based on memory type
         if memory.get("type") == "code":
             cipher_memory["language"] = memory.get("metadata", {}).get("language", "unknown")
             cipher_memory["file_path"] = memory.get("metadata", {}).get("file_path")
-        
+
         return cipher_memory
-    
+
     def _from_cipher_format(self, cipher_memory: Dict[str, Any]) -> Dict[str, Any]:
         """Convert Cipher memory to Second Brain format"""
         # Map Cipher format to our format
@@ -291,17 +288,17 @@ def _from_cipher_format(self, cipher_memory: Dict[str, Any]) -> Dict[str, Any]:
                 "synced_at": datetime.now().isoformat(),
             }
         }
-        
+
         # Preserve timestamps if available
         if "created_at" in cipher_memory:
             memory["created_at"] = cipher_memory["created_at"]
         if "updated_at" in cipher_memory:
             memory["updated_at"] = cipher_memory["updated_at"]
-        
+
         # Add embedding if available
         if "embedding" in cipher_memory:
             memory["embedding"] = cipher_memory["embedding"]
-        
+
         return memory
 
 
@@ -337,4 +334,4 @@ def create_cipher_config(
             "workspace_id": workspace_id,
             "enable_mcp": enable_mcp
         }
-    )
+    )

app/config.py

@@ -76,7 +76,7 @@ class Config:
     OTEL_EXPORTER_OTLP_ENDPOINT: str = env.get("OTEL_EXPORTER_OTLP_ENDPOINT", "")
     OTEL_SERVICE_NAME: str = env.get("OTEL_SERVICE_NAME", "second-brain")
     SENTRY_DSN: str = env.get("SENTRY_DSN", "")
-    
+
     # Cipher Integration Settings (Optional)
     CIPHER_ENABLED: bool = env.get_bool("CIPHER_ENABLED", False)
     CIPHER_URL: str = env.get("CIPHER_URL", "http://localhost:3000")
@@ -85,7 +85,7 @@ class Config:
     CIPHER_SYNC_INTERVAL: int = env.get_int("CIPHER_SYNC_INTERVAL", 300)  # 5 minutes
     CIPHER_ENABLE_MCP: bool = env.get_bool("CIPHER_ENABLE_MCP", True)
     CIPHER_CONFLICT_RESOLUTION: str = env.get(
-        "CIPHER_CONFLICT_RESOLUTION", 
+        "CIPHER_CONFLICT_RESOLUTION",
         "newest"  # Options: local, remote, newest
     )