Kubernetes Model Context KMCP

​

What is KMCP?

• Accelerates local development of MCP servers with templates and boilerplates.
• Provides CLI tooling to scaffold, test, and deploy MCP servers.
• Manages MCP server lifecycle and secret handling in Kubernetes using CRDs and best practices.

• Project scaffolding and framework-specific templates (FastMCP for Python, MCP Go).
• Tool boilerplates to expose internal APIs or services to LLMs.
• Local development experience: build, run, and use the MCP Inspector to exercise tools.
• Kubernetes lifecycle management: deploy, update, delete, health checks, and secret management.
• Support for multiple transports (stdio, HTTP) and authorization integration (e.g., Keycloak).

​

Typical KMCP development workflow

1. Initialize a project
2. Add tool boilerplates
3. Run locally for development and testing (MCP Inspector)
4. Test tools interactively using the inspector
5. Deploy to Kubernetes and manage lifecycle

​

Commands (quick reference)

• Python (FastMCP):

kmcp init python my-mcp-server

• Go:

kmcp init go my-mcp-server --go-module-name my-mcp-server

• Example tool(s) (e.g., echo tool),
• Dockerfile for containerization,
• kmcp.yaml configuration,
• A test suite and recommended project structure.

​

Add a tool boilerplate

kmcp add-tool my-tool --project-dir my-mcp-server

​

Run locally (with MCP Inspector)

kmcp run --project-dir my-mcp-server

​

Deploy to Kubernetes

kmcp deploy --project-dir my-mcp-server

​

Project structure examples

FastMCP Python Project

my-mcp-server/
├─ src/
│  ├─ core/
│  ├─ tools/
│  └─ main.py
├─ tests/
├─ Dockerfile
├─ kmcp.yaml
├─ pyproject.toml
├─ .env.example
└─ README.md

# Core MCP server logic and utilities
# Your MCP tool implementations
# Entry point that starts the MCP server
# Built-in test suite for tools
# Used to containerize for Kubernetes
# KMCP config defining how server runs
# Python dependencies and project settings
# Sample environment variables
# Project documentation

my-mcp-server/
├─ main.go                           # Entry point for the MCP server
├─ go.mod                            # Go module configuration
├─ go.sum                            # Dependency integrity file
├─ tools/                            # Tool implementations
│  ├─ all_tools.go                   # Registers all tools with the server
│  ├─ echo.go                        # Example tool
│  └─ tool.go                        # Template for creating new tools
├─ Dockerfile                        # Container image definition
├─ kmcp.yaml                         # KMCP project configuration
└─ README.md                         # Project documentation

​

Framework comparison

​

KMCP core components and CLI

• CLI commands:
  • kmcp init — Initialize a new MCP project.
  • kmcp add-tool — Add a new tool boilerplate to the project.
  • kmcp run — Run the MCP server locally for testing.
  • kmcp deploy — Deploy the MCP server to Kubernetes.
• Boilerplate code and example tools follow recommended patterns.
• Containerization: Dockerfile included in scaffold.
• Project configuration: kmcp.yaml includes environment variables, transport settings, and metadata.

# Common kmcp commands
kmcp init    # Initialize new MCP project
kmcp add-tool  # Add new tool boilerplate
kmcp run     # Run locally for testing
kmcp deploy  # Deploy to Kubernetes

​

Running KMCP on Kubernetes

• stdio transport (process-based)
• HTTP transport (configure port, target port, path-based routing)

​

Lifecycle management

• Deployments and updates
• Health checks and status conditions
• Secret management and rotation support
• Scaling and resource metadata injection

​

Use cases

​

Benefits

• Rapid iteration via boilerplates and templates.
• Multiple framework support (Python, Go).
• Local testing with the MCP Inspector and integrated examples.

• Kubernetes-native deployment and lifecycle.
• Automatic health-checks and status reporting.
• Secret management and scalable architecture.

• A standardized protocol reduces maintenance overhead, simplified scaling, and consistent integration patterns without vendor lock-in.

​

Summary

• Rapidly scaffold MCP servers with best-practice templates.
• Develop and test tools locally using the MCP Inspector.
• Deploy and manage MCP servers in Kubernetes with CRDs, health checks, and secret handling.
• Choose the framework that fits your needs: FastMCP for Python or MCP Go for high-throughput services.

​

Next steps / Labs

• Deploy MCP servers to Kubernetes (including AWS).
• Integrate LLM-driven agents with an AWS Pricing MCP server.
• Build a custom cryptocurrency-check MCP server to fetch live prices.

• MCP (Model Context Protocol) — https://github.com/anthropic/mcp
• Keycloak — https://www.keycloak.org