MCP Server DevOps Bridge - MCP Server

MCP Server DevOps Bridge 🚀

Connect your DevOps tools with the power of AI

This project evolved from a simple experiment into a powerful bridge between your essential DevOps platforms, providing a unified interface through Claude and other AI assistants. With integrated agent capabilities, it can even delegate work autonomously!

🌉 Bridge Your DevOps Tools

Connect your essential DevOps platforms with a natural language interface:

Azure DevOps - Work items, wiki, sprints, and project management
GitHub - Pull requests, code reviews, repositories
Slack - Team communication, notifications, updates
Browser Automation - Web interactions, screenshots, JavaScript execution
AI Agents - Delegate tasks to autonomous AI agents

🎯 Key Benefits

Natural Language Interface - Interact with your tools using plain English
Cross-Platform Integration - Work items link to PRs, PRs trigger notifications
Unified Workflow - Let AI handle the context switching between tools
Flexible Architecture - Easy to extend with new integrations
Autonomous Workflows - Create AI agents to handle repetitive tasks

🚀 Getting Started

Prerequisites

Go 1.23.4 or later
Docker (required for agent system)
Access tokens for your platforms:
- Azure DevOps PAT
- GitHub PAT (optional)
- Slack Bot Token (optional)
- OpenAI API Key (for agents)

Installation

Clone and build:

git clone https://github.com/theapemachine/mcp-server-devops-bridge
cd mcp-server-devops-bridge
go build

Configure your environment:

export AZURE_DEVOPS_ORG="your-org"
export AZDO_PAT="your-pat-token"
export AZURE_DEVOPS_PROJECT="your-project"

# Optional integrations
export GITHUB_PAT="your-github-pat"
export SLACK_BOT_TOKEN="your-slack-token"
export DEFAULT_SLACK_CHANNEL="some-slack-channel-id"

# AI and Memory integrations
export OPENAI_API_KEY="your-api-key"
export QDRANT_URL="http://localhost:6333"
export QDRANT_API_KEY="your-qdrant-api-key"
export NEO4J_URL="http://localhost:7474"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your-neo4j-password"

Add to Claude's configuration:

{
  "mcpServers": {
    "devops-bridge": {
      "command": "/full/path/to/mcp-server-devops-bridge/mcp-server-devops-bridge",
      "args": [],
      "env": {
        "AZURE_DEVOPS_ORG": "organization",
        "AZDO_PAT": "personal_access_token",
        "AZURE_DEVOPS_PROJECT": "project",
        "SLACK_DEFAULT_CHANNEL": "channel_id",
        "SLACK_BOT_TOKEN": "bot_token",
        "GITHUB_PAT": "personal_access_token",
        "OPENAI_API_KEY": "openaikey",
        "QDRANT_URL": "http://localhost:6333",
        "QDRANT_API_KEY": "yourkey",
        "NEO4J_URL": "yourneo4jinstance",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "neo4jpassword"
      }
    }
  }
}

💡 Example Workflows

Cross-Platform Task Management

"Create a user story for the new authentication feature, link it to the existing GitHub PR #123, and notify the team in Slack"

Code Review Workflow

"Find all work items related to authentication, show their linked PRs, and summarize recent code review comments"

Status Reporting

"Generate a sprint report including:
- Work item status from Azure Boards
- PR review status from GitHub
- Team discussions from Slack"

Documentation Management

"Update the wiki page for authentication and link it to relevant work items and PRs"

Autonomous Agent Workflow

"Create an agent to monitor our authentication PRs, summarize code changes, and post daily updates to Slack"

🔌 Key Features

Agents System

The project includes a powerful agent system built on OpenAI's GPT-4o-mini, enabling Claude to create its own long-running agents that can:

Execute tasks autonomously in secure Docker containers
Communicate with other agents
Access system tools and commands
Process tasks in the background
Run commands in isolated environments for security

Under the hood, each agent runs inside a dedicated Docker container, providing:

Isolated execution environment
Secure command execution
Controlled access to host resources
Clean separation between agents

Azure DevOps Integration

Work Item Management
- Create, update, and query work items
- Add/remove tags
- Manage work item attachments
- Add comments and track discussions
- Create work items from templates
- Manage work item relationships
Wiki Management
- Create and update wiki pages
- Search wiki content
- Retrieve page content and subpages
Sprint Management
- Query current and upcoming sprints
- Track sprint progress

