From MCP Servers to Services: Introducing kmcp for Enterprise-Grade MCP Development

Right now, developers are shipping a wave of new MCP servers. These servers are typically designed to run locally, often inside a desktop agent or CLI shell, and they’re optimized for speed of development, not operational hardening. That’s fine if you’re experimenting or running personal agents, but it’s a different story when you want to run these tools as managed services inside an enterprise.

This is where kmcp comes in.

kmcp is a lightweight set of tools that helps you take MCP servers from prototype to production. It gives you a clear path from initialization to deployment, without the need to write Dockerfiles, patch together Kubernetes manifests, or reverse engineer the MCP spec. It lets you scaffold a new project, package it as a container, and deploy it to Kubernetes using a consistent and flexible workflow.

Whether you’re building internal copilots, customer-facing agents, or an enterprise catalog of AI tools, kmcp gives you the foundation to build and operate MCP services the right way.

What is kmcp?

kmcp is a focused set of tools designed to simplify and accelerate MCP service development and deployment.

With kmcp, you can:

• Scaffold new MCP projects with kmcp init, using templates that follow best practices
• Build container images with kmcp build, including cross-platform options
• Deploy to Kubernetes with kmcp deploy, with support for both stdio and http transports
• Manage MCP services as Kubernetes-native resources using CRDs
• Focus on writing the actual tool logic rather than building infrastructure around it

The goal is simple: reduce friction for teams building secure and scalable MCP services. 

kmcp Features and Capabilities

Scaffold Production-Ready Projects

The kmcp init python (FastMCP) and kmcp init go (MCP Go) commands generate a complete MCP project structure. This includes directory layout, language-specific dependencies, test harness, Dockerfile, project metadata, and kmcp configuration. You can choose a supported framework, set author details, and skip prompts for automation. 

Initial support is focused on FastMCP with Python and MCP Go, but the system is built to be extensible across other languages and frameworks. Kmcp will support Python, TypeScript, Golang, Java, and JavaScript frameworks. 

Simplify Builds

Use kmcp build to create a container image for your service. You can tag it, target specific platforms, or output artifacts to a local directory. The build process standardizes packaging, applies secure defaults, and prepares the service for cloud-native environments.

No need to write your own Dockerfile or guess how to handle dependencies.

Kubernetes-Native Deployment

Once built, kmcp deploy runs your MCP service in Kubernetes. You can deploy to any namespace, choose the transport (stdio or http), configure ports and environment variables, and even generate manifests without applying them directly.  The deploy command automatically opens the MCP inspector tool so that you can test and verify your MCP server deployment.

With kmcp, your MCP service becomes a first-class Kubernetes resource, using the MCPServer custom resources to manage lifecycle and configuration.

Support for Multiple Transports

kmcp supports both stdio and HTTP Streamable transports. This allows your MCP service to operate in different architectural environments, whether it’s plugged into a local agent shell or exposed as a remote API for multi-agent workloads.

The transport can be configured at deploy time, and kmcp handles service discovery and port mapping automatically.

Optimized for AI Tool Integration

The scaffolding templates include common patterns for building tools that interact with external systems. This might be an API client, a database integration, or a workflow coordinator. These patterns eliminate boilerplate and let you focus on building useful capabilities for your agents.

The result is a consistent, enterprise-ready development experience.

Built-in Support for Agentgateway

With kmcp, your MCP service has built-in support for agentgateway, which provides drop-in security, observability, and governance for agent-to-tool communication. You can apply any of the security policies supported by agentgateway easily.

Getting Started with kmcp

Here’s how the kmcp workflow looks in practice.

Step 1: Initialize a New MCP Project

kmcp init python my-weather-server \
   --author "Jane Developer" \
   --email "jane@company.com" \
   --non-interactive

This creates a full project layout, including:

• Source code and tool logic
• Tests
• Dockerfile
• Python dependencies
• kmcp configuration

Step 2: Build and Package the Service

cd my-weather-server
kmcp build --tag my-weather-server:v1.0.0

You now have a production-ready container image for your MCP service.

Step 3: Controller Setup

To enable CRD support and declarative management, you can install the kmcp controller once per cluster:

kmcp install

After this, MCP services can be deployed and updated using Kubernetes-native workflows.

Step 4: Deploy to Kubernetes

kmcp deploy \
   --image my-weather-server:v1.0.0 \
   --namespace tools \
   --port 3000 \
   --env "API_KEY=your-weather-api-key"

You can also dry-run to generate manifests without applying them:

kmcp deploy --dry-run --output ./deployment.yaml

‍

See the Demo here:

‍Try kmcp Today

kmcp is open source and available now. You can use it to scaffold, build, and deploy MCP services in minutes. It brings production sensibilities to a fast-moving space and helps developers and teams take a more disciplined approach to AI service development.

If you’re building or operating AI systems that rely on tools and context providers, this is your on-ramp to doing it the right way.

To learn more or see how this fits into your enterprise environment, reach out to Solo.io. We’re helping organizations move beyond experimental agents and toward secure, scalable, AI-native architectures built on MCP.