What is Devops Mcp

DevOps MCP (Model Context Protocol) is a production-ready platform that connects AI agents to DevOps tools through a unified, standardized API, enabling efficient interaction and management of conversation contexts.

Use cases

Use cases for devops-mcp include automating CI/CD pipelines, managing deployment contexts, performing semantic searches in DevOps documentation, and integrating AI-driven insights into DevOps workflows.

How to use

To use devops-mcp, ensure you have the prerequisites including Go 1.24+, Docker, PostgreSQL with pgvector, and Redis. Follow the quick start guide to set up the environment and integrate with your DevOps tools.

Key features

Key features include multi-tool integration with a unified API, efficient context management with S3 support, vector-based semantic search using pgvector, an event-driven architecture with SQS integration, and production-ready capabilities such as observability and circuit breakers.

Where to use

DevOps MCP can be used in software development environments, particularly where AI agents need to interact with various DevOps tools for automation, monitoring, and management tasks.

DevOps MCP (Model Context Protocol)

A production-ready platform connecting AI agents to DevOps tools through a unified, standardized API

Overview

DevOps MCP (Model Context Protocol) provides a standardized, secure interface for AI agents to interact with DevOps tools, manage conversation contexts, and perform vector-based semantic search. Built with Go workspaces for modular architecture, it bridges the gap between Large Language Models (LLMs) and external DevOps tools.

🚀 Key Capabilities

• Multi-Tool Integration: Unified API supporting GitHub, with extensible adapter pattern for additional tools
• Context Management: Efficient storage and retrieval of conversation contexts with S3 support
• Vector Search: Semantic search using pgvector with support for multiple embedding models
• Event-Driven Architecture: Asynchronous processing with SQS integration
• Production-Ready: Built-in observability, circuit breakers, and rate limiting

🏗️ Architecture

Built using Go workspaces for modularity and clean architecture:

• Three-Service Architecture: MCP server, REST API, and Worker services
• Adapter Pattern: Clean separation between business logic and external integrations
• Event-Driven: Asynchronous processing with AWS SQS support
• Resilience Patterns: Circuit breakers, retry logic, and bulkheads
• Observability: OpenTelemetry tracing and Prometheus metrics

🚀 Quick Start

Option 1: Using Pre-built Docker Images (Recommended)

The fastest way to get started - no build required!

# Clone for configuration files
git clone https://github.com/S-Corkum/devops-mcp.git
cd devops-mcp

# Copy environment configuration
cp .env.example .env
# Edit .env with your settings

# Pull and run the latest images
GITHUB_USERNAME={github-username} ./scripts/pull-images.sh
docker-compose -f docker-compose.prod.yml up -d

# Access services
# - MCP Server: http://localhost:8080
# - REST API: http://localhost:8081
# - Prometheus: http://localhost:9090
# - Grafana: http://localhost:3000

Option 2: Building from Source

For development or customization:

Prerequisites

• Go 1.24+ (required for workspace support)
• Docker & Docker Compose
• PostgreSQL 14+ with pgvector extension
• Redis 6.2+
• Make
• AWS credentials (optional, for S3/SQS integration)

Local Development

# Clone the repository
git clone https://github.com/S-Corkum/devops-mcp.git
cd devops-mcp

# Copy configuration template
cp config.yaml.example config.yaml
# Edit config.yaml with your settings (especially API tokens)

# Start infrastructure services (includes PostgreSQL, Redis, LocalStack)
make dev-setup

# Build all services
make build

# Run database migrations
make migrate-local

# Option 1: Start services (in separate terminals)
make run-mcp-server
make run-rest-api
make run-worker

# Option 2: Run all services with Docker Compose
make local-dev

# Verify health
curl http://localhost:8080/health
curl http://localhost:8081/health

📚 Documentation

• Quick Start Guide - Get up and running quickly
• Architecture Overview - System design and components
• API Reference - API endpoints and examples
• Development Environment - Setup for contributors
• Examples - Integration examples and use cases

Key Documentation

• Architecture: System Overview | Adapter Pattern | Go Workspace Structure
• Integration Examples: GitHub | AI Agent | Vector Search
• Developer Resources: Development Environment | Debugging Guide

📁 Project Structure

devops-mcp/
├── apps/                      # Go workspace applications
│   ├── mcp-server/           # Main MCP protocol server
│   │   ├── cmd/server/       # Server entrypoint
│   │   └── internal/         # Internal packages
│   ├── rest-api/             # REST API service
│   │   ├── cmd/api/          # API entrypoint
│   │   └── internal/         # Internal packages
│   └── worker/               # Event processing worker
│       ├── cmd/worker/       # Worker entrypoint
│       └── internal/         # Internal packages
├── pkg/                      # Shared packages (importable)
│   ├── adapters/            # External service adapters
│   ├── common/              # Common utilities
│   ├── database/            # Database abstractions
│   ├── embedding/           # Vector embedding services
│   ├── models/              # Shared data models
│   ├── observability/       # Logging, metrics, tracing
│   └── repository/          # Data access patterns
├── docs/                    # Documentation
├── scripts/                 # Utility scripts
├── migrations/              # Database migrations
├── configs/                 # Configuration files
├── go.work                  # Go workspace definition
└── Makefile                 # Build automation

🛠️ Technology Stack

• Language: Go 1.24+ with workspace support
• Databases: PostgreSQL 14+ (with pgvector), Redis 6.2+
• Message Queue: AWS SQS
• Storage: AWS S3 (optional)
• Observability: OpenTelemetry, Prometheus
• API Framework: Gin (REST API)
• Testing: Go testing package, testify, gomock

🐳 Docker Images

Pre-built Docker images are available on GitHub Container Registry:

• ghcr.io/{github-username}/devops-mcp-mcp-server - MCP protocol server
• ghcr.io/{github-username}/devops-mcp-rest-api - REST API service
• ghcr.io/{github-username}/devops-mcp-worker - Event processing worker
• ghcr.io/{github-username}/devops-mcp-mockserver - Mock server for testing

All images:

• Support multiple architectures (amd64, arm64)
• Are signed with Sigstore Cosign
• Include SBOMs (Software Bill of Materials)
• Follow semantic versioning

See Docker Registry Guide for detailed information.

🧪 Testing

# Run unit tests
make test

# Run integration tests (requires Docker)
make test-integration

# Run functional tests (requires full stack)
make test-functional

# Test coverage
make test-coverage

# Generate HTML coverage report
make test-coverage-html
open coverage.html

🚢 Deployment

The services are containerized and can be deployed using:

• Docker Compose: For local development and testing
• Kubernetes: Production deployment with Helm charts (coming soon)
• AWS ECS: Native AWS deployment option

See deployment documentation for detailed instructions.

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for:

• Code of Conduct
• Development workflow
• Coding standards
• Pull request process

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• OpenTelemetry for observability standards
• pgvector for vector similarity search
• The Go community for excellent tooling