MCP vs Manual vs A2A Nginx Installation

Introduction

This project simulates three different approaches to setting up a server (e.g., Nginx):

A traditional manual installation (simulated, not an actual system setup).
An automated installation using Anthropic's MCP (Model Context Protocol), which is actually connected and working in this project (connection steps are explained later in the file).
A simulated collaborative agent setup using Google's A2A (Agent2Agent Protocol).

The goal is to demonstrate how DevOps engineers in the near future could leverage both MCP and especially A2A to simplify their workflows, reduce time and effort, improve efficiency, and automate complex infrastructure tasks across tools and environments.

What is MCP?

Model Context Protocol (MCP) by Anthropic is an open protocol that standardizes how AI applications can connect to tools and data sources. It lets large language models understand available tools, access them securely, and decide how to use them without being hardcoded for each case. MCP simplifies complex operations into high-level intents.

What is A2A?

A2A (Agent2Agent Protocol) is a new open protocol introduced by Google just days ago. It enables AI agents to discover each other, communicate, and collaborate across different systems—even if the agents were built by different vendors. A2A empowers developers to build ecosystems of agents that can coordinate tasks together, creating smart, dynamic workflows.

Real-Life Example of What MCP Is:

Think of it as a kitchen tool that connects all your equipment. Instead of pulling out different devices and connecting them every time you need to cook, you have one system that connects everything and simplifies the work for you. The MCP agent works in a similar way—it connects data sources, making tasks like setting up servers faster and easier, without having to manually integrate each one separately.

Real-Life Example of What A2A Is:

Personal example: Automating daily errands through agents

Imagine you have a few personal AI agents:

An Email Agent
A Shopping Agent
A Calendar Agent

Without A2A:

Each agent works alone. You must manually send emails, book appointments, and shop.

With A2A:

You say: “I need to buy new headphones by tomorrow, and I’m only free between 5–6pm.”

The Email Agent checks your inbox.
The Calendar Agent verifies your availability.
The Shopping Agent finds matching deals.
They coordinate with each other and complete the task. You get an update with the delivery info and a calendar entry.

Prerequisites

Before you begin, make sure you have the following:

Python 3.x installed
Docker installed (for running MCP agent)
Visual Studio Code (VSCode) installed
Copilot Plugin installed in VSCode (this is used to interact with the MCP agent)

Step-by-Step Instructions

Step 2: Automating the Installation with MCP Agent

Install the Copilot Plugin in VSCode.
Open the JSON file in VSCode. Click "Start" to open the Copilot chat window.
Set Mode to "Agent" in the Copilot window.

Note: To use the MCP configuration, you will need a GitHub Personal Access Token. Go to your GitHub account → Settings → Developer settings → Personal access tokens, and generate a token with the appropriate permissions. Once generated, paste the token where prompted in the Copilot input field for github_token.

Use the Following JSON Code

{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "github_token",
        "description": "GitHub Personal Access Token",
        "password": true
      }
    ],
    "servers": {
      "github": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-e",
          "GITHUB_PERSONAL_ACCESS_TOKEN",
          "ghcr.io/github/github-mcp-server"
        ],
        "env": {
          "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
        }
      }
    }
  }
}

A2A Protocol Overview

A2A is Google's open protocol that enables agents to communicate, exchange information, and collaborate on complex tasks—even across vendors.

✅ Advantages

Agents collaborate with each other
Enables complex multi-agent workflows
Can work with different tools simultaneously
Real-time scaling, monitoring, and customization

⚠️ Disadvantages

Requires advanced initial setup
Still a very new (evolving) interface

🧪 Real-World DevOps A2A Example: Deployment & Cloud Maintenance

Imagine you're a DevOps engineer managing apps across AWS, GCP, and internal systems.

One agent manages Terraform infrastructure.
Another triggers CI/CD with Jenkins.
A third monitors performance with Prometheus.
A fourth sends updates via Slack.

Without A2A:

You manually integrate each step, deal with mismatches, and handle every connection manually.

With A2A:

Jenkins Agent runs a build.
Sends a "task" to the Terraform Agent to deploy.
If an error occurs, Monitoring Agent alerts the Slack Agent.

Now all agents communicate and sync—even if built with different tools.

🎯 Benefits:

For you: Smart automation of your digital tasks.
For DevOps: Modular agent-based systems that talk to each other without extra integrations.
More efficiency, less time wasted, scalable and transparent infrastructure.

📁 Project Structure

MCP-MANUAL-A2A-nginx-install/
├── install_nginx.sh
├── mcp_config.json
├── mcp_nginx_install.py
├── nginx_install.py
├── a2a_simulation.py
├── requirements.txt
└── README.md