/mcp-gateway-registry

Enterprise-ready MCP Gateway & Registry that centralizes AI development tools with secure OAuth authentication, dynamic tool discovery, and unified access for both autonomous AI agents and AI coding assistants. Transform scattered MCP server chaos into governed, auditable tool access with Keycloak/Cognito integration.

Primary LanguagePythonApache License 2.0Apache-2.0

MCP Gateway & Registry Logo

Unified Agent & MCP Server Registry – Enterprise-Ready Gateway for AI Development Tools

GitHub stars GitHub forks GitHub issues License GitHub release

🚀 Get Running Now | Quick Start | Documentation | Enterprise Features | Community

Demo Videos: ⭐ MCP Registry CLI Demo | Full End-to-End Functionality | OAuth 3-Legged Authentication | Dynamic Tool Discovery

What is MCP Gateway & Registry?

The MCP Gateway & Registry is a unified, enterprise-ready platform that centralizes access to both MCP Servers and AI Agents using the Model Context Protocol (MCP). It serves three core functions:

  1. Unified MCP Server Gateway – Centralized access point for multiple MCP servers
  2. MCP Servers Registry – Register, discover, and manage access to MCP servers with unified governance
  3. Agent Registry & A2A Communication Hub – Agent registration, discovery, governance, and direct agent-to-agent communication through the A2A (Agent-to-Agent) Protocol

The platform integrates with external registries such as Anthropic's MCP Registry (and more to come), providing a single control plane for both tool access, agent orchestration, and agent-to-agent communication patterns.

Why unified? Instead of managing hundreds of individual MCP server configurations, agent connections, and separate governance systems across your development teams, this platform provides secure, governed access to curated MCP servers and registered agents through a single, unified control plane.

Transform this chaos:

❌ AI agents require separate connections to each MCP server
❌ Each developer configures VS Code, Cursor, Claude Code individually
❌ Developers must install and manage MCP servers locally
❌ No standard authentication flow for enterprise tools
❌ Scattered API keys and credentials across tools
❌ No visibility into what tools teams are using
❌ Security risks from unmanaged tool sprawl
❌ No dynamic tool discovery for autonomous agents
❌ No curated tool catalog for multi-tenant environments
❌ A2A provides agent cards but no way for agents to discover other agents
❌ Maintaining separate MCP server and agent registries is a non-starter for governance
❌ Impossible to maintain unified policies across server and agent access

Into this organized approach:

✅ AI agents connect to one gateway, access multiple MCP servers
✅ Single configuration point for VS Code, Cursor, Claude Code
✅ Central IT manages cloud-hosted MCP infrastructure via streamable HTTP
✅ Developers use standard OAuth 2LO/3LO flows for enterprise MCP servers
✅ Centralized credential management with secure vault integration
✅ Complete visibility and audit trail for all tool usage
✅ Enterprise-grade security with governed tool access
✅ Dynamic tool discovery and invocation for autonomous workflows
✅ Registry provides discoverable, curated MCP servers for multi-tenant use
✅ Agents can discover and communicate with other agents through unified Agent Registry
✅ Single control plane for both MCP servers and agent governance
✅ Unified policies and audit trails for both server and agent access

┌─────────────────────────────────────┐     ┌──────────────────────────────────────────────────────┐
│          BEFORE: Chaos              │     │    AFTER: MCP Gateway & Registry                     │
├─────────────────────────────────────┤     ├──────────────────────────────────────────────────────┤
│                                     │     │                                                      │
│  Developer 1 ──┬──► MCP Server A    │     │  Developer 1 ──┐                  ┌─ MCP Server A    │
│                ├──► MCP Server B    │     │                │                  ├─ MCP Server B    │
│                └──► MCP Server C    │     │  Developer 2 ──┼──► MCP Gateway   │                  │
│                                     │     │                │    & Registry ───┼─ MCP Server C    │
│  Developer 2 ──┬──► MCP Server A    │ ──► │  AI Agent 1 ───┘         │        │                  │
│                ├──► MCP Server D    │     │                          │        ├─ AI Agent 1      │
│                └──► MCP Server E    │     │  AI Agent 2 ──────────────┤        ├─ AI Agent 2     │
│                                     │     │                          │        │                  │
│  AI Agent 1 ───┬──► MCP Server B    │     │  AI Agent 3 ──────────────┘        └─ AI Agent 3     │
│                ├──► MCP Server C    │     │                                                      │
│                └──► MCP Server F    │     │              Single Connection Point                 │
│                                     │     │                                                      │
│  ❌ Multiple connections per user  │     │         ✅ One gateway for all                      │
│  ❌ No centralized control         │     │         ✅ Unified server & agent access            │
│  ❌ Credential sprawl              │     │         ✅ Unified governance & audit trails        │
└─────────────────────────────────────┘     └──────────────────────────────────────────────────────┘

Note on Agent-to-Agent Communication: AI Agents discover other AI Agents through the unified Agent Registry and communicate with them directly (peer-to-peer) without routing through the MCP Gateway. The Registry handles discovery, authentication, and access control, while agents maintain direct connections for efficient, low-latency communication.

Unified Agent & Server Registry

This platform serves as a comprehensive, unified registry supporting:

  • ✅ MCP Server Registration & Discovery – Register, discover, and manage access to MCP servers
  • ✅ AI Agent Registration & Discovery – Register agents and enable them to discover other agents
  • ✅ Agent-to-Agent (A2A) Communication – Direct agent-to-agent communication patterns using the A2A protocol
  • ✅ Multi-Protocol Support – Support for various agent communication protocols and patterns
  • ✅ Unified Governance – Single policy and access control system for both agents and servers
  • ✅ Cross-Protocol Agent Discovery – Agents can discover each other regardless of implementation
  • ✅ Integrated External Registries – Connect with Anthropic's MCP Registry and other external sources
  • ✅ Agent Cards & Metadata – Rich metadata for agent capabilities, skills, and authentication schemes

Key distinction: Unlike separate point solutions, this unified registry eliminates the need to maintain separate MCP server and agent systems, providing a single control plane for agent orchestration, MCP server access, and agent-to-agent communication.

MCP Servers & Agents Registry

Watch how MCP Servers, A2A Agents, and External Registries work together for dynamic tool discovery:

MCP-Gateway-Registry-vidcast.mp4

MCP Tools in Action

View MCP Tools Demo

MCP Registry CLI

Interactive terminal interface for chatting with AI models and discovering MCP tools in natural language. Talk to the registry using a Claude Code-like conversational interface with real-time token status, cost tracking, and AI model selection.

MCP Registry CLI Screenshot

Quick Start: registry --url https://mcpgateway.ddns.net | Full Guide

What's New

  • 🔗 Agent-to-Agent (A2A) Protocol Support - Agents can now register, discover, and communicate with other agents through a secure, centralized registry. Enable autonomous agent ecosystems with Keycloak-based access control and fine-grained permissions. A2A Guide
  • 🤖 Agentic CLI for MCP Registry - Talk to the Registry in natural language using a Claude Code-like interface. Discover tools, ask questions, and execute MCP commands conversationally. Learn more
  • 💬 Interactive MCP-Registry CLI - Terminal-based chat interface with AI-powered MCP tool discovery. Supports Amazon Bedrock and Anthropic API. MCP-Registry CLI
  • 🔒 MCP Server Security Scanning - Integrated vulnerability scanning with Cisco AI Defence MCP Scanner. Automatic security scans during server registration, periodic registry-wide scans with detailed markdown reports, and automatic disabling of servers with security issues.
  • 📥 Import Servers from Anthropic MCP Registry - Import curated MCP servers from Anthropic's registry with a single command. Import Guide
  • 🔌 Anthropic MCP Registry REST API Compatibility - Full compatibility with Anthropic's MCP Registry REST API specification. API Documentation
  • 🚀 Pre-built Images - Deploy instantly with pre-built Docker images. Get Started | macOS Guide
  • 🔐 Keycloak Integration - Enterprise authentication with AI agent audit trails and group-based authorization. Learn more
  • 📊 Real-Time Metrics & Observability - Grafana dashboards with SQLite and OpenTelemetry integration. Observability Guide
  • Amazon Bedrock AgentCore Integration - AgentCore Gateway support with dual authentication. Integration Guide

Core Use Cases

AI Agent & Coding Assistant Governance

Provide both autonomous AI agents and human developers with secure access to approved tools through AI coding assistants (VS Code, Cursor, Claude Code) while maintaining IT oversight and compliance.

Enterprise Security & Compliance

Centralized authentication, fine-grained permissions, and comprehensive audit trails for SOX/GDPR compliance pathways across both human and AI agent access patterns.

Dynamic Tool Discovery

