ModelContextProtocol.io

High-performance context-aware protocol for AI systems

MCP Core Architecture

Function Transport

QUIC (UDP-based) for low-latency communication with optimized packet routing and congestion control.

Port: 5840

Session

JWT-based agent authentication with rotating keys and session timeouts for secure communication.

TTL: 24h

Context

Protocol Buffers encoding for efficient serialization with schema evolution support.

Version: proto3

Semantic

RDF/OWL knowledge graphs for rich semantic understanding and reasoning capabilities.

Format: Turtle

Action

OpenAPI-like task definitions with JSON Schema validation for consistent execution.

Spec: 3.0.0

PowerShell Installation

# MCP PowerShell Installation Script
# Version 1.2.0

param (
    [Parameter(Mandatory=$false)]
    [string]$InstallPath = "$env:ProgramFiles\MCP"
)

# Validate system requirements
if (-not (Test-Path "HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full")) {
    Write-Error ".NET Framework 4.8 or later required"
    exit 1
}

# Create installation directory
if (-not (Test-Path $InstallPath)) {
    New-Item -ItemType Directory -Path $InstallPath | Out-Null
}

# Download and extract MCP components
$ProgressPreference = 'SilentlyContinue'
Invoke-WebRequest -Uri "https://mcp.io/download/latest/windows" -OutFile "$InstallPath\mcp-core.zip"
Expand-Archive -Path "$InstallPath\mcp-core.zip" -DestinationPath $InstallPath -Force

# Register Windows service
New-Service -Name "MCP Agent" -BinaryPathName "$InstallPath\mcp-agent.exe" `
    -DisplayName "MCP Context Agent" -StartupType Automatic | Out-Null

# Configure firewall rules
if (Get-Command "New-NetFirewallRule" -ErrorAction SilentlyContinue) {
    New-NetFirewallRule -DisplayName "MCP QUIC" -Direction Inbound `
        -LocalPort 5840 -Protocol UDP -Action Allow | Out-Null
    
    New-NetFirewallRule -DisplayName "MCP HTTP/3" -Direction Inbound `
        -LocalPort 5841 -Protocol TCP -Action Allow | Out-Null
}

# Set environment variables
[Environment]::SetEnvironmentVariable("MCP_HOME", $InstallPath, "Machine")
[Environment]::SetEnvironmentVariable("MCP_JWT_SECRET", (New-Guid).Guid, "Machine")

# Verify installation
Start-Service "MCP Agent"
if ((Get-Service "MCP Agent").Status -ne "Running") {
    Write-Error "Service failed to start"
    exit 1
}

Write-Host "MCP installed successfully at $InstallPath" -ForegroundColor Green
PowerShell 7+ Windows 10/11 Admin Privileges .NET 4.8

System requirement validation

Checks for PowerShell version, .NET Framework, and OS compatibility before installation.

Automatic service registration

Creates and configures a Windows service for automatic startup and management.

Firewall configuration

Sets up necessary inbound rules for QUIC (UDP 5840) and HTTP/3 (TCP 5841).

Environment variables setup

Configures system-wide variables including installation path and JWT secret.

Post-install verification

Validates service startup and provides clear success/error messaging.

Protocol Specifications

Context Encoding (.mcproto)

syntax = "proto3";

message ContextFrame {
    string agent_id = 1;  // UUIDv4 format
    bytes semantic_graph = 2;  // RDF/Turtle serialized
    repeated Action actions = 3;
    
    message Action {
        string name = 1;
        map<string, string> parameters = 2;
        int32 priority = 3;  // 0-100 scale
    }
    
    // Timestamp in RFC 3339 format
    string timestamp = 4;
    
    // Optional digital signature
    bytes signature = 5;
}

Supported Serialization Formats

Protocol Buffers JSON MessagePack CBOR

Network Endpoints

Endpoint Protocol Port
mcp://agent.register QUIC 5840
mcp://context.push HTTP/3 5841
mcp://metrics.stream WebSocket 5842
mcp://admin.console HTTPS 5843

Endpoint Security

All endpoints require JWT authentication with rotating keys. QUIC connections use TLS 1.3 with 0-RTT.

3DS Automator Script (Node.js)

3DS Automator for MCP-PayPal Agent

Puppeteer Headless Chrome
const puppeteer = require('puppeteer');
const yargs = require('yargs');

const args = yargs
  .option('amount', { type: 'number', required: true })
  .option('token', { type: 'string', required: true })
  .argv;

(async () => {
  const browser = await puppeteer.launch({
    headless: true,
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  const page = await browser.newPage();

  try {
    // Simulate navigating to payment gateway's 3DS page
    await page.goto(`https://mcp-payment-gateway/3ds?token=${args.token}&amount=${args.amount}`);

    // Fill 3DS form (example selectors - adjust per your gateway)
    await page.type('#cardholder-name', 'MCP Payment Agent');
    await page.type('#verification-code', '123456');  // Mock OTP
    await page.click('#submit-3ds');

    // Wait for success/failure
    await page.waitForSelector('.auth-result', { timeout: 10000 });
    const result = await page.$eval('.auth-result', el => el.textContent.trim());

    // Output result to PowerShell
    console.log(result === 'Authentication successful' ? 'success' : 'failed');
  } catch (error) {
    console.error('failed');
  } finally {
    await browser.close();
  }
})();

