class VectorStoreConfig(BaseModel):
    collection_name: Optional[str] = Field(None, description="Name of the collection")
    embedding_model_dims: Optional[int] = Field(None, description="Dimensions of the embedding model")
    client: Optional[str] = Field(None, description="Custom client for the database")
    path: Optional[str] = Field(None, description="Path for the database")
    host: Optional[str] = Field(None, description="Host where the server is running")
    port: Optional[int] = Field(None, description="Port where the server is running")
    user: Optional[str] = Field(None, description="Username for database connection")
    password: Optional[str] = Field(None, description="Password for database connection")
    dbname: Optional[str] = Field(None, description="Name of the database")
    url: Optional[str] = Field(None, description="Full URL for the server")
    api_key: Optional[str] = Field(None, description="API key for the server")
    on_disk: Optional[bool] = Field(None, description="Enable persistent storage")
    endpoint_id: Optional[str] = Field(None, description="Endpoint ID (vertex_ai_vector_search)")
    index_id: Optional[str] = Field(None, description="Index ID (vertex_ai_vector_search)")
    deployment_index_id: Optional[str] = Field(None, description="Deployment index ID (vertex_ai_vector_search)")
    project_id: Optional[str] = Field(None, description="Project ID (vertex_ai_vector_search)")
    project_number: Optional[str] = Field(None, description="Project number (vertex_ai_vector_search)")
    vector_search_api_endpoint: Optional[str] = Field(None, description="Vector search API endpoint (vertex_ai_vector_search)")
    connection_string: Optional[str] = Field(None, description="PostgreSQL connection string (for Supabase/PGVector)")
    index_method: Optional[str] = Field(None, description="Vector index method (for Supabase)")
    index_measure: Optional[str] = Field(None, description="Distance measure for similarity search (for Supabase)")

class VectorStoreProvider(BaseModel):
    provider: str = Field(..., description="Vector store provider name")
    config: VectorStoreConfig
#...
class Mem0Config(BaseModel):
    llm: Optional[LLMProvider] = None
    embedder: Optional[EmbedderProvider] = None
    vector_store: Optional[VectorStoreProvider] = None # Added to implement

@router.get("/mem0/vector_store", response_model=VectorStoreProvider)
async def get_vector_store_configuration(db: Session = Depends(get_db)):
    """Get only the Vector Store configuration."""
    config = get_config_from_db(db)
    vector_store_config = config.get("mem0", {}).get("vector_store", {})
    return vector_store_config

@router.put("/mem0/vector_store", response_model=VectorStoreProvider)
async def update_vector_store_configuration(vector_store_config: VectorStoreProvider, db: Session = Depends(get_db)):
    """Update only the Vector Store configuration."""
    current_config = get_config_from_db(db)
    
    # Ensure mem0 key exists
    if "mem0" not in current_config:
        current_config["mem0"] = {}
    
    # Update the Vector Store configuration
    current_config["mem0"]["vector_store"] = vector_store_config.dict(exclude_none=True)
    
    # Save the configuration to database
    save_config_to_db(db, current_config)
    reset_memory_client()
    return current_config["mem0"]["vector_store"]

def get_default_memory_config():
    """Get default memory client configuration from default_config.json file."""
    from app.utils.config_loader import get_mem0_config
    
    # Load mem0 config from JSON file
    base_config = get_mem0_config()
    
    # Use the configs directly from JSON - environment variables will be applied later
    vector_store_config = base_config.get("vector_store", {})
    llm_config = base_config.get("llm", {})
    embedder_config = base_config.get("embedder", {})
    
    return {
        "vector_store": vector_store_config,
        "llm": llm_config,
        "embedder": embedder_config,
        "version": "v1.1"
    }

def load_default_config() -> Dict[str, Any]:
    """
    Load the default configuration from default_config.json file.
    
    Returns:
        Dict containing the configuration loaded from JSON file.
        Falls back to hardcoded defaults if file is not found or invalid.
    """
    # Get the path to default_config.json relative to this file
    config_path = os.path.join(
        os.path.dirname(__file__), 
        "..", 
        "..", 
        "default_config.json"
    )
    
    try:
        with open(config_path, 'r') as f:
            config = json.load(f)
        
        # Ensure openmemory section exists
        if "openmemory" not in config:
            config["openmemory"] = {
                "custom_instructions": None
            }
        
        return config
        
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Warning: Could not load default_config.json: {e}")
        return get_fallback_config()