GitHub Integration

Pull Request Management
- List open/closed pull requests
- Get detailed PR information
- Review and comment on PRs
Code Search
- Search across repositories
- Filter by path, language, and repository

Slack Integration

Message Formatting
- Format messages using Block Kit
- Support for headers, sections, and context blocks
Message Search
- Search message history
- Filter by channel and user
Message Posting
- Post messages to channels
- Support for threaded replies
- Rich message formatting with blocks

Browser Automation

Web Navigation
- Open websites
- Execute JavaScript
- Take screenshots
- Wait for elements
Form Filling
- Input text
- Click buttons
- Handle dropdowns
Data Extraction
- Scrape content
- Process results

Memory Management

Vector Storage (Qdrant)
- Semantic search capabilities
- Document storage with metadata
- Similarity search with configurable thresholds
Graph Database (Neo4j)
- Store relationships between memories
- Query using Cypher
- Track temporal relationships

AI Integration

Claude Integration
- Direct chat capabilities
- Memory-augmented conversations
- Context-aware responses
OpenAI Integration
- GPT-4 integration for agents
- Memory retrieval and formatting
- Structured output generation

Code Analysis

Code complexity analysis
Potential bug detection
Security issue identification
Context storage for future reference

Cross-Integration Features

Status Report Generation
- Combine data from multiple sources
- Sprint status reports
- Work item summaries
- PR status integration
Work Item Reminders
- Slack notifications
- Customizable messages
- Automated tracking
Standup Report Generation
- Team-based reporting
- State-grouped work items
- Rich Slack formatting

🛠 Architecture

The bridge uses the Model Context Protocol to provide Claude with structured access to your DevOps tools. This enables:

Type-safe operations
Proper error handling
Clear feedback
Extensible design

🔒 Security

Store access tokens securely
Grant minimal required permissions
Regularly rotate credentials
Audit integration access

Alternative Setup: start.sh

If you don't have direct access to modify environment variables, create a start.sh script and make it executable:

#!/bin/bash

# Azure DevOps Configuration
export AZURE_DEVOPS_ORG="YOUR ORG"
export AZDO_PAT="YOUR PAT"
export AZURE_DEVOPS_PROJECT="YOUR PROJECT"

# GitHub Configuration
export GITHUB_PAT="YOUR PAT"

# Slack Configuration
export SLACK_BOT_TOKEN="YOUR TOKEN"
export DEFAULT_SLACK_CHANNEL="YOUR CHANNEL ID"

# OpenAI Configuration
export OPENAI_API_KEY="YOUR API KEY"

# Qdrant Configuration
export QDRANT_URL="http://localhost:6333"
export QDRANT_API_KEY="your-qdrant-api-key"

# Neo4j Configuration
export NEO4J_URL="http://localhost:7474"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your-neo4j-password"

# Email Configuration (if using email features)
export EMAIL_INBOX_WEBHOOK_URL="YOUR WEBHOOK URL"
export EMAIL_SEARCH_WEBHOOK_URL="YOUR WEBHOOK URL"
export EMAIL_REPLY_WEBHOOK_URL="YOUR WEBHOOK URL"

/path/to/mcp-server-devops-bridge/mcp-server-devops-bridge

🤝 Contributing

We welcome contributions! Key areas for enhancement:

Additional platform integrations (GitLab, Jira, etc.)
Enhanced cross-platform workflows
Improved reporting capabilities
New integration patterns

📝 License

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

🆘 Support

Open an issue for bugs or feature requests
Check discussions for common questions
Review wiki for implementation guides

🧠 Memory System

The bridge implements an intelligent memory system that enables AI assistants to automatically:

Retrieve relevant memories before responding to queries
Store important context from interactions for future reference

Memory Architecture

The memory system uses a dual-store approach:

Vector Storage (Qdrant) - For semantic search of unstructured text
Graph Database (Neo4j) - For entity relationships and structured queries

Automatic Memory Integration

The system includes a middleware layer that enhances MCP tools with memory capabilities:

// Apply memory middleware to any tool handler
wrappedHandler := MemoryMiddleware(originalHandler)

