version changes

Author: 0xrushi

backends/advanced/pyproject.toml

@@ -10,15 +10,15 @@ dependencies = [
     "fastmcp>=0.5.0", # MCP server for conversation access
     "mem0ai", # Using main branch with PR #3250 AsyncMemory fix
     "langchain_neo4j",
-    "neo4j>=5.0.0",
+    "neo4j>=5.0.0,<6.0.0",
     "motor>=3.7.1",
     "ollama>=0.4.8",
     "friend-lite-sdk",
     "python-dotenv>=1.1.0",
     "uvicorn>=0.34.2",
     "wyoming>=1.6.1",
     "aiohttp>=3.8.0",
-    "httpx>=0.28.0",
+    "httpx>=0.28.0,<1.0.0",
     "fastapi-users[beanie]>=14.0.1",
     "PyYAML>=6.0.1",
     "langfuse>=3.3.0",

backends/advanced/src/advanced_omi_backend/services/memory/config.py

@@ -9,6 +9,7 @@
 from typing import Any, Dict, Optional, Union
 
 from advanced_omi_backend.model_registry import get_models_registry
+from advanced_omi_backend.utils.config_utils import resolve_value
 
 memory_logger = logging.getLogger("memory_service")
 
@@ -24,25 +25,32 @@ def _is_langfuse_enabled() -> bool:
 
 class LLMProvider(Enum):
     """Supported LLM providers."""
+
     OPENAI = "openai"
     OLLAMA = "ollama"
     CUSTOM = "custom"
 
+
 class VectorStoreProvider(Enum):
     """Supported vector store providers."""
+
     QDRANT = "qdrant"
     WEAVIATE = "weaviate"
     CUSTOM = "custom"
 
+
 class MemoryProvider(Enum):
     """Supported memory service providers."""
-    CHRONICLE = "chronicle"            # Default sophisticated implementation
+
+    CHRONICLE = "chronicle"  # Default sophisticated implementation
     OPENMEMORY_MCP = "openmemory_mcp"  # OpenMemory MCP backend
-    MYCELIA = "mycelia"                # Mycelia memory backend
+    MYCELIA = "mycelia"  # Mycelia memory backend
+
 
 @dataclass
 class MemoryConfig:
     """Configuration for memory service."""
+
     memory_provider: MemoryProvider = MemoryProvider.CHRONICLE
     llm_provider: LLMProvider = LLMProvider.OPENAI
     vector_store_provider: VectorStoreProvider = VectorStoreProvider.QDRANT
@@ -55,21 +63,6 @@ class MemoryConfig:
     extraction_enabled: bool = True
     timeout_seconds: int = 1200
 
-# Helper to resolve ${VAR:-default}
-def resolve_value(value: Union[str, int, float]) -> Union[str, int, float]:
-    """Resolve environment variable references in configuration values.
-    
-    Supports ${VAR} and ${VAR:-default} syntax. Returns the original value
-    if it's not a string or doesn't match the pattern.
-    """
-    if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
-        content = value[2:-1]
-        if ":-" in content:
-            var_name, default_val = content.split(":-", 1)
-            return os.getenv(var_name, default_val)
-        else:
-            return os.getenv(content, "")
-    return value
 
 def load_config_yml() -> Dict[str, Any]:
     """Load config.yml from standard locations."""
@@ -78,37 +71,35 @@ def load_config_yml() -> Dict[str, Any]:
     # Path inside Docker: /app/config.yml (if mounted) or ../../../config.yml relative to src
     paths = [
         Path("/app/config.yml"),
-        current_dir.parent.parent.parent.parent.parent / "config.yml", # Relative to src/
+        current_dir.parent.parent.parent.parent.parent / "config.yml",  # Relative to src/
         Path("./config.yml"),
     ]
-    
+
     for path in paths:
         if path.exists():
-            with open(path, 'r') as f:
+            with open(path, "r") as f:
                 return yaml.safe_load(f) or {}
-                
+
     raise FileNotFoundError(f"config.yml not found in any of: {[str(p) for p in paths]}")
 
+
 def create_openmemory_config(
     server_url: str = "http://localhost:8765",
     client_name: str = "chronicle",
     user_id: str = "default",
-    timeout: int = 30
+    timeout: int = 30,
 ) -> Dict[str, Any]:
     """Create OpenMemory MCP configuration."""
     return {
         "server_url": server_url,
         "client_name": client_name,
         "user_id": user_id,
-        "timeout": timeout
+        "timeout": timeout,
     }
 
 
 def create_mycelia_config(
-    api_url: str = "http://localhost:8080",
-    api_key: str = None,
-    timeout: int = 30,
-    **kwargs
+    api_url: str = "http://localhost:8080", api_key: str = None, timeout: int = 30, **kwargs
 ) -> Dict[str, Any]:
     """Create Mycelia configuration."""
     config = {
@@ -161,7 +152,7 @@ def build_memory_config_from_env() -> MemoryConfig:
     try:
         # Determine memory provider from registry
         reg = get_models_registry()
-        mem_settings = (reg.memory if reg else {})
+        mem_settings = reg.memory if reg else {}
         memory_provider = (mem_settings.get("provider") or "chronicle").lower()
 
         # Map legacy provider names to current names
@@ -173,18 +164,20 @@ def build_memory_config_from_env() -> MemoryConfig:
             raise ValueError(f"Unsupported memory provider: {memory_provider}")
 
         memory_provider_enum = MemoryProvider(memory_provider)
-        
+
         # For OpenMemory MCP, configuration is much simpler
         if memory_provider_enum == MemoryProvider.OPENMEMORY_MCP:
-            mcp = (mem_settings.get("openmemory_mcp") or {})
+            mcp = mem_settings.get("openmemory_mcp") or {}
             openmemory_config = create_openmemory_config(
                 server_url=mcp.get("server_url", "http://localhost:8765"),
                 client_name=mcp.get("client_name", "chronicle"),
                 user_id=mcp.get("user_id", "default"),
                 timeout=int(mcp.get("timeout", 30)),
             )
 
-            memory_logger.info(f"🔧 Memory config: Provider=OpenMemory MCP, URL={openmemory_config['server_url']}")
+            memory_logger.info(
+                f"🔧 Memory config: Provider=OpenMemory MCP, URL={openmemory_config['server_url']}"
+            )
 
             return MemoryConfig(
                 memory_provider=memory_provider_enum,
@@ -195,7 +188,7 @@ def build_memory_config_from_env() -> MemoryConfig:
         # For Mycelia provider, build mycelia_config + llm_config (for temporal extraction)
         if memory_provider_enum == MemoryProvider.MYCELIA:
             # Registry-driven Mycelia configuration
-            mys = (mem_settings.get("mycelia") or {})
+            mys = mem_settings.get("mycelia") or {}
             api_url = mys.get("api_url", "http://localhost:5173")
             timeout = int(mys.get("timeout", 30))
             mycelia_config = create_mycelia_config(api_url=api_url, timeout=timeout)
@@ -210,21 +203,27 @@ def build_memory_config_from_env() -> MemoryConfig:
                         model=llm_def.model_name,
                         base_url=llm_def.model_url,
                     )
-                    memory_logger.info(f"🔧 Mycelia temporal extraction (registry): LLM={llm_def.model_name}")
+                    memory_logger.info(
+                        f"🔧 Mycelia temporal extraction (registry): LLM={llm_def.model_name}"
+                    )
             else:
-                memory_logger.warning("Registry not available for Mycelia temporal extraction; disabled")
+                memory_logger.warning(
+                    "Registry not available for Mycelia temporal extraction; disabled"
+                )
 
-            memory_logger.info(f"🔧 Memory config: Provider=Mycelia, URL={mycelia_config['api_url']}")
+            memory_logger.info(
+                f"🔧 Memory config: Provider=Mycelia, URL={mycelia_config['api_url']}"
+            )
 
             return MemoryConfig(
                 memory_provider=memory_provider_enum,
                 mycelia_config=mycelia_config,
                 llm_config=llm_config,
                 timeout_seconds=int(mem_settings.get("timeout_seconds", timeout)),
             )
-        
+
         # For Chronicle provider, use registry-driven configuration
-        
+
         # Registry-driven configuration only (no env-based branching)
         llm_config = None
         llm_provider_enum = LLMProvider.OPENAI  # OpenAI-compatible API family
@@ -236,7 +235,7 @@ def build_memory_config_from_env() -> MemoryConfig:
         if not llm_def:
             raise ValueError("No default LLM defined in config.yml")
         model = llm_def.model_name
-        embedding_model = (embed_def.model_name if embed_def else "text-embedding-3-small")
+        embedding_model = embed_def.model_name if embed_def else "text-embedding-3-small"
         base_url = llm_def.model_url
         memory_logger.info(
             f"🔧 Memory config (registry): LLM={model}, Embedding={embedding_model}, Base URL={base_url}"
@@ -267,9 +266,9 @@ def build_memory_config_from_env() -> MemoryConfig:
             embedding_dims=embedding_dims,
         )
         vector_store_provider_enum = VectorStoreProvider.QDRANT
-        
+
         # Get memory extraction settings from registry
-        extraction_cfg = (mem_settings.get("extraction") or {})
+        extraction_cfg = mem_settings.get("extraction") or {}
         extraction_enabled = bool(extraction_cfg.get("enabled", True))
         extraction_prompt = extraction_cfg.get("prompt") if extraction_enabled else None
 
@@ -291,7 +290,7 @@ def build_memory_config_from_env() -> MemoryConfig:
             extraction_enabled=extraction_enabled,
             timeout_seconds=timeout_seconds,
         )
-        
+
     except ImportError:
         memory_logger.warning("Config loader not available, using environment variables only")
         raise
@@ -302,7 +301,7 @@ def get_embedding_dims(llm_config: Dict[str, Any]) -> int:
     Query the embedding endpoint and return the embedding vector length.
     Works for OpenAI and OpenAI-compatible endpoints (e.g., Ollama).
     """
-    embedding_model = llm_config.get('embedding_model')
+    embedding_model = llm_config.get("embedding_model")
     try:
         reg = get_models_registry()
         if reg: