swanlab-mcp 0.0.1__py3-none-any.whl

swanlab_mcp/__init__.py

@@ -0,0 +1,12 @@
+from ._version import __version__
+from .config import SwanLabConfig
+
+
+def main() -> None:
+    """Serve as the main entry point for SwanLab MCP Server."""
+    from .cli import main as cli_main
+
+    cli_main()
+
+
+__all__ = ["main", "__version__", "SwanLabConfig"]

swanlab_mcp/__main__.py

@@ -0,0 +1,4 @@
+from . import main
+
+if __name__ == "__main__":
+    main()

swanlab_mcp/_version.py

@@ -0,0 +1,3 @@
+"""Version information for SwanLab MCP Server."""
+
+__version__ = "0.0.1"

swanlab_mcp/cli.py

@@ -0,0 +1,59 @@
+"""Command line interface for SwanLab MCP Server."""
+
+import argparse
+import sys
+
+from .meta.info import get_server_name, get_server_name_with_version, get_server_version
+from .server import create_mcp_server
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        description=get_server_name_with_version(),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                        # Run with stdio transport (default)
+  %(prog)s --transport stdio      # Run with stdio transport
+        """,
+    )
+
+    parser.add_argument(
+        "--transport",
+        choices=["stdio"],
+        default="stdio",
+        help="Transport type (default: stdio)",
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {get_server_version()}",
+    )
+
+    return parser
+
+
+def main() -> None:
+    """Handle CLI entry point operations."""
+    parser = create_parser()
+    args = parser.parse_args()
+
+    # Create and configure the MCP server
+    try:
+        mcp = create_mcp_server()
+        print(f"MCP server created successfully on transport {args.transport}")
+    except Exception as e:
+        print(f"Error creating MCP server: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        print(f"Starting MCP server on transport {args.transport}...")
+        mcp.run(transport=args.transport)
+    except KeyboardInterrupt:
+        print(f"\nShutting down {get_server_name()}...", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error starting server: {e}", file=sys.stderr)
+        sys.exit(1)

swanlab_mcp/config.py

@@ -0,0 +1,59 @@
+"""Configuration management for SwanLab MCP Server."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+from .constants import DEFAULT_API_TIMEOUT_SECONDS, DEFAULT_SWANLAB_API_HOST, DEFAULT_SWANLAB_HOST
+
+
+class SwanLabConfig(BaseSettings):
+    """SwanLab MCP Server configuration settings."""
+
+    # Authentication settings
+    api_key: str | None = Field(
+        default=None,
+        description="SwanLab API key for authentication",
+        validation_alias="SWANLAB_API_KEY",
+    )
+
+    # Domain settings
+    main_domain: str = Field(
+        default=DEFAULT_SWANLAB_HOST,
+        description="SwanLab website domain",
+        validation_alias="SWANLAB_HOST",
+    )
+    api_domain: str = Field(
+        default=DEFAULT_SWANLAB_API_HOST,
+        description="SwanLab API domain",
+        validation_alias="SWANLAB_API_HOST",
+    )
+
+    # Request settings
+    timeout: int = Field(
+        default=DEFAULT_API_TIMEOUT_SECONDS,
+        description="API request timeout in seconds",
+        validation_alias="API_TIMEOUT",
+    )
+
+    class Config:
+        """Pydantic configuration."""
+
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+def get_config() -> SwanLabConfig:
+    """
+    Get the SwanLab configuration.
+
+    Returns:
+        SwanLabConfig instance with settings loaded from environment.
+
+    Raises:
+        ValueError: If required settings (like api_key) are not set.
+    """
+    config = SwanLabConfig()
+    if not config.api_key:
+        raise ValueError("SWANLAB_API_KEY environment variable must be set")
+    return config

swanlab_mcp/constants.py

@@ -0,0 +1,7 @@
+"""Constants for SwanLab MCP Server."""
+
+DEFAULT_SWANLAB_HOST = "https://swanlab.cn"
+DEFAULT_SWANLAB_API_HOST = "https://api.swanlab.cn"
+
+
+DEFAULT_API_TIMEOUT_SECONDS = 10

swanlab_mcp/meta/info.py

