MCP in Your Code Repository: How Model Context Protocol Changes AI-Assisted Infrastructure

AI coding assistants are powerful but blind. They see the file you're editing and maybe a few open tabs. They don't see your Kubernetes cluster state, your CI/CD pipeline status, your Kyverno policy violations, your cost dashboard, or your incident history. Every time you need that context, you alt-tab, copy data, paste it into the chat, and hope the AI understands the format.

Model Context Protocol (MCP) fixes this. MCP is an open standard (created by Anthropic, adopted across the ecosystem) that gives AI assistants structured, real-time access to external data sources through a simple server interface. Instead of copying context manually, the AI queries MCP servers directly — and gets structured data it can reason about.

For platform engineering, this is transformative. Your AI assistant doesn't just help you write YAML — it writes YAML informed by your actual cluster state, policy requirements, cost constraints, and deployment history.

What MCP Actually Is

MCP is a client-server protocol. The AI assistant (Cursor, Claude Desktop, VS Code with Copilot) is the client. MCP servers expose tools and resources that the client can call:

• Tools: Actions the AI can take — query a database, check cluster status, run a policy evaluation, look up cost data
• Resources: Data the AI can read — configuration files, documentation, API schemas, architecture decision records
• Prompts: Pre-built prompt templates that combine context from multiple sources into a structured request

The key insight: MCP servers are lightweight. A Kubernetes MCP server is a small process that translates AI requests into kubectl/API calls. A Git MCP server reads repository history. A cost MCP server queries your OpenCost/Kubecost API. Each one is simple; the power comes from combining them.

MCP Servers for Platform Engineering

1. Kubernetes Cluster MCP Server

Gives the AI real-time cluster awareness:

Now when the AI generates a Kubernetes manifest, it knows the actual cluster state. It won't suggest a resource limit that exceeds your node capacity. It won't create a NetworkPolicy that conflicts with existing rules. It writes infrastructure that fits your reality, not a generic tutorial example.

2. Git Repository MCP Server

Gives the AI project history and team context:

When the AI suggests a change, it understands the history. "The last 3 changes to this file were security hardening by the security team — my suggestion should maintain that direction, not undo it."

3. CI/CD Pipeline MCP Server

Gives the AI build and deployment awareness:

4. Cost and Capacity MCP Server

Gives the AI financial awareness:

Now when the AI suggests infrastructure, it includes cost context. "This deployment will cost approximately 2,400 EUR/month. Based on the team's budget of 10,000 EUR/month and current spend of 7,200 EUR/month, this fits within budget." Infrastructure planning with financial awareness.

5. Policy and Compliance MCP Server

Integrating MCP Into Your Repository Workflow

Repository-Level MCP Configuration

MCP configuration lives in the repository, versioned alongside the code:

# .mcp/config.json (checked into Git)
{
  "servers": {
    "kubernetes": {
      "command": "mcp-kubernetes",
      "args": ["--kubeconfig", "~/.kube/config", "--context", "production"],
      "env": {
        "ALLOWED_NAMESPACES": "ml-team-*,platform-*",
        "READ_ONLY": "true"
      }
    },
    "git-history": {
      "command": "mcp-git",
      "args": ["--repo", "."],
      "env": {
        "MAX_COMMITS": "100",
        "INCLUDE_DIFFS": "true"
      }
    },
    "ci-pipeline": {
      "command": "mcp-cicd",
      "args": ["--provider", "github-actions"],
      "env": {
        "GITHUB_TOKEN_REF": "vault:ci/github-token",
        "INCLUDE_SECURITY_SCANS": "true"
      }
    },
    "cost": {
      "command": "mcp-opencost",
      "args": ["--endpoint", "http://opencost.monitoring:9090"],
      "env": {
        "CURRENCY": "EUR",
        "INCLUDE_GPU": "true"
      }
    },
    "policy": {
      "command": "mcp-kyverno",
      "args": ["--policy-dir", "policies/"],
      "env": {
        "REGULATIONS": "DORA,NIS2,AI-Act,CRA",
        "COMPLIANCE_MAPPING": "policies/compliance-map.yaml"
      }
    }
  }
}

When an engineer opens the repository in Cursor (or any MCP-compatible editor), these servers start automatically. Every team member gets the same context sources. The rulesets and skills combined with MCP servers create an AI assistant that knows your standards AND your current state.

Security Boundaries

MCP servers must respect security boundaries:

• Read-only by default: MCP servers should query cluster state, not modify it. Changes go through Git (GitOps). The AI suggests changes; humans approve them in PRs
• Namespace scoping: Engineers only see namespaces they have RBAC access to. The MCP server inherits the engineer's permissions, not cluster-admin
• Secret filtering: MCP servers must redact secrets, tokens, and credentials from responses. The AI needs to know a secret exists, not its value
• Audit logging: Every MCP query is logged. "Engineer X queried production pod status at 14:32." Same audit rigour as direct API access
• Rate limiting: MCP servers should limit query frequency to prevent AI assistants from hammering the API. 10 queries per minute per server is a reasonable starting point

The Compound Effect: MCP + Rulesets + Skills

MCP alone is useful. Combined with project rulesets and shared skills, it's transformative:

• Rulesets tell the AI your standards (how to write code)
• Skills tell the AI your patterns (what to generate)
• MCP tells the AI your reality (what exists, what's running, what it costs)

Together: the AI generates a Kyverno policy (skill) that follows your naming conventions (ruleset) and doesn't conflict with existing policies (MCP cluster query), fits within your compliance requirements (MCP policy evaluation), and costs within your team's budget (MCP cost query). That's not autocomplete — that's an informed engineering partner.

What Open Empower Delivers

• MCP architecture design: Assess your infrastructure and design the MCP server topology — which data sources, which security boundaries, which team access patterns
• MCP server deployment: Deploy and configure MCP servers for Kubernetes, Git, CI/CD, cost, and policy compliance — integrated with your existing infrastructure
• Security and RBAC: Namespace-scoped access, secret filtering, audit logging, and rate limiting for all MCP servers
• Ruleset + Skill + MCP integration: Combined configuration that gives your AI assistants standards, patterns, and real-time context in a single, version-controlled setup
• Team rollout: Onboarding documentation, training sessions, and adoption tracking for MCP-enabled AI workflows

Your AI assistant should know your infrastructure as well as your senior engineers do. Let's give it the context it needs.