AI agents can autonomously discover and execute specialized tools beyond their initial capabilities using intelligent semantic search, while developers get guided tool discovery through their coding assistants.

Unified Access Gateway

Single gateway supporting both autonomous AI agents (machine-to-machine) and AI coding assistants (human-guided) with consistent authentication and tool access patterns.

Architecture

The MCP Gateway & Registry provides a unified platform for both autonomous AI agents and AI coding assistants to access enterprise-curated tools through a centralized gateway with comprehensive authentication and governance.

flowchart TB
    subgraph Human_Users["Human Users"]
        User1["Human User 1"]
        User2["Human User 2"]
        UserN["Human User N"]
    end

    subgraph AI_Agents["AI Agents"]
        Agent1["AI Agent 1"]
        Agent2["AI Agent 2"]
        Agent3["AI Agent 3"]
        AgentN["AI Agent N"]
    end

    subgraph EC2_Gateway["<b>MCP Gateway & Registry</b> (Amazon EC2 Instance)"]
        subgraph NGINX["NGINX Reverse Proxy"]
            RP["Reverse Proxy Router"]
        end
        
        subgraph AuthRegistry["Authentication & Registry Services"]
            AuthServer["Auth Server<br/>(Dual Auth)"]
            Registry["Registry<br/>Web UI"]
            RegistryMCP["Registry<br/>MCP Server"]
        end
        
        subgraph LocalMCPServers["Local MCP Servers"]
            MCP_Local1["MCP Server 1"]
            MCP_Local2["MCP Server 2"]
        end
    end
    
    %% Identity Provider
    IdP[Identity Provider<br/>Keycloak/Cognito]
    
    subgraph EKS_Cluster["Amazon EKS/EC2 Cluster"]
        MCP_EKS1["MCP Server 3"]
        MCP_EKS2["MCP Server 4"]
    end
    
    subgraph APIGW_Lambda["Amazon API Gateway + AWS Lambda"]
        API_GW["Amazon API Gateway"]
        Lambda1["AWS Lambda Function 1"]
        Lambda2["AWS Lambda Function 2"]
    end
    
    subgraph External_Systems["External Data Sources & APIs"]
        DB1[(Database 1)]
        DB2[(Database 2)]
        API1["External API 1"]
        API2["External API 2"]
        API3["External API 3"]
    end
    
    %% Connections from Human Users
    User1 -->|Web Browser<br>Authentication| IdP
    User2 -->|Web Browser<br>Authentication| IdP
    UserN -->|Web Browser<br>Authentication| IdP
    User1 -->|Web Browser<br>HTTPS| Registry
    User2 -->|Web Browser<br>HTTPS| Registry
    UserN -->|Web Browser<br>HTTPS| Registry
    
    %% Connections from Agents to Gateway
    Agent1 -->|MCP Protocol<br>SSE with Auth| RP
    Agent2 -->|MCP Protocol<br>SSE with Auth| RP
    Agent3 -->|MCP Protocol<br>Streamable HTTP with Auth| RP
    AgentN -->|MCP Protocol<br>Streamable HTTP with Auth| RP
    
    %% Auth flow connections
    RP -->|Auth validation| AuthServer
    AuthServer -.->|Validate credentials| IdP
    Registry -.->|User authentication| IdP
    RP -->|Tool discovery| RegistryMCP
    RP -->|Web UI access| Registry
    
    %% Connections from Gateway to MCP Servers
    RP -->|SSE| MCP_Local1
    RP -->|SSE| MCP_Local2
    RP -->|SSE| MCP_EKS1
    RP -->|SSE| MCP_EKS2
    RP -->|Streamable HTTP| API_GW
    
    %% Connections within API GW + Lambda
    API_GW --> Lambda1
    API_GW --> Lambda2
    
    %% Connections to External Systems
    MCP_Local1 -->|Tool Connection| DB1
    MCP_Local2 -->|Tool Connection| DB2
    MCP_EKS1 -->|Tool Connection| API1
    MCP_EKS2 -->|Tool Connection| API2
    Lambda1 -->|Tool Connection| API3

    %% Style definitions
    classDef user fill:#fff9c4,stroke:#f57f17,stroke-width:2px
    classDef agent fill:#e1f5fe,stroke:#29b6f6,stroke-width:2px
    classDef gateway fill:#e8f5e9,stroke:#66bb6a,stroke-width:2px
    classDef nginx fill:#f3e5f5,stroke:#ab47bc,stroke-width:2px
    classDef mcpServer fill:#fff3e0,stroke:#ffa726,stroke-width:2px
    classDef eks fill:#ede7f6,stroke:#7e57c2,stroke-width:2px
    classDef apiGw fill:#fce4ec,stroke:#ec407a,stroke-width:2px
    classDef lambda fill:#ffebee,stroke:#ef5350,stroke-width:2px
    classDef dataSource fill:#e3f2fd,stroke:#2196f3,stroke-width:2px
    
    %% Apply styles
    class User1,User2,UserN user
    class Agent1,Agent2,Agent3,AgentN agent
    class EC2_Gateway,NGINX gateway
    class RP nginx
    class AuthServer,Registry,RegistryMCP gateway
    class IdP apiGw
    class MCP_Local1,MCP_Local2 mcpServer
    class EKS_Cluster,MCP_EKS1,MCP_EKS2 eks
    class API_GW apiGw
    class Lambda1,Lambda2 lambda
    class DB1,DB2,API1,API2,API3 dataSource