@@ -0,0 +1,72 @@
+"""Metadata utilities for version information."""
+
+import sys
+from importlib import metadata
+
+from .. import __version__
+
+
+def get_server_name() -> str:
+    """Get SwanLab MCP Server name.
+
+    Returns:
+        str: Server name without version
+
+    """
+    return "SwanLab MCP Server"
+
+
+def get_server_name_with_version() -> str:
+    """Get SwanLab MCP Server name with version.
+
+    Returns:
+        str: Server name with version (e.g., "SwanLab MCP Server v1.0.0")
+
+    """
+    return f"{get_server_name()} v{get_server_version()}"
+
+
+def get_server_version() -> str:
+    """Get SwanLab MCP Server version.
+
+    Returns:
+        str: Server version string
+
+    """
+    return __version__
+
+
+def get_fastmcp_version() -> str:
+    """Get FastMCP framework version.
+
+    Returns:
+        str: FastMCP version string, or "unknown" if not available
+
+    """
+    try:
+        return metadata.version("fastmcp")
+    except metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def get_mcp_protocol_version() -> str:
+    """Get MCP protocol version.
+
+    Returns:
+        str: MCP protocol version string, or "unknown" if not available
+
+    """
+    try:
+        return metadata.version("mcp")
+    except metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def get_python_version() -> str:
+    """Get Python runtime version.
+
+    Returns:
+        str: Python version in x.y.z format
+
+    """
+    return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"

swanlab_mcp/models.py

@@ -0,0 +1,26 @@
+from typing import Dict
+
+from pydantic import BaseModel
+
+
+class Experiment(BaseModel):
+    cuid: str  # 实验CUID, 唯一标识符
+    name: str  # 实验名
+    description: str = ""  # 实验描述
+    state: str  # 实验状态, 'FINISHED' 或 'RUNNING'
+    show: bool  # 显示状态
+    createdAt: str  # e.g., '2024-11-23T12:28:04.286Z'
+    finishedAt: str = ""  # e.g., '2024-11-23T12:28:04.286Z'
+    user: Dict[str, str]  # 实验创建者, 包含 'username' 与 'name'
+    profile: Dict  # 实验相关配置
+
+
+class Project(BaseModel):
+    cuid: str  # 项目CUID, 唯一标识符
+    name: str  # 项目名
+    description: str = ""  # 项目描述
+    visibility: str  # 可见性, 'PUBLIC' 或 'PRIVATE'
+    createdAt: str  # e.g., '2024-11-23T12:28:04.286Z'
+    updatedAt: str  # e.g., '2024-11-23T12:28:04.286Z'
+    group: Dict[str, str]  # 工作空间信息, 包含 'type', 'username', 'name'
+    count: Dict[str, int] = {}  # 项目的统计信息

swanlab_mcp/server.py

@@ -0,0 +1,38 @@
+"""SwanLab MCP Server."""
+
+from mcp.server.fastmcp import FastMCP
+from swanlab import OpenApi
+
+from .config import get_config
+from .meta.info import get_server_name_with_version
+from .tools import register_experiment_tools, register_project_tools, register_workspace_tools
+
+
+def create_mcp_server():
+    # Load configuration
+    config = get_config()
+
+    # Initialize SwanLab API
+    swanlab_api = OpenApi(api_key=config.api_key or "")
+
+    # Initialize MCP server
+    mcp = FastMCP(
+        name=get_server_name_with_version(),
+        instructions="""
+        A Model Context Protocol (MCP) server for SwanLab - a collaborative machine learning experiment tracking platform.
+
+        This server provides tools to:
+        - List and manage workspaces
+        - List, get, and delete projects
+        - List, get, and delete experiments
+        - Retrieve experiment metrics and summaries
+
+        All operations require a valid SWANLAB_API_KEY set in the environment.
+        """,
+    )
+
+    # Register all tools
+    register_workspace_tools(mcp, swanlab_api)
+    register_project_tools(mcp, swanlab_api)
+    register_experiment_tools(mcp, swanlab_api)
+    return mcp

swanlab_mcp/tools/__init__.py