This middleware:

Automatically searches for relevant memories based on the tool and query
Injects found memories into the context before the response
Extracts and stores important information from interactions

Memory Flow

Query Phase: Before processing a tool request
- Extract query context from the tool parameters
- Search vector and graph stores for relevant memories
- Format memories for inclusion in the response
Response Phase: After processing a tool request
- Analyze the response for important information
- Use OpenAI to extract structured knowledge
- Store in both vector and graph databases

Benefits

Contextual Awareness: AI can recall relevant facts from previous interactions
Knowledge Persistence: Important information is automatically preserved
Cross-Session Memory: Context is maintained between different conversations
Transparent Enhancement: Memory injection is automatic and seamless

Usage

Memory-enhancing specific tools is simple:

// Create your tool
myTool := mcp.NewTool("my_tool", /* ... */);

// Original handler function
func handleMyTool(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
    // Tool implementation
}

// Wrap with memory middleware
wrappedHandler := MemoryMiddleware(handleMyTool)

// Register with MCP server
mcpServer.AddTool(myTool, wrappedHandler)

Configuration

The memory system can be configured through environment variables:

# Vector Store (Qdrant)
export QDRANT_URL="http://localhost:6333"
export QDRANT_API_KEY="your-qdrant-api-key"

# Graph Database (Neo4j)
export NEO4J_URL="http://localhost:7474"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your-neo4j-password"

# OpenAI (for memory extraction)
export OPENAI_API_KEY="your-openai-key"

MCP Server DevOps Bridge with Agent System

This repository contains the code for an MCP (Mission Control Panel) server DevOps bridge with a powerful agent system that allows AI models to create, manage, and coordinate long-running agents.

Overview

The system allows AI models to:

Create new long-running agents with customized system prompts and tasks
Send commands to existing agents
Facilitate communication between agents through a messaging system
Monitor and manage agent lifecycles

Key Components

Agent Management

The system provides tools for:

Creating Agents: Create new agents with custom system prompts and tasks
Listing Agents: View all running agents and their status
Sending Commands: Send instructions or queries to specific agents
Subscribing to Topics: Have agents listen for messages on specific channels
Killing Agents: Terminate agents when they're no longer needed

Inter-Agent Communication

Agents can communicate with each other through:

Message Bus: A central messaging system that routes messages to subscribed agents
Topics: Channels that agents can publish to and subscribe to
Direct Commands: Send direct instructions to specific agents

System Tools

The system provides tools for:

Command Execution: Run system commands with proper security controls
Messaging: Send and receive messages between agents
Agent Management: Create, monitor, and terminate agents

Usage

Creating and Coordinating Agents

// Get all agent-related tools
tools := ai.GetAllToolsAsOpenAI()

// Create an OpenAI client
client := openai.NewClient()

// Use OpenAI to coordinate agents
messages := []openai.ChatCompletionMessageParamUnion{
    openai.SystemMessage(`You are a coordinator of AI agents.`),
    openai.UserMessage("Create two agents and have them work together."),
}

// Call OpenAI with our tools
params := openai.ChatCompletionNewParams{
    Model:    openai.F(openai.ChatModelGPT4o),
    Messages: openai.F(messages),
    Tools:    openai.F(tools),
}

// Process the response and handle tool calls
// ...

Example Agent Workflow

Create Agents: Create specialized agents for different tasks

Tool: agent
Arguments: {"id": "researcher", "system_prompt": "You are a research agent...", "task": "Find information about climate change"}

Subscribe to Topics: Have agents listen for relevant messages

Tool: subscribe_agent
Arguments: {"agent_id": "writer", "topic": "research_results"}

Send Messages: Share information between agents

Tool: send_agent_message
Arguments: {"topic": "research_results", "content": "Here is the information I found..."}

Send Commands: Give direct instructions to agents

Tool: send_command
Arguments: {"agent_id": "writer", "command": "Summarize the research in 3 paragraphs"}

Security

The system implements several security measures:

Agents only have access to the commands and paths explicitly granted to them
Command execution is containerized to provide isolation
All communication is managed through controlled channels

Getting Started

See the examples/agent_example.go file for a complete example of how to use the agent system to create and coordinate multiple agents.