openlayer-mcp 0.1.0__tar.gz

openlayer_mcp-0.1.0/.github/workflows/publish-pypi.yaml

@@ -0,0 +1,28 @@
+name: "Publish to PyPI"
+
+on:
+  release:
+    types: ["published"]
+
+jobs:
+  run:
+    name: "Build and publish release"
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Set up Python
+        run: uv python install 3.10
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish -t ${{ secrets.PYPI_TOKEN }}

openlayer_mcp-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.ruff_cache/
+
+# Virtual environments
+.venv
+uv.lock

openlayer_mcp-0.1.0/.python-version

@@ -0,0 +1 @@
+3.10

openlayer_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: openlayer-mcp
+Version: 0.1.0
+Summary: MCP server for the Openlayer platform
+Requires-Python: >=3.10
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: openlayer>=0.2.0a51
+Description-Content-Type: text/markdown
+
+# Openlayer MCP
+
+[MCP](https://github.com/modelcontextprotocol) (Model Context Protocol) server for
+the Openlayer platform. This allows MCP clients (such as Cursor, VSCode,
+Claude Desktop, etc.) to interact with the Openlayer platform.
+
+## Installation
+
+```bash
+uv add openlayer-mcp
+```
+or
+
+```bash
+pip install openlayer-mcp
+```
+
+## Usage
+
+To use the Openlayer MCP server in your IDE or desktop app, you need to add it
+to the MCP configuration file.
+
+```json
+{
+    "mcpServers": {
+        "openlayer": {
+            "command": "uvx",
+            "args": [
+                "openlayer_mcp"
+            ],
+            "env": {
+                "OPENLAYER_API_KEY": "YOUR_OPENLAYER_API_KEY_HERE"
+            }
+        }
+    }
+}
+```
+
+You can alternatively run it as a standalone server with:
+
+```bash
+uv run -m openlayer_mcp
+```
+
+
+
+
+
+
+
+
+
+

openlayer_mcp-0.1.0/README.md

@@ -0,0 +1,53 @@
+# Openlayer MCP
+
+[MCP](https://github.com/modelcontextprotocol) (Model Context Protocol) server for
+the Openlayer platform. This allows MCP clients (such as Cursor, VSCode,
+Claude Desktop, etc.) to interact with the Openlayer platform.
+
+## Installation
+
+```bash
+uv add openlayer-mcp
+```
+or
+
+```bash
+pip install openlayer-mcp
+```
+
+## Usage
+
+To use the Openlayer MCP server in your IDE or desktop app, you need to add it
+to the MCP configuration file.
+
+```json
+{
+    "mcpServers": {
+        "openlayer": {
+            "command": "uvx",
+            "args": [
+                "openlayer_mcp"
+            ],
+            "env": {
+                "OPENLAYER_API_KEY": "YOUR_OPENLAYER_API_KEY_HERE"
+            }
+        }
+    }
+}
+```
+
+You can alternatively run it as a standalone server with:
+
+```bash
+uv run -m openlayer_mcp
+```
+
+
+
+
+
+
+
+
+
+

openlayer_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "openlayer-mcp"
+version = "0.1.0"
+description = "MCP server for the Openlayer platform"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp[cli]>=1.6.0",
+    "openlayer>=0.2.0a51",
+]
+
+[project.scripts]
+openlayer-mcp = "openlayer_mcp:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

openlayer_mcp-0.1.0/src/openlayer_mcp/__init__.py

@@ -0,0 +1,6 @@
+from .openlayer_platform import mcp
+
+
+def main():
+    """Run the Openlayer MCP server."""
+    mcp.run(transport="stdio")

openlayer_mcp-0.1.0/src/openlayer_mcp/__main__.py

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

openlayer_mcp-0.1.0/src/openlayer_mcp/openlayer_platform.py

@@ -0,0 +1,164 @@
+"""Openlayer platform MCP server.
+
+Provides tools that an MCP client can use to interact with the Openlayer
+platform.
+"""
+
+import os
+from typing import Dict, List
+
+from mcp.server.fastmcp import FastMCP
+from openlayer import Openlayer
+from openlayer.lib.data import commit
+
+mcp = FastMCP("openlayer-mcp")
+client = Openlayer()
+
+
+# --------------------------------- Projects --------------------------------- #
+@mcp.tool()
+def list_projects() -> List[Dict]:
+    """Get a list of the projects in the user's workspace."""
+    project_list = client.projects.list()
+    return [item.model_dump() for item in project_list.items]
+
+
+@mcp.tool()
+def create_project(
+    name: str,
+    task_type: str,
+    description: str,
+) -> Dict:
+    """Create a new project in the user's workspace.
+
+    Args:
+        name: The name of the project to create.
+        task_type: The type of task the project will be used for. Must be one of
+            'llm-base', 'tabular-classification', 'tabular-regression', or
+            'text-classification'.
+        description: A short description for the project.
+    """
+    project = client.projects.create(
+        name=name,
+        task_type=task_type,
+        description=description,
+    )
+    return project.model_dump()
+
+
+# ---------------------------------- Commits --------------------------------- #
+@mcp.tool()
+def list_commits(project_id: str) -> List[Dict]:
+    """List the commits in a project.
+
+    Args:
+        project_id: The ID of the project to list the commits for.
+    """
+    commits = client.projects.commits.list(project_id=project_id)
+    return [item.model_dump() for item in commits.items]
+
+
+@mcp.tool()
+def retrieve_commit(project_version_id: str) -> Dict:
+    """Retrieve a commit by ID.
+
+    Args:
+        project_version_id: The ID of the commit to retrieve.
+    """
+    commit = client.commits.retrieve(project_version_id=project_version_id)
+    return commit.model_dump()
+
+
+@mcp.tool()
+def push_commit(
+    project_id: str,
+    directory: str,
+    message: str = "New commit",
+) -> str:
+    """Push a commit to the project.
+
+    Args:
+        project_id: The ID of the project to push the commit to.
+        directory: The directory containing the files to push. Usually has at least
+            an `openlayer.json` file.
+        message: The commit message.
+    """
+    # Check if the directory contains an openlayer.json file
+    if not os.path.exists(os.path.join(directory, "openlayer.json")):
+        raise ValueError(
+            f"Directory {directory} does not contain an openlayer.json file, so "
+            "it is not prepared to be pushed to Openlayer."
+        )
+    try:
+        commit.push(
+            client=client,
+            directory=directory,
+            project_id=project_id,
+            message=message,
+        )
+    except Exception as exc:
+        raise ValueError(f"Error pushing commit: {exc}")
+    return "Commit pushed successfully."
+
+
+# ---------------------------- Inference pipelines --------------------------- #
+@mcp.tool()
+def list_inference_pipelines(project_id: str) -> List[Dict]:
+    """List the inference pipelines in a project."""
+    inference_pipelines = client.projects.inference_pipelines.list(
+        project_id=project_id
+    )
+    return [item.model_dump() for item in inference_pipelines.items]
+
+
+@mcp.tool()
+def retrieve_inference_pipeline(project_id: str, inference_pipeline_id: str) -> Dict:
+    """Retrieve an inference pipeline by ID."""
+    inference_pipeline = client.inference_pipelines.retrieve(
+        inference_pipeline_id=inference_pipeline_id
+    )
+    return inference_pipeline.model_dump()
+
+
+@mcp.tool()
+def create_inference_pipeline(
+    project_id: str,
+    name: str,
+    description: str,
+) -> Dict:
+    """Create a new inference pipeline in project.
+
+    Args:
+        project_id: The ID of the project to create the inference pipeline for.
+        name: The name of the inference pipeline to create.
+        description: The description of the inference pipeline to create.
+    """
+    inference_pipeline = client.projects.inference_pipelines.create(
+        project_id=project_id,
+        name=name,
+        description=description,
+    )
+    return inference_pipeline.model_dump()
+
+
+# ------------------------------- Test results ------------------------------- #
+@mcp.tool()
+def list_commit_test_results(project_version_id: str) -> List[Dict]:
+    """List the test results for a commit.
+
+    Args:
+        project_version_id: The ID of the commit to list the test results for.
+    """
+    test_results = client.commits.test_results.list(
+        project_version_id=project_version_id
+    )
+    return [item.model_dump() for item in test_results.items]
+
+
+@mcp.tool()
+def list_inference_pipeline_test_results(inference_pipeline_id: str) -> List[Dict]:
+    """List the test results for an inference pipeline."""
+    test_results = client.inference_pipelines.test_results.list(
+        inference_pipeline_id=inference_pipeline_id
+    )
+    return [item.model_dump() for item in test_results.items]