@@ -0,0 +1,16 @@
+"""SwanLab MCP Tools."""
+
+from .experiment import ExperimentTools, register_experiment_tools
+from .project import ProjectTools, register_project_tools
+from .workspace import WorkspaceTools, register_workspace_tools
+
+__all__ = [
+    # Tool classes
+    "ProjectTools",
+    "ExperimentTools",
+    "WorkspaceTools",
+    # Registration functions
+    "register_workspace_tools",
+    "register_project_tools",
+    "register_experiment_tools",
+]

swanlab_mcp/tools/experiment.py

@@ -0,0 +1,245 @@
+"""Experiment related MCP tools."""
+
+from typing import Any, Dict, List, Optional, Union
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ToolAnnotations
+from swanlab import OpenApi
+
+from ..models import Experiment
+
+
+class ExperimentTools:
+    """SwanLab Experiment management tools."""
+
+    def __init__(self, api: OpenApi):
+        self.api = api
+
+    async def list_experiments(self, project: str) -> List[Experiment]:
+        """
+        List all experiments in a project.
+
+        Args:
+            project: Project name or CUID
+
+        Returns:
+            List of Experiment objects containing:
+            - cuid: Unique experiment identifier
+            - name: Experiment name
+            - description: Experiment description
+            - state: RUNNING or FINISHED
+            - show: Display status
+            - createdAt/finishedAt: Timestamps
+            - user: Creator information
+            - profile: Experiment configuration
+        """
+        try:
+            response = self.api.list_experiments(project=project)
+            experiments = []
+            for item in response.data:
+                if hasattr(item, "model_dump"):
+                    experiments.append(Experiment(**item.model_dump()))
+                elif hasattr(item, "__dict__"):
+                    experiments.append(Experiment(**item.__dict__))
+                else:
+                    experiments.append(Experiment(**item))
+            return experiments
+        except Exception as e:
+            raise RuntimeError(f"Failed to list experiments for project '{project}': {str(e)}") from e
+
+    async def get_experiment(self, project: str, exp_id: str) -> Experiment:
+        """
+        Get detailed information about a specific experiment.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID
+
+        Returns:
+            Experiment object with detailed information including profile data
+        """
+        try:
+            response = self.api.get_experiment(project=project, exp_id=exp_id)
+            item = response.data
+            if hasattr(item, "model_dump"):
+                return Experiment(**item.model_dump())
+            elif hasattr(item, "__dict__"):
+                return Experiment(**item.__dict__)
+            else:
+                return Experiment(**item)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get experiment '{exp_id}' from project '{project}': {str(e)}") from e
+
+    async def get_summary(self, project: str, exp_id: str) -> Dict[str, Any]:
+        """
+        Get summary statistics for an experiment's metrics.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID
+
+        Returns:
+            Dictionary containing metric summaries with step, value, min, and max information.
+            Example: {"loss": {"step": 47, "value": 0.19, "min": {...}, "max": {...}}}
+        """
+        try:
+            response = self.api.get_summary(project=project, exp_id=exp_id)
+            return response.data
+        except Exception as e:
+            raise RuntimeError(f"Failed to get summary for experiment '{exp_id}': {str(e)}") from e
+
+    async def get_metrics(self, exp_id: str, keys: Union[str, List[str]]) -> Optional[Dict[str, Any]]:
+        """
+        Get metric data for an experiment.
+
+        Args:
+            exp_id: Experiment CUID
+            keys: List of metric names to retrieve (e.g., ["loss", "acc"])
+
+        Returns:
+            Dictionary containing metric values indexed by step.
+            Includes both values and timestamps for each metric.
+        """
+        try:
+            response = self.api.get_metrics(exp_id=exp_id, keys=keys if isinstance(keys, list) else [keys])
+            data = response.data
+            if hasattr(data, "to_dict"):
+                return data.to_dict()
+            return None
+        except Exception as e:
+            raise RuntimeError(f"Failed to get metrics for experiment '{exp_id}': {str(e)}") from e
+
+    async def delete_experiment(self, project: str, exp_id: str) -> str:
+        """
+        Delete an experiment from a project.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID to delete
+
+        Returns:
+            Success message
+        """
+        try:
+            self.api.delete_experiment(project=project, exp_id=exp_id)
+            return f"Successfully deleted experiment '{exp_id}' from project '{project}'"
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete experiment '{exp_id}': {str(e)}") from e
+
+
+def register_experiment_tools(mcp: FastMCP, api: OpenApi) -> None:
+    """
+    Register experiment-related MCP tools.
+
+    Args:
+        mcp: FastMCP server instance
+        api: SwanLab OpenApi instance
+    """
+    experiment_tools = ExperimentTools(api)
+
+    @mcp.tool(
+        name="swanlab_list_experiments_in_a_project",
+        description="List all experiments in a project.",
+        annotations=ToolAnnotations(
+            title="List all experiments in a project.",
+            readOnlyHint=True,
+        ),
+    )
+    async def list_experiments(project: str) -> List[Dict[str, Any]]:
+        """
+        List all experiments in a project.
+
+        Args:
+            project: Project name or CUID
+
+        Returns:
+            List of experiments with their names, states, descriptions, and metadata.
+        """
+        experiments = await experiment_tools.list_experiments(project)
+        return [exp.model_dump() for exp in experiments]
+
+    @mcp.tool(
+        name="swanlab_get_a_specific_experiment",
+        description="Get detailed information about a specific experiment in a project.",
+        annotations=ToolAnnotations(
+            title="Get detailed information about a specific experiment in a project.",
+            readOnlyHint=True,
+        ),
+    )
+    async def get_experiment(project: str, exp_id: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a specific experiment.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID
+
+        Returns:
+            Experiment details including profile data, configuration, and metadata.
+        """
+        experiment = await experiment_tools.get_experiment(project, exp_id)
+        return experiment.model_dump()
+
+    @mcp.tool(
+        name="swanlab_get_summary_for_an_experiment",
+        description="Get summary statistics for an experiment's metrics.",
+        annotations=ToolAnnotations(
+            title="Get summary statistics for an experiment's metrics.",
+            readOnlyHint=True,
+        ),
+    )
+    async def get_experiment_summary(project: str, exp_id: str) -> Dict[str, Any]:
+        """
+        Get summary statistics for an experiment's metrics.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID
+
+        Returns:
+            Dictionary containing metric summaries with step, value, min, and max information.
+        """
+        return await experiment_tools.get_summary(project, exp_id)
+
+    @mcp.tool(
+        name="swanlab_get_metrics_for_an_experiment",
+        description="Get metric data for an experiment.",
+        annotations=ToolAnnotations(
+            title="Get metric data for an experiment.",
+            readOnlyHint=True,
+        ),
+    )
+    async def get_experiment_metrics(exp_id: str, keys: List[str]) -> Optional[Dict[str, Any]]:
+        """
+        Get metric data for an experiment.
+
+        Args:
+            exp_id: Experiment CUID
+            keys: Optional list of metric names to retrieve (e.g., ["loss", "acc"]).
+                  If not provided, all metrics will be returned.
+
+        Returns:
+            Dictionary containing metric values indexed by step, including timestamps.
+        """
+        return await experiment_tools.get_metrics(exp_id, keys)
+
+    @mcp.tool(
+        name="swanlab_delete_an_experiment",
+        description="Delete an experiment from a project. Warning: This action cannot be undone.",
+        annotations=ToolAnnotations(
+            title="Delete an experiment from a project. Warning: This action cannot be undone.",
+            readOnlyHint=False,
+        ),
+    )
+    async def delete_experiment(project: str, exp_id: str) -> str:
+        """
+        Delete an experiment from a project.
+
+        Args:
+            project: Project name or CUID
+            exp_id: Experiment CUID to delete
+
+        Returns:
+            Success message confirming deletion.
+        """
+        return await experiment_tools.delete_experiment(project, exp_id)

swanlab_mcp/tools/project.py

@@ -0,0 +1,154 @@
+"""Project related MCP tools."""
+
+from typing import Any, Dict, List
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ToolAnnotations
+from swanlab import OpenApi
+
+from ..models import Project
+
+
+class ProjectTools:
+    """SwanLab Project management tools."""
+
+    def __init__(self, api: OpenApi):
+        self.api = api
+
+    async def list_projects(self) -> List[Project]:
+        """
+        List all projects in the workspace.
+
+        Returns:
+            List of Project objects containing project information including:
+            - cuid: Unique project identifier
+            - name: Project name
+            - description: Project description
+            - visibility: PUBLIC or PRIVATE
+            - createdAt/updatedAt: Timestamps
+            - group: Workspace information
+            - count: Statistics (experiments, contributors, etc.)
+        """
+        try:
+            response = self.api.list_projects()
+            # SwanLab API returns Project objects, convert to our Pydantic models
+            projects = []
+            for item in response.data:
+                if hasattr(item, "model_dump"):
+                    # If it's already a Pydantic model
+                    projects.append(Project(**item.model_dump()))
+                elif hasattr(item, "__dict__"):
+                    # If it's a regular object with attributes
+                    projects.append(Project(**item.__dict__))
+                else:
+                    # If it's a dict
+                    projects.append(Project(**item))
+            return projects
+        except Exception as e:
+            raise RuntimeError(f"Failed to list projects: {str(e)}") from e
+
+    async def get_project(self, project: str) -> Project:
+        """
+        Get detailed information about a specific project by filtering from list.
+
+        Args:
+            project: Project name or CUID
+
+        Returns:
+            Project object with detailed information
+        """
+        try:
+            # SwanLab API doesn't have get_project, so we filter from list_projects
+            projects = await self.list_projects()
+            for proj in projects:
+                if proj.cuid == project or proj.name == project:
+                    return proj
+            raise ValueError(f"Project '{project}' not found")
+        except Exception as e:
+            raise RuntimeError(f"Failed to get project '{project}': {str(e)}") from e
+
+    async def delete_project(self, project: str) -> str:
+        """
+        Delete a project from the workspace.
+
+        Args:
+            project: Project name or CUID to delete
+
+        Returns:
+            Success message
+        """
+        try:
+            self.api.delete_project(project=project)
+            return f"Successfully deleted project '{project}'"
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete project '{project}': {str(e)}") from e
+
+
+def register_project_tools(mcp: FastMCP, api: OpenApi) -> None:
+    """
+    Register project-related MCP tools.
+
+    Args:
+        mcp: FastMCP server instance
+        api: SwanLab OpenApi instance
+    """
+    project_tools = ProjectTools(api)
+
+    @mcp.tool(
+        name="swanlab_list_projects_in_a_workspace",
+        description="List all projects in the workspace.",
+        annotations=ToolAnnotations(
+            title="List all projects in the workspace.",
+            readOnlyHint=True,
+        ),
+    )
+    async def list_projects() -> List[Dict[str, Any]]:
+        """
+        List all projects in the workspace.
+
+        Returns:
+            List of projects with details including name, description, visibility, statistics, etc.
+        """
+        projects = await project_tools.list_projects()
+        return [project.model_dump() for project in projects]
+
+    @mcp.tool(
+        name="swanlab_get_a_specific_project",
+        description="Get detailed information about a specific project.",
+        annotations=ToolAnnotations(
+            title="Get detailed information about a specific project.",
+            readOnlyHint=True,
+        ),
+    )
+    async def get_project(project: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a specific project.
+
+        Args:
+            project: Project name or CUID
+
+        Returns:
+            Project details including metadata and statistics.
+        """
+        project_obj = await project_tools.get_project(project)
+        return project_obj.model_dump()
+
+    @mcp.tool(
+        name="swanlab_delete_a_project",
+        description="Delete a project from the workspace. Warning: This action cannot be undone.",
+        annotations=ToolAnnotations(
+            title="Delete a project from the workspace. Warning: This action cannot be undone.",
+            readOnlyHint=False,
+        ),
+    )
+    async def delete_project(project: str) -> str:
+        """
+        Delete a project from the workspace.
+
+        Args:
+            project: Project name or CUID to delete
+
+        Returns:
+            Success message confirming deletion.
+        """
+        return await project_tools.delete_project(project)

swanlab_mcp/tools/workspace.py

@@ -0,0 +1,58 @@
+"""Workspace related MCP tools."""
+
+from typing import Any, Dict, List
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ToolAnnotations
+from swanlab import OpenApi
+
+
+class WorkspaceTools:
+    """SwanLab Workspace management tools."""
+
+    def __init__(self, api: OpenApi):
+        self.api = api
+
+    async def list_workspaces(self) -> List[Dict[str, Any]]:
+        """
+        List all workspaces accessible to the current user.
+
+        Returns:
+            List of workspace dictionaries containing:
+            - name: Workspace name
+            - username: Workspace username/identifier
+            - role: User's role in the workspace (OWNER, MEMBER, etc.)
+        """
+        try:
+            response = self.api.list_workspaces()
+            return response.data
+        except Exception as e:
+            raise RuntimeError(f"Failed to list workspaces: {str(e)}") from e
+
+
+def register_workspace_tools(mcp: FastMCP, api: OpenApi) -> None:
+    """
+    Register workspace-related MCP tools.
+
+    Args:
+        mcp: FastMCP server instance
+        api: SwanLab OpenApi instance
+    """
+    workspace_tools = WorkspaceTools(api)
+
+    @mcp.tool(
+        name="swanlab_list_workspaces",
+        description="List all workspaces accessible to the current user.",
+        annotations=ToolAnnotations(
+            title="List all workspaces accessible to the current user.",
+            readOnlyHint=True,
+        ),
+    )
+    async def list_workspaces() -> List[Dict[str, Any]]:
+        """
+        List all workspaces accessible to the current user.
+
+        Returns:
+            List of workspaces with their names, usernames, and user roles.
+        """
+        return await workspace_tools.list_workspaces()

swanlab_mcp-0.0.1.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: swanlab-mcp
+Version: 0.0.1
+Summary: MCP (Model Context Protocol) server support for SwanLab
+Author-email: CaddiesNew <nexisato0810@gmail.com>
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=2.14.4
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: swanlab
+Description-Content-Type: text/markdown
+
+# SwanLab-MCP-Server
+
+> A Model Context Protocol (MCP) server implementation for SwanLab, combining SwanLab-OpenAPI & FastMCP.
+
+## ✨ Features
+
+### Core Features
+
+- **Workspace Management** - List and manage user-accessible workspaces
+- **Project Management** - Create, retrieve, delete projects, and list project information
+- **Experiment Management** - Create, retrieve, delete experiments, and retrieve experiment metrics and summaries
+- **API Integration** - Provide complete platform access through SwanLab OpenAPI
+
+### Tech Stack
+
+- **Language**: Python 3.12+
+- **Core Framework**: FastMCP (v2.14.4+)
+- **API Client**: SwanLab SDK
+- **Config Management**: Pydantic Settings
+
+## 🚀 Quick Start
+
+### ❗️Configuration
+
+Add the following configuration to your relative mcp config list
+
+```json
+{
+  "mcpServers": 
+    ...
+    {
+    "swanlab-mcp": {
+      "command": "uv",
+      "args": ["run", "swanlab_mcp", "--transport", "stdio"],
+      "env": {
+        "SWANLAB_API_KEY": "your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+For `Claude Code` Users, you can config like this:
+
+```bash
+claude mcp add --env SWANLAB_API_KEY=<your_api_key> -- swanlab_mcp uv run swanlab_mcp --transport stdio
+```
+
+### Prerequisites
+
+- Python >= 3.12
+- SwanLab API Key (get it from [SwanLab](https://swanlab.cn))
+
+### Installation
+
+```bash
+# Using uv (recommended)
+uv sync
+
+# Or using pip
+pip install -e .
+```
+
+### Configuration
+
+#### Environment Variables
+
+Create a `.env` file and configure your API key:
+
+```bash
+cp .env.template .env
+```
+
+Edit the `.env` file:
+
+```env
+SWANLAB_API_KEY=your_api_key_here
+```
+
+### Running
+
+```bash
+# Using stdio transport (default)
+python -m swanlab_mcp
+
+# Or using CLI
+python -m swanlab_mcp --transport stdio
+
+# Check version
+python -m swanlab_mcp --version
+```
+
+### Usage
+
+After configuration, restart Claude Desktop to interact with SwanLab via the MCP protocol.
+
+Available Tools:
+- `swanlab_list_workspaces` - List workspaces
+- `swanlab_create_project` - Create project
+- `swanlab_list_projects` - List projects
+- `swanlab_create_experiment` - Create experiment
+- `swanlab_list_experiments` - List experiments
+- `swanlab_get_experiment` - Get experiment details
+- `swanlab_delete_experiment` - Delete experiment
+
+## 🛠️ Development
+
+### Code Formatting
+
+```bash
+# Using Makefile
+make format
+
+# Or manually
+uvx isort . --skip-gitignore
+uvx ruff format . --quiet
+```
+
+### Lint Check
+
+```bash
+uvx ruff check .
+```
+
+### Pre-commit Hooks
+
+```bash
+bash scripts/install-hooks.sh
+```
+
+## 📚 References & Acknowledgements
+
+- [SwanLab](https://github.com/SwanHubX/SwanLab)
+- [Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro)
+- [FastMCP v2](https://github.com/jlowin/fastmcp)
+- [modelscope-mcp-server](https://github.com/modelscope/modelscope-mcp-server)
+- [TrackIO-mcp-server](https://github.com/fcakyon/trackio-mcp)
+- [Simple-Wandb-mcp-server](https://github.com/tsilva/simple-wandb-mcp-server)
+
+## 📄 License
+
+MIT License

swanlab_mcp-0.0.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+swanlab_mcp/__init__.py,sha256=BE5zf9dh3Lx_QvUr_7vI9afv-C_2wBJaWWCiGrSrlz4,261
+swanlab_mcp/__main__.py,sha256=5BjNuyet8AY-POwoF5rGt722rHQ7tJ0Vf0UFUfzzi-I,58
+swanlab_mcp/_version.py,sha256=V9RIhJ1LjlFvbGmWoU5Vy5wjiVD_LKdlNdrh-NQ88Lw,73
+swanlab_mcp/cli.py,sha256=7tJZv8f8ByJ0ME8wDcyTZiTkp2fPYjBk0TSGFRRbZTc,1710
+swanlab_mcp/config.py,sha256=MgqztPVcEfIeRDv4AUmX9tpYTW42DXbVtgY1BW6BXHU,1603
+swanlab_mcp/constants.py,sha256=0aDFnrfgN_DkY8IQY6w-0WV9hDTwvNGbCJH5BD_SXuc,172
+swanlab_mcp/models.py,sha256=PbcCBYjoospoXX0HjaKtcEGq6YHQWO4oMZFrUqbln7c,967
+swanlab_mcp/server.py,sha256=wYWvaezWi0hrYlLuYPRp8kRS1XfnrnXNAMxF0Sz-qDo,1172
+swanlab_mcp/meta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+swanlab_mcp/meta/info.py,sha256=2w6_UhXUWWtrdSSlq_gTPdn6-Bbs7TBN24R_LO2GrEw,1482
+swanlab_mcp/tools/__init__.py,sha256=AgPfbSmuI4SzryUzvqfl_wvByAV-A7zfV9zf3-lnQSU,438
+swanlab_mcp/tools/experiment.py,sha256=jzwmfzwKrZctz-_hN8VCVvQJT6_EzQWoNh0JSlOp7JE,8630
+swanlab_mcp/tools/project.py,sha256=sA_uKbM8M5xB4llIGa7drViLcDZF4t5qWYAK4fGNp4c,5115
+swanlab_mcp/tools/workspace.py,sha256=hXhH6T1EoJkBy1pkbPEMhO_ZSqNYxy_fEoRCj0SGq9w,1726
+swanlab_mcp-0.0.1.dist-info/METADATA,sha256=XZpv8xHFZ5axR7geXPI8Qvx1Ujz5-7_axXzsc9MvCnA,3356
+swanlab_mcp-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+swanlab_mcp-0.0.1.dist-info/entry_points.txt,sha256=zKTWAZz7UcDiZdVTNkgtxe7ESf50fvKpBacGJGJrnS0,53
+swanlab_mcp-0.0.1.dist-info/RECORD,,

swanlab_mcp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

swanlab_mcp-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+swanlab_mcp = swanlab_mcp.cli:main