Setup Instructions

# Install dependencies
npm install puppeteer yargs

# Run the script
node 3ds-automator.js \
  --amount 99.99 \
  --token "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

Configuration Options

  • --headless: Run browser in headless mode (default: true)
  • --timeout: Maximum wait time in ms (default: 10000)
  • --debug: Enable verbose logging

Hugging Face Spaces Deployment

MCP-PayPal Agent Space

FastAPI WebSocket

Dockerfile

FROM python:3.9-slim

# Install PowerShell 7
RUN apt-get update && \
    apt-get install -y wget apt-transport-https && \
    wget -q https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb && \
    dpkg -i packages-microsoft-prod.deb && \
    apt-get update && \
    apt-get install -y powershell

# Install Node.js for PM2/WebSocket
RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash - && \
    apt-get install -y nodejs

# Install dependencies
RUN npm install -g pm2
RUN pip install fastapi uvicorn websockets

# Copy scripts
COPY MCP-PayPal-Agent.ps1 /app/
COPY 3ds-automator.js /app/
COPY mcp-agent.js /app/

# Expose ports
EXPOSE 8080  # WebSocket
EXPOSE 5840  # MCP QUIC

# Start services
CMD ["pm2-runtime", "start", "/app/mcp-agent.js"]

FastAPI Webhook

from fastapi import FastAPI, WebSocket
import subprocess

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        # Execute PowerShell script on payment request
        result = subprocess.run(
            ["pwsh", "/app/MCP-PayPal-Agent.ps1", f"-OrderSource {data}"],
            capture_output=True, text=True
        )
        await websocket.send_text(result.stdout)

PM2 WebSocket Agent

const WebSocket = require('ws');
const { exec } = require('child_process');

const wss = new WebSocket.Server({ port: 8080 });
const MCP_LOGS = new Map();  // Track payment states

wss.on('connection', (ws) => {
  ws.on('message', async (message) => {
    const { auth, action, payload } = JSON.parse(message);
        
    if (auth === process.env.MCP_JWT_TOKEN) {
      switch (action) {
        case 'process-payment':
          exec(`pwsh ./MCP-PayPal-Agent.ps1 -OrderSource "${payload.source}"`, (error, stdout) => {
            MCP_LOGS.set(payload.id, stdout);
            ws.send(JSON.stringify({ status: 'completed', log: stdout }));
          });
          break;
              
        case 'get-status':
          ws.send(JSON.stringify({ status: 'pending', log: MCP_LOGS.get(payload.id) }));
          break;
      }
    }
  });
});

Deployment Steps

  1. 1 Authenticate with Hugging Face CLI: huggingface-cli login
  2. 2 Upload your space: huggingface-cli upload username/mcp-paypal-agent ./ --repo-type=space
  3. 3 Configure environment variables in Space settings (MCP_JWT_TOKEN, etc.)
  4. 4 Test WebSocket connection: websocat wss://your-hf-space.ngrok-free.app/ws

Key Integration Points

Component Purpose Port Protocol
PowerShell
7.2.0+
Payment logic and order processing - CLI
3DS Automator
Puppeteer
Headless authentication flows 9222 Chrome DevTools
PM2 WebSocket
Node.js
Real-time control interface 8080 WebSocket
MCP Protocol
Agent communication
Context-aware messaging 5840-5841 QUIC/HTTP3

Example Workflow

  1. 1

    User uploads order.pdf

    Customer uploads an invoice or order document to the Hugging Face Space interface.

    {
      "filename": "order.pdf",
      "size": "245KB",
      "type": "application/pdf"
    }
  2. 2

    WebSocket message sent

    Frontend initiates payment processing via WebSocket message with JWT authentication.

    {
      "auth": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
      "action": "process-payment",
      "payload": {
        "source": "order.pdf",
        "gateway": "PayPal"
      }
    }
  3. 3

    PowerScript execution

    PM2 triggers the MCP-PayPal-Agent.ps1 script which processes the payment through multiple steps.

    1. PDF Extraction 2. Payment Initiation 3. 3DS Authentication 4. Confirmation Email
  4. 4

    Result returned

    WebSocket connection receives the final status and transaction details.

    {
      "status": "completed",
      "transaction_id": "txn_GH123456789",
      "amount": 99.99,
      "currency": "USD",
      "timestamp": "2023-07-15T14:32:10Z"
    }

Made with DeepSite LogoDeepSite - 🧬 Remix