MCP Servers: Connecting AI Tools to Real-Time Documentation

As AI coding assistants become essential tools for DevOps and SRE teams, a fundamental problem emerges: LLMs are trained on static data that becomes outdated quickly. When you ask your AI assistant about the latest Kubernetes API changes or a new cloud provider feature, it might give you information from months ago.

Model Context Protocol (MCP) servers solve this by giving AI tools live access to authoritative documentation sources.

What is MCP?

Model Context Protocol is an open standard that allows AI assistants to safely connect to external data sources. Think of it as a standardized API layer between your AI tools and the information they need.

Instead of relying on training data snapshots, an MCP-enabled assistant can:

• Query live documentation
• Access current API references
• Retrieve up-to-date code examples
• Get the latest best practices

Google's Developer Knowledge API

Google recently launched the Developer Knowledge API with an official MCP server. This provides programmatic access to documentation from:

• Firebase
• Android Developer docs
• Google Cloud Platform
• Maps API
• And more Google developer resources

The documentation is re-indexed within 24 hours of updates, so your AI tools always have current information.

Setting Up the Google MCP Server

Here is how to connect Google's documentation to your AI workflow:

1. Create an API Key

Generate an API key in your Google Cloud Console:

# Navigate to APIs & Services > Credentials
# Create a new API key
# Restrict it to the Developer Knowledge API

2. Enable the MCP Server

Using the Google Cloud CLI:

gcloud beta services mcp enable developerknowledge.googleapis.com \
  --project=YOUR_PROJECT_ID

3. Configure Your Tool

Add the MCP server to your tool's configuration. For Claude Desktop:

{
  "mcpServers": {
    "google-developer-knowledge": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-google-developer-knowledge"],
      "env": {
        "GOOGLE_API_KEY": "your-api-key"
      }
    }
  }
}

For other tools like Cursor, VS Code with Continue, or custom setups, check the specific MCP configuration documentation.

Practical Use Cases for DevOps

Infrastructure Documentation Queries

"What are the current GKE node pool autoscaling limits?"
"Show me the latest Cloud Run concurrency configuration options."
"What changed in the Firebase Admin SDK v12?"

Troubleshooting with Current Docs

"Check the docs for fixing ApiNotActivatedMapError"
"What does GCP error code RESOURCE_EXHAUSTED mean for Pub/Sub?"

Comparing Services

"Compare Cloud Run vs Cloud Functions for async job processing"
"What are the differences between Firestore and Realtime Database for my use case?"

Building Your Own MCP Server

For internal documentation or custom knowledge bases, you can build MCP servers using the official SDKs:

TypeScript:

import { Server } from "@modelcontextprotocol/sdk/server";

const server = new Server({
  name: "internal-docs",
  version: "1.0.0"
});

server.setRequestHandler("search", async (request) => {
  const query = request.params.query;
  // Query your internal documentation system
  const results = await searchInternalDocs(query);
  return { results };
});

server.setRequestHandler("retrieve", async (request) => {
  const docId = request.params.id;
  // Fetch full document content
  const content = await getDocument(docId);
  return { content };
});

Python:

from mcp import Server

server = Server("internal-docs")

@server.handler("search")
async def search(query: str):
    results = await search_internal_docs(query)
    return {"results": results}

@server.handler("retrieve")
async def retrieve(doc_id: str):
    content = await get_document(doc_id)
    return {"content": content}

MCP Servers for DevOps Tools

Beyond documentation, MCP servers can connect AI assistants to:

• Monitoring systems: Query Prometheus, Datadog, or Grafana
• Incident management: Access PagerDuty or Opsgenie data
• Infrastructure state: Read Terraform state or Kubernetes resources
• Runbooks: Retrieve internal playbooks and procedures

Example: connecting to your Kubernetes cluster:

server.setRequestHandler("get-pods", async (request) => {
  const namespace = request.params.namespace || "default";
  const pods = await k8sClient.listNamespacedPod(namespace);
  return {
    pods: pods.body.items.map(p => ({
      name: p.metadata.name,
      status: p.status.phase,
      restarts: p.status.containerStatuses?.[0]?.restartCount || 0
    }))
  };
});

Security Considerations

When deploying MCP servers in production:

1. API key rotation: Rotate keys regularly and use secret management
2. Scope restrictions: Limit what each MCP server can access
3. Audit logging: Log all queries for compliance and debugging
4. Network isolation: Run MCP servers in trusted network segments
5. Rate limiting: Protect against excessive API usage

What This Means for DevOps Teams

MCP servers represent a shift in how we build AI-powered tooling:

• Accuracy: AI responses based on current documentation, not stale training data
• Trust: Point to authoritative sources instead of hallucinated answers
• Integration: Connect AI assistants to your existing knowledge systems
• Automation: Build smarter runbooks that can query live infrastructure state

As more vendors release official MCP servers, expect tighter integration between AI coding assistants and the tools DevOps teams use daily.

Getting Started

1. Try Google's Developer Knowledge MCP server with your preferred AI tool
2. Identify internal documentation that would benefit from MCP access
3. Start with read-only MCP servers before adding write capabilities
4. Monitor usage patterns to understand how your team uses AI-assisted documentation

The future of DevOps automation includes AI that can read the manual for you, and MCP makes that possible today.

---

Akmatori helps DevOps teams build reliable, AI-powered infrastructure automation. Explore our open-source tools or learn more at akmatori.com.