Loading

Key Architectural Benefits:

  • Unified Gateway: Single point of access for both AI agents and human developers through coding assistants
  • Dual Authentication: Supports both human user authentication and machine-to-machine agent authentication
  • Scalable Infrastructure: Nginx reverse proxy with horizontal scaling capabilities
  • Multiple Transports: SSE and Streamable HTTP support for different client requirements

Key Advantages

Enterprise-Grade Security

  • OAuth 2.0/3.0 compliance with IdP integration
  • Fine-grained access control at tool and method level
  • Zero-trust network architecture
  • Complete audit trails and comprehensive analytics for compliance

AI Agent & Developer Experience

  • Single configuration works across autonomous AI agents and AI coding assistants (VS Code, Cursor, Claude Code, Cline)
  • Dynamic tool discovery with natural language queries for both agents and humans
  • Instant onboarding for new team members and AI agent deployments
  • Unified governance for both AI agents and human developers

Production Ready

  • Container-native (Docker/Kubernetes)
  • Real-time health monitoring and alerting
  • Dual authentication supporting both human and machine authentication

Quick Start

📱 Running on macOS? See our macOS Setup Guide for platform-specific instructions and optimizations.

Option A: Pre-built Images (Instant Setup)

Get running in under 2 minutes with pre-built containers:

Step 1: Clone and setup

git clone https://github.com/agentic-community/mcp-gateway-registry.git
cd mcp-gateway-registry
cp .env.example .env

Step 2: Download embeddings model Download the required sentence-transformers model to the shared models directory:

hf download sentence-transformers/all-MiniLM-L6-v2 --local-dir ${HOME}/mcp-gateway/models/all-MiniLM-L6-v2

Step 3: Configure environment Complete: Initial Environment Configuration - Configure domains, passwords, and authentication

export DOCKERHUB_ORG=mcpgateway

Step 4: Deploy with pre-built images

./build_and_run.sh --prebuilt

For detailed information about all Docker images used with --prebuilt, see Pre-built Images Documentation.

Step 5: Initialize Keycloak Complete: Initialize Keycloak Configuration - Set up identity provider and security policies

Step 5.5: Set up users and service accounts Run the bootstrap script to create default users and M2M service accounts:

./cli/bootstrap_user_and_m2m_setup.sh

This script:

  • Creates 3 Keycloak groups: registry-users-lob1, registry-users-lob2, registry-admins
  • Creates 6 users for testing and management:
    • LOB1: lob1-bot (M2M service account) and lob1-user (human user)
    • LOB2: lob2-bot (M2M service account) and lob2-user (human user)
    • Admin: admin-bot (M2M service account) and admin-user (human user)
  • Generates and saves OAuth credentials to .oauth-tokens/ directory

All user passwords default to the value set in your .env file (INITIAL_USER_PASSWORD).

Step 6: Access the registry

open http://localhost:7860

Step 7: Create your first agent Complete: Create Your First AI Agent Account - Create agent credentials for testing

Step 8: Restart auth server to apply new credentials

docker-compose down auth-server && docker-compose rm -f auth-server && docker-compose up -d auth-server

Step 9: Test the setup Complete: Testing with mcp_client.py and agent.py - Validate your setup works correctly

Benefits: No build time • No Node.js required • No frontend compilation • Consistent tested images

Option B: Build from Source

New to MCP Gateway? Start with our Complete Setup Guide for detailed step-by-step instructions from scratch on AWS EC2.

