Overview

The NanoVMs MCP (Model Context Protocol) server is a lightweight service for building and publishing NanoVMs unikernels to cloud providers and artifact stores. It accepts build “models” — a compact description of source, runtime, build options and target cloud — then runs the build pipeline and produces deployable images or artifacts. The server decouples build infrastructure from developer machines and CI systems, enabling fast, repeatable, and secure unikernel builds.

For teams that build and deploy minimal unikernels at scale, an MCP server centralizes builders, caches artifacts, and integrates with multiple clouds (AWS, GCP, Azure, custom OpenStack/S3 endpoints, etc.). This makes it straightforward to create reproducible tiny VMs, push them to registries or object storage, and automate deployment from CI/CD pipelines.

Features

Remote build server for NanoVMs unikernels (Model Context Protocol compatible)
Multi-cloud publishing: support for public clouds and custom providers
Artifact storage backends (S3-compatible, local storage, container registries)
REST API for programmatic integration with CI/CD and developer tools
Containerized deployment and single-binary distribution
Build caching and reuse across requests
Authentication and multi-tenant configuration (via environment or config)
Extensible provider plugins for custom deployment targets
Logs and build artifacts accessible over HTTP

Installation / Configuration

There are two common ways to run the MCP server: using Docker, or building from source.

Run with Docker (quick start)

# Pull and run a container (replace image tag as needed)
docker run -p 8080:8080 \
  -e MCP_LISTEN=":8080" \
  -e S3_ENDPOINT="https://s3.example.com" \
  -e AWS_ACCESS_KEY_ID="AKIA..." \
  -e AWS_SECRET_ACCESS_KEY="..." \
  nanovms/ops-mcp:latest

Build from source (Go required)

git clone https://github.com/nanovms/ops-mcp.git
cd ops-mcp
go build ./cmd/mcp
# Run with a configuration file
./mcp --config ./config.json

Example JSON config (minimal)

{
  "listen": ":8080",
  "storage": {
    "type": "s3",
    "bucket": "nanovms-artifacts",
    "endpoint": "https://s3.example.com"
  },
  "providers": {
    "aws": {
      "region": "us-east-1"
    },
    "gcp": {
      "project": "my-gcp-project"
    }
  }
}

Common environment variables

MCP_LISTEN — host:port to bind the server (default :8080)
S3_ENDPOINT, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY — S3-compatible artifact storage
PROVIDER_AWS_REGION, PROVIDER_GCP_PROJECT — per-provider credentials/settings

After starting, consult the server logs to confirm listening address and storage connectivity.

Available Resources

Source code and issues: https://github.com/nanovms/ops-mcp
NanoVMs main project and docs: https://github.com/nanovms
Example configs and CI snippets typically live in the repo’s examples/ or docs/ directories
Use your existing CI (GitHub Actions, GitLab CI, Jenkins) to call MCP REST API or CLI integration

Use Cases

CI/CD Unikernel Builds
- In a GitHub Actions workflow, upload the build model (source + build options) to the MCP server, trigger the build, and retrieve the resulting AMI, image file, or container. Store the artifact in an S3-compatible bucket and then create an infrastructure change that references that artifact.
Multi-cloud Image Publishing
- Configure the MCP server with multiple providers. Submit a single model and have the server produce artifacts for AWS, GCP, and an on-prem OpenStack endpoint. Use artifacts to launch small, secure VM instances across environments.
Shared Builder for Teams
- Operate a central MCP in a private network to provide reproducible builds. Developers push models rather than running local build toolchains, reducing local dependencies and enabling consistent outputs.
Automated Edge Deployments
- Build minimal unikernels for edge devices or small VMs and publish images to an object store. Remote deployment scripts or orchestration tools download the artifact and instantiate the unikernel close to the edge.
Secure, Ephemeral Building
- Run MCP worker nodes in ephemeral containers or short-lived VMs to isolate build environments. Once a build completes and artifacts are persisted to storage, tear down workers to reduce attack surface.

Example workflow (conceptual)

Prepare a build model (metadata, source tarball reference, build options).
POST the model to the MCP server’s API endpoint.
Server schedules a build, runs toolchain and produces artifacts.
Artifact is pushed to configured storage (S3, registry, image store).
Client polls or subscribes to build status and retrieves artifact metadata/URLs.

Tips for Developers

Start with a single local Docker instance for testing before integrating into CI.
Use S3-compatible storage for durability and to decouple artifacts from ephemeral builders.
Cache dependencies and reuse worker images to speed up repeated builds.
Secure the server via network controls and credentials; limit who can submit build requests and read artifacts.

For implementation details, configuration options and API examples, see the repository: https://github.com/nanovms/ops-mcp. Tags: developer-tools.

NanoVMs MCP Server: Build and Deploy Cloud Unikernels