mycelium-ai 0.5.0__py3-none-any.whl

mycelium/config.py

@@ -0,0 +1,346 @@
+"""Configuration management for Mycelium"""
+
+import logging
+import os
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from mycelium.domain.models import MediaServerType
+
+
+def get_user_data_dir() -> Path:
+    """Get the user data directory for Mycelium (platform-specific)."""
+    if os.name == 'nt':  # Windows
+        base_dir = os.getenv('LOCALAPPDATA', os.path.expanduser('~/AppData/Local'))
+    elif os.uname().sysname == 'Darwin':  # macOS
+        base_dir = os.path.expanduser('~/Library/Application Support')
+    else:  # Linux/Unix
+        base_dir = os.getenv('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
+
+    data_dir = Path(base_dir) / 'mycelium'
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_user_log_dir() -> Path:
+    """Get the user log directory for Mycelium (platform-specific)."""
+    if os.name == 'nt':  # Windows
+        base_dir = os.getenv('LOCALAPPDATA', os.path.expanduser('~/AppData/Local'))
+    elif os.uname().sysname == 'Darwin':  # macOS
+        base_dir = os.path.expanduser('~/Library/Logs')
+    else:  # Linux/Unix
+        base_dir = os.getenv('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
+
+    log_dir = Path(base_dir) / 'mycelium'
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory for Mycelium."""
+    if os.name == 'nt':  # Windows
+        base_dir = os.getenv('APPDATA', os.path.expanduser('~/AppData/Roaming'))
+    else:  # macOS and Linux/Unix
+        base_dir = os.path.expanduser('~/.config')
+
+    config_dir = Path(base_dir) / 'mycelium'
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_config_file_path() -> Path:
+    """Get the configuration file path."""
+    return get_config_dir() / 'config.yml'
+
+
+@dataclass
+class PlexConfig:
+    """Configuration for Plex connection."""
+    url: str = "http://localhost:32400"
+    token: Optional[str] = None
+    music_library_name: str = "Music"
+
+@dataclass
+class ServerConfig:
+    """Configuration for server settings."""
+    gpu_batch_size: int = 16
+
+@dataclass
+class CLAPConfig:
+    """Configuration for CLAP model."""
+    model_id: str = "laion/larger_clap_music_and_speech"
+    target_sr: int = 48000
+    chunk_duration_s: int = 10
+    num_chunks: int = 3
+    max_load_duration_s: Optional[int] = 120
+
+@dataclass
+class MediaServerConfig:
+    """Configuration for media server."""
+    type: MediaServerType
+    
+    def __post_init__(self):
+        """Convert string type to MediaServerType enum if needed."""
+        if isinstance(self.type, str):
+            self.type = MediaServerType(self.type.lower())
+
+@dataclass
+class ChromaConfig:
+    """Configuration for ChromaDB."""
+    collection_name: str = "my_music_library"
+    batch_size: int = 1000
+
+    @staticmethod
+    def get_db_path() -> str:
+        """Get the actual database path for ChromaDB."""
+        return str(get_user_data_dir() / "music_vector_db")
+
+
+@dataclass
+class DatabaseConfig:
+    """Configuration for track metadata database."""
+
+    @staticmethod
+    def get_db_path() -> str:
+        """Get the actual database path for track metadata."""
+        return str(get_user_data_dir() / "mycelium_tracks.db")
+
+
+@dataclass
+class APIConfig:
+    """Configuration for API server."""
+    host: str = "0.0.0.0"
+    port: int = 8000
+    reload: bool = False
+
+
+@dataclass
+class LoggingConfig:
+    """Configuration for logging system."""
+    level: str = "INFO"
+    format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    file: Optional[str] = None
+
+
+@dataclass
+class MyceliumConfig:
+    """Main configuration class."""
+    server: ServerConfig
+    media_server: MediaServerConfig
+    plex: PlexConfig
+    clap: CLAPConfig
+    chroma: ChromaConfig
+    database: DatabaseConfig
+    api: APIConfig
+    logging: LoggingConfig
+
+    @classmethod
+    def load_from_yaml(cls, config_path: Optional[Path] = None) -> "MyceliumConfig":
+        """Load configuration"""
+        if config_path is None:
+            config_path = get_config_file_path()
+
+        # Load YAML config if it exists
+        config_data = {}
+        config_exists = config_path.exists()
+        if config_exists:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config_data = yaml.safe_load(f) or {}
+
+        plex_config = PlexConfig(
+            url=config_data.get("plex", {}).get("url", "http://localhost:32400"),
+            token=config_data.get("plex", {}).get("token", "replace_with_your_token"),
+            music_library_name=config_data.get("plex", {}).get("music_library_name", "Music")
+        )
+
+        server_config = ServerConfig(
+            gpu_batch_size=config_data.get("server", {}).get("gpu_batch_size", 16)
+        )
+
+        clap_config = CLAPConfig(
+            model_id=config_data.get("clap", {}).get("model_id", "laion/larger_clap_music_and_speech"),
+            target_sr=config_data.get("clap", {}).get("target_sr", 48000),
+            chunk_duration_s=config_data.get("clap", {}).get("chunk_duration_s", 10),
+            num_chunks=config_data.get("clap", {}).get("num_chunks", 3),
+            max_load_duration_s=config_data.get("clap", {}).get("max_load_duration_s", 120)
+        )
+
+        chroma_config = ChromaConfig(
+            collection_name=config_data.get("chroma", {}).get("collection_name", "my_music_library"),
+            batch_size=config_data.get("chroma", {}).get("batch_size", 1000)
+        )
+
+        media_server = MediaServerConfig(
+            type=MediaServerType[config_data.get("media_server", {}).get("type", "plex").upper()]
+        )
+
+        database_config = DatabaseConfig()
+
+        api_config = APIConfig(
+            host=config_data.get("api", {}).get("host", "0.0.0.0"),
+            port=config_data.get("api", {}).get("port", 8000),
+            reload=config_data.get("api", {}).get("reload", False)
+        )
+
+        # Handle logging configuration with default log file path
+        logging_data = config_data.get("logging", {})
+        log_file = logging_data.get("file")
+        if log_file is None:
+            log_file = str(get_user_log_dir() / "mycelium.log")
+
+        logging_config = LoggingConfig(
+            level=logging_data.get("level", "INFO"),
+            format=logging_data.get("format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"),
+            file=log_file
+        )
+
+        cfg = cls(
+            media_server=media_server,
+            plex=plex_config,
+            clap=clap_config,
+            chroma=chroma_config,
+            database=database_config,
+            api=api_config,
+            logging=logging_config,
+            server=server_config
+        )
+
+        # If no config file existed, create one with current values for convenience
+        if not config_exists:
+            # Ensure config directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                cfg.save_to_yaml(config_path)
+            except Exception:
+                # Best-effort; ignore failures to avoid blocking startup
+                pass
+
+        return cfg
+
+    def save_to_yaml(self, config_path: Optional[Path] = None) -> None:
+        """Save configuration to YAML file."""
+        if config_path is None:
+            config_path = get_config_file_path()
+
+        def custom_dict_factory(data):
+            result = []
+            for k, v in data:
+                if isinstance(v, MediaServerType):
+                    result.append((k, v.value))
+                else:
+                    result.append((k, v))
+            return dict(result)
+
+        config_dict = {
+            "media_server": asdict(self.media_server, dict_factory=custom_dict_factory),
+            "plex": asdict(self.plex),
+            "clap": asdict(self.clap),
+            "chroma": asdict(self.chroma),
+            "database": asdict(self.database),
+            "api": asdict(self.api),
+            "logging": asdict(self.logging),
+            "server": asdict(self.server)
+        }
+
+        with open(config_path, 'w', encoding='utf-8') as f:
+            yaml.dump(config_dict, f, default_flow_style=False, indent=2)
+
+    def to_dict(self) -> dict:
+        """Convert configuration to dictionary format"""
+        return {
+            "media_server": {
+                "type": self.media_server.type.value
+            },
+            "plex": {
+                "url": self.plex.url,
+                "token": self.plex.token,
+                "music_library_name": self.plex.music_library_name
+            },
+            "server": {
+                "gpu_batch_size": self.server.gpu_batch_size
+            },
+            "api": {
+                "host": self.api.host,
+                "port": self.api.port,
+                "reload": self.api.reload
+            },
+            "chroma": {
+                "collection_name": self.chroma.collection_name,
+                "batch_size": self.chroma.batch_size
+            },
+            "clap": {
+                "model_id": self.clap.model_id,
+                "target_sr": self.clap.target_sr,
+                "chunk_duration_s": self.clap.chunk_duration_s,
+                "num_chunks": self.clap.num_chunks,
+                "max_load_duration_s": self.clap.max_load_duration_s
+            },
+            "logging": {
+                "level": self.logging.level
+            }
+        }
+
+    def setup_logging(self) -> None:
+        """Setup logging configuration."""
+        # Configure the root logger
+        level = getattr(logging, self.logging.level.upper(), logging.INFO)
+
+        # Create log directory if needed
+        log_file_path = Path(self.logging.file)
+        log_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Get the root logger
+        root_logger = logging.getLogger()
+        
+        # Remove all existing handlers to ensure clean reconfiguration
+        for handler in root_logger.handlers[:]:
+            root_logger.removeHandler(handler)
+            handler.close()
+        
+        # Set the new level on the root logger
+        root_logger.setLevel(level)
+        
+        # Create and add new handlers
+        file_handler = logging.FileHandler(self.logging.file)
+        file_handler.setLevel(level)
+        file_handler.setFormatter(logging.Formatter(self.logging.format))
+        
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(logging.Formatter(self.logging.format))
+        
+        root_logger.addHandler(file_handler)
+        root_logger.addHandler(console_handler)
+
+        # Set log level for third-party libraries to reduce noise
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('urllib3').setLevel(logging.WARNING)
+        logging.getLogger('requests').setLevel(logging.WARNING)
+
+        # Configure Uvicorn loggers to prevent unwanted access logs
+        logging.getLogger('uvicorn.access').setLevel(logging.WARNING)
+        logging.getLogger('uvicorn').setLevel(logging.WARNING)
+        
+        # Disable verbose numba logging
+        logging.getLogger('numba.core').setLevel(logging.WARNING)
+
+
+# Export all necessary components
+__all__ = [
+    "MediaServerConfig",
+    "MyceliumConfig",
+    "PlexConfig",
+    "CLAPConfig",
+    "ChromaConfig",
+    "DatabaseConfig",
+    "APIConfig",
+    "LoggingConfig",
+    "ServerConfig",
+    "get_config_file_path",
+    "get_user_data_dir",
+    "get_user_log_dir",
+    "get_config_dir"
+]

mycelium/domain/__init__.py

@@ -0,0 +1,13 @@
+"""Domain package initialization."""
+
+from .models import Track, TrackEmbedding, SearchResult
+from .repositories import MediaServerRepository, EmbeddingRepository, EmbeddingGenerator
+
+__all__ = [
+    "Track",
+    "TrackEmbedding", 
+    "SearchResult",
+    "MediaServerRepository",
+    "EmbeddingRepository",
+    "EmbeddingGenerator",
+]

mycelium/domain/models.py

@@ -0,0 +1,71 @@
+"""Domain models for the Mycelium application."""
+
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional
+from datetime import datetime
+
+
+class MediaServerType(Enum):
+    """Supported media server types."""
+    PLEX = "plex"
+    JELLYFIN = "jellyfin"
+
+
+@dataclass
+class Track:
+    """Represents a music track from a media server."""
+
+    media_server_rating_key: str
+    media_server_type: MediaServerType
+    artist: str = ""
+    album: str = ""
+    title: str = ""
+    filepath: Optional[Path] = None
+
+    @property
+    def display_name(self) -> str:
+        """Get a display-friendly name for the track."""
+        return f"{self.artist} - {self.title}"
+    
+    @property
+    def unique_id(self) -> str:
+        """Get a unique identifier for the track across media servers."""
+        return f"{self.media_server_type.value}:{self.media_server_rating_key}"
+    
+
+
+
+@dataclass
+class TrackEmbedding:
+    """Represents a track with its embedding from a specific model."""
+
+    track: Track
+    embedding: List[float]
+    model_id: str
+    processed_at: Optional[datetime] = None
+
+
+@dataclass
+class SearchResult:
+    """Represents a search result with similarity score."""
+
+    track: Track
+    similarity_score: float
+    distance: float
+
+
+@dataclass
+class Playlist:
+    """Represents a playlist created from recommendations."""
+    
+    name: str
+    tracks: List[Track]
+    created_at: Optional[datetime] = None
+    server_id: Optional[str] = None
+    
+    @property
+    def track_count(self) -> int:
+        """Get the number of tracks in the playlist."""
+        return len(self.tracks)

mycelium/domain/repositories.py

@@ -0,0 +1,98 @@
+"""Repository interfaces for domain layer."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Optional
+
+from .models import Track, TrackEmbedding, SearchResult, Playlist
+
+
+class MediaServerRepository(ABC):
+    """Interface for media server operations (Plex, Jellyfin, etc.)."""
+    
+    @abstractmethod
+    def get_all_tracks(self) -> List[Track]:
+        """Get all tracks from the music library."""
+        pass
+    
+    @abstractmethod
+    def get_track_by_id(self, track_id: str) -> Optional[Track]:
+        """Get a specific track by its ID."""
+        pass
+    
+    @abstractmethod
+    def create_playlist(self, playlist: Playlist, batch_size: int = 100) -> Playlist:
+        """Create a playlist on the media server.
+        
+        Args:
+            playlist: The playlist to create
+            batch_size: Number of tracks to add per batch for large playlists (default: 100)
+        """
+        pass
+
+
+class EmbeddingRepository(ABC):
+    """Interface for managing track embeddings."""
+    
+    @abstractmethod
+    def save_embeddings(self, embeddings: List[TrackEmbedding]) -> None:
+        """Save track embeddings to storage."""
+        pass
+
+    @abstractmethod
+    def save_embedding(self, track_embedding: TrackEmbedding) -> None:
+        """Save track embeddings to storage."""
+        pass
+    
+    @abstractmethod
+    def search_by_embedding(self, embedding: List[float], n_results: int = 10) -> List[SearchResult]:
+        """Search for similar tracks by embedding."""
+        pass
+    
+    @abstractmethod
+    def get_embedding_count(self) -> int:
+        """Get the total number of embeddings stored."""
+        pass
+
+    @abstractmethod
+    def get_embedding_by_track_id(self, track_id: str) -> Optional[List[float]]:
+        """Get embedding for a specific track by its ID."""
+        pass
+
+    @abstractmethod
+    def has_embedding(self, track_id: str) -> bool:
+        """Check if an embedding exists for a specific track."""
+        pass
+
+
+class EmbeddingGenerator(ABC):
+    """Interface for generating embeddings from audio files."""
+    
+    @abstractmethod
+    def generate_embedding(self, filepath: Path) -> Optional[List[float]]:
+        """Generate embedding for an audio file."""
+        pass
+    
+    @abstractmethod
+    def generate_embedding_batch(self, filepaths: List[Path]) -> List[Optional[List[float]]]:
+        """Generate embeddings for multiple audio files in a batch."""
+        pass
+    
+    @abstractmethod
+    def generate_text_embedding(self, text: str) -> Optional[List[float]]:
+        """Generate embedding for text description."""
+        pass
+
+    @abstractmethod
+    def generate_text_embedding_batch(self, texts: List[str]) -> List[Optional[List[float]]]:
+        """Generate embeddings for multiple text queries in a batch."""
+        pass
+
+    @staticmethod
+    def get_best_device() -> str:
+        """Get the best device for running the embedding model (e.g., 'cpu', 'cuda')."""
+        pass
+
+    @staticmethod
+    def can_use_half_precision() -> bool:
+        """Checks once if the device supports half precision."""

mycelium/domain/worker.py

@@ -0,0 +1,77 @@
+"""Worker domain models for client-server coordination."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional
+
+from mycelium.domain import SearchResult
+
+
+class TaskType(str, Enum):
+    """Type of tasks that can be assigned to workers."""
+    COMPUTE_TEXT_EMBEDDING = "compute_text_embedding"
+    COMPUTE_AUDIO_EMBEDDING = "compute_audio_embedding"
+
+class ContextType(str, Enum):
+    """Type of context for the task."""
+    AUDIO_SEARCH = "audio_search"
+    AUDIO_PROCESSING = "audio_processing"
+    TEXT_SEARCH = "text_search"
+    SIMILAR_TRACKS = "similar_tracks"
+
+
+class TaskStatus(str, Enum):
+    """Status of a task."""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    SUCCESS = "success"
+    FAILED = "failed"
+
+
+@dataclass
+class Worker:
+    """Represents a worker in the system."""
+    id: str
+    ip_address: str
+    registration_time: datetime
+    last_heartbeat: datetime
+    is_active: bool = True
+
+
+@dataclass
+class Task:
+    """Represents a task to be processed by a worker."""
+    task_id: str
+    task_type: TaskType
+    context_type: ContextType
+    track_id: str
+    download_url: str
+    status: TaskStatus = TaskStatus.PENDING
+    assigned_worker_id: Optional[str] = None
+    created_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    error_message: Optional[str] = None
+    # Additional fields for search tasks
+    text_query: Optional[str] = None  # For text search tasks
+    audio_filename: Optional[str] = None  # For audio search tasks
+    n_results: Optional[int] = None  # For search tasks - number of results to return
+    # Results storage for search tasks
+    search_results: Optional[List[SearchResult]] = None
+
+    def __post_init__(self):
+        if self.created_at is None:
+            self.created_at = datetime.now()
+
+
+@dataclass
+class TaskResult:
+    """Result of a completed task."""
+    task_id: str
+    track_id: str
+    status: TaskStatus
+    embedding: Optional[List[float]] = None
+    error_message: Optional[str] = None
+    # For search tasks, we store the search results directly
+    search_results: Optional[List[dict]] = None

mycelium/frontend_dist/404.html

@@ -0,0 +1 @@
+<!DOCTYPE html><!--glVJ0yJSL0zWN7anTTG3_--><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="stylesheet" href="/_next/static/css/1eb7f0e2c78e0734.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/webpack-c81e624915b2ea70.js"/><script src="/_next/static/chunks/4bd1b696-cf72ae8a39fa05aa.js" async=""></script><script src="/_next/static/chunks/964-830f77d7ce1c2463.js" async=""></script><script src="/_next/static/chunks/main-app-4153d115599d3126.js" async=""></script><meta name="robots" content="noindex"/><title>404: This page could not be found.</title><title>Mycelium - AI Music Discovery</title><meta name="description" content="Discover your music collection like never before with AI-powered embeddings"/><link rel="icon" href="/favicon.ico" type="image/x-icon" sizes="16x16"/><script src="/_next/static/chunks/polyfills-42372ed130431b0a.js" noModule=""></script></head><body class="antialiased"><div hidden=""><!--$--><!--/$--></div><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding:0 23px 0 0;font-size:24px;font-weight:500;vertical-align:top;line-height:49px">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:49px;margin:0">This page could not be found.</h2></div></div></div><!--$--><!--/$--><script src="/_next/static/chunks/webpack-c81e624915b2ea70.js" id="_R_" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0])</script><script>self.__next_f.push([1,"1:\"$Sreact.fragment\"\n2:I[7555,[],\"\"]\n3:I[1295,[],\"\"]\n4:I[9665,[],\"OutletBoundary\"]\n6:I[4911,[],\"AsyncMetadataOutlet\"]\n8:I[9665,[],\"ViewportBoundary\"]\na:I[9665,[],\"MetadataBoundary\"]\nb:\"$Sreact.suspense\"\nd:I[8393,[],\"\"]\n:HL[\"/_next/static/css/1eb7f0e2c78e0734.css\",\"style\"]\n"])</script><script>self.__next_f.push([1,"0:{\"P\":null,\"b\":\"glVJ0yJSL0zWN7anTTG3_\",\"p\":\"\",\"c\":[\"\",\"_not-found\"],\"i\":false,\"f\":[[[\"\",{\"children\":[\"/_not-found\",{\"children\":[\"__PAGE__\",{}]}]},\"$undefined\",\"$undefined\",true],[\"\",[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/css/1eb7f0e2c78e0734.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"children\":[\"$\",\"body\",null,{\"className\":\"antialiased\",\"children\":[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]}]}]]}],{\"children\":[\"/_not-found\",[\"$\",\"$1\",\"c\",{\"children\":[null,[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]]}],{\"children\":[\"__PAGE__\",[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":{\"fontFamily\":\"system-ui,\\\"Segoe UI\\\",Roboto,Helvetica,Arial,sans-serif,\\\"Apple Color Emoji\\\",\\\"Segoe UI Emoji\\\"\",\"height\":\"100vh\",\"textAlign\":\"center\",\"display\":\"flex\",\"flexDirection\":\"column\",\"alignItems\":\"center\",\"justifyContent\":\"center\"},\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":{\"display\":\"inline-block\",\"margin\":\"0 20px 0 0\",\"padding\":\"0 23px 0 0\",\"fontSize\":24,\"fontWeight\":500,\"verticalAlign\":\"top\",\"lineHeight\":\"49px\"},\"children\":404}],[\"$\",\"div\",null,{\"style\":{\"display\":\"inline-block\"},\"children\":[\"$\",\"h2\",null,{\"style\":{\"fontSize\":14,\"fontWeight\":400,\"lineHeight\":\"49px\",\"margin\":0},\"children\":\"This page could not be found.\"}]}]]}]}]],null,[\"$\",\"$L4\",null,{\"children\":[\"$L5\",[\"$\",\"$L6\",null,{\"promise\":\"$@7\"}]]}]]}],{},null,false]},null,false]},null,false],[\"$\",\"$1\",\"h\",{\"children\":[[\"$\",\"meta\",null,{\"name\":\"robots\",\"content\":\"noindex\"}],[[\"$\",\"$L8\",null,{\"children\":\"$L9\"}],null],[\"$\",\"$La\",null,{\"children\":[\"$\",\"div\",null,{\"hidden\":true,\"children\":[\"$\",\"$b\",null,{\"fallback\":null,\"children\":\"$Lc\"}]}]}]]}],false]],\"m\":\"$undefined\",\"G\":[\"$d\",[]],\"s\":false,\"S\":true}\n"])</script><script>self.__next_f.push([1,"9:[[\"$\",\"meta\",\"0\",{\"charSet\":\"utf-8\"}],[\"$\",\"meta\",\"1\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}]]\n5:null\n"])</script><script>self.__next_f.push([1,"e:I[8175,[],\"IconMark\"]\n7:{\"metadata\":[[\"$\",\"title\",\"0\",{\"children\":\"Mycelium - AI Music Discovery\"}],[\"$\",\"meta\",\"1\",{\"name\":\"description\",\"content\":\"Discover your music collection like never before with AI-powered embeddings\"}],[\"$\",\"link\",\"2\",{\"rel\":\"icon\",\"href\":\"/favicon.ico\",\"type\":\"image/x-icon\",\"sizes\":\"16x16\"}],[\"$\",\"$Le\",\"3\",{}]],\"error\":null,\"digest\":\"$undefined\"}\n"])</script><script>self.__next_f.push([1,"c:\"$7:metadata\"\n"])</script></body></html>