Testing & Integration Options

Python Scripts:

  • ./cli/mcp_client.py - Core MCP operations (ping, list tools, call tools)
  • ./tests/mcp_cmds.sh - Shell-based MCP testing operations

Python Agent:

  • agents/agent.py - Full-featured Python agent with advanced AI capabilities

Next Steps: Testing Guide | Complete Installation Guide | Authentication Setup | AI Assistant Integration

Enterprise Features

AI Agents & Coding Assistants Integration

Transform how both autonomous AI agents and development teams access enterprise tools with centralized governance:

Roo Code MCP Configuration

Enterprise-curated MCP servers accessible through unified gateway

 Roo Code Agent in Action

AI assistants executing approved enterprise tools with governance

Observability

Comprehensive real-time metrics and monitoring through Grafana dashboards with dual-path storage: SQLite for detailed historical analysis and OpenTelemetry (OTEL) export for integration with Prometheus, CloudWatch, Datadog, and other monitoring platforms. Track authentication events, tool executions, discovery queries, and system performance metrics. Learn more

Grafana Metrics Dashboard

Real-time metrics and observability dashboard tracking server health, tool usage, and authentication events

Anthropic MCP Registry Integration

Seamlessly integrate with Anthropic's official MCP Registry to import and access curated MCP servers through your gateway:

  • Import Servers: Select and import desired servers from Anthropic's registry with a single command
  • Unified Access: Access imported servers through your gateway with centralized authentication and governance
  • API Compatibility: Full support for Anthropic's Registry REST API specification - point your Anthropic API clients to this registry to discover available servers

Anthropic Registry Integration

Import and access curated MCP servers from Anthropic's official registry

Import Guide | Registry API Documentation

Security Scanning

Integrated Vulnerability Detection:

  • Automated Security Scanning - Integrated vulnerability scanning for MCP servers using Cisco AI Defence MCP Scanner, with automatic scans during registration and support for periodic registry-wide scans
  • Detailed Security Reports - Comprehensive markdown reports with vulnerability details, severity assessments, and remediation recommendations
  • Automatic Protection - Servers with security issues are automatically disabled with security-pending status to protect your infrastructure
  • Compliance Ready - Security audit trails and vulnerability tracking for enterprise compliance requirements

Authentication & Authorization

Multiple Identity Modes:

  • Machine-to-Machine (M2M) - For autonomous AI agents and automated systems
  • Three-Legged OAuth (3LO) - For external service integration (Atlassian, Google, GitHub)
  • Session-Based - For human developers using AI coding assistants and web interface

Supported Identity Providers: Keycloak, Amazon Cognito, and any OAuth 2.0 compatible provider. Learn more

Fine-Grained Permissions: Tool-level, method-level, team-based, and temporary access controls. Learn more

Production Deployment

Cloud Platforms: Amazon EC2, Amazon EKS

Documentation

Getting Started Enterprise Setup Developer & Operations
Complete Setup Guide
NEW! Step-by-step from scratch on AWS EC2		 Authentication Guide
OAuth and identity provider integration		 AI Coding Assistants Setup
VS Code, Cursor, Claude Code integration
Installation Guide
Complete setup instructions for EC2 and EKS		 Keycloak Integration
Enterprise identity with agent audit trails		 API Reference
Programmatic registry management
Quick Start Tutorial
Get running in 5 minutes		 Amazon Cognito Setup
Step-by-step IdP configuration		 Token Refresh Service
Automated token refresh and lifecycle management
Configuration Reference
Environment variables and settings		 Anthropic Registry Import
NEW! Import servers from Anthropic MCP Registry		 Observability Guide
NEW! Metrics, monitoring, and OpenTelemetry setup
Anthropic Registry API
NEW! REST API compatibility		 Fine-Grained Access Control
Permission management and security		 Dynamic Tool Discovery
Autonomous agent capabilities
Service Management
Server lifecycle and operations
Production Deployment
Complete setup for production environments
Troubleshooting Guide
Common issues and solutions

Community

Get Involved

Join the Discussion

Contributing

Star History

Star History Chart

Roadmap

The following GitHub issues represent our current development roadmap and planned features:

Major Features

DevOps & Operations

Completed

For the complete list of open issues, feature requests, and bug reports, visit our GitHub Issues page.

License

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

⭐ Star this repository if it helps your organization!

Get Started | Documentation | Contribute