Overview

The Webrix MCP Server is a Model Context Protocol (MCP) gateway designed to centralize and secure access to AI models and agent workflows. It sits between internal agents and external model endpoints, providing single sign‑on (SSO) integration, role‑based access control (RBAC), centralized token vaults, and audit trails—whether deployed on‑premises or in a cloud Kubernetes cluster via Helm.

By consolidating authentication, authorization, and secret management into a single service, teams can enforce consistent policies (who can call which model, with which credential), rotate or revoke credentials centrally, and retain audit logs for compliance and forensics. The server is useful when multiple agents or applications need controlled access to third‑party model APIs or when enterprises require stronger governance for AI usage.

Features

SSO integration (OIDC compatible) for user and service authentication
Role‑based access control (RBAC) for fine‑grained permissions
Token vaults: store, rotate, and inject API keys for model providers
Audit logs and activity tracing for requests and token usage
MCP protocol endpoint that brokers model requests and context
Deployable via Docker, Kubernetes, or Helm chart for in‑cloud/on‑premise
Web admin or API for managing roles, tokens, and audit records
Extensible backends for vault storage (filesystem, database, cloud KMS)

Installation / Configuration

Prerequisites:

Kubernetes (1.20+) and Helm 3, or Docker for local runs
An OIDC provider (Keycloak, Okta, Auth0) or corporate SSO
A persistent storage option for token vaults (DB or PVC)

Quick Helm install (example):

# clone the repo if you want to install the chart locally
git clone https://github.com/webrix-ai/secure-mcp-gateway.git
cd secure-mcp-gateway/chart

# create namespace and install with Helm
kubectl create namespace mcp
helm upgrade --install webrix-mcp . -n mcp \
  --set ingress.enabled=true \
  --set ingress.host= mcp.example.com \
  --set oidc.issuerUrl=https://sso.example.com \
  --set oidc.clientId=webrix-mcp \
  --set storage.type=postgres \
  --set storage.postgres.connectionString="postgres://user:pass@db:5432/mcp"

Local Docker run (development):

docker run --rm -p 8080:8080 \
  -e OIDC_ISSUER="https://sso.example.com" \
  -e OIDC_CLIENT_ID="webrix-mcp" \
  -e VAULT_BACKEND="file:/data/vault.json" \
  ghcr.io/webrix-ai/secure-mcp-gateway:latest

Example Helm/Environment configuration table

Key	Description	Example
oidc.issuerUrl / OIDC_ISSUER	OIDC provider discovery URL	https://sso.example.com
oidc.clientId / OIDC_CLIENT_ID	OIDC client id for the MCP server	webrix-mcp
storage.type	Vault/store backend (file/postgres/kv)	postgres
storage.postgres.connectionString	Connection string for DB storage	postgres://user:pass@db:5432/mcp
audit.logLevel	Audit logging verbosity	info/debug
token.ttl	Default ephemeral token TTL for agents	1h

RBAC and policy configuration is typically managed via the admin API or YAML manifests. Example RBAC snippet:

roles:
  - name: model-infer
    permissions:
      - action: invoke
        resource: models/gpt-4
bindings:
  - role: model-infer
    subjects:
      - type: group
        id: ai-team

Available Resources

GitHub repository (source, charts, manifests): https://github.com/webrix-ai/secure-mcp-gateway
Helm chart: included in the repo under /chart
Docker image: ghcr.io/webrix-ai/secure-mcp-gateway:latest (use repo tags)
REST API: MCP protocol endpoints (token issuance, brokered requests, audit)
Admin UI: web console for managing roles, tokens, and audit trails (if enabled)

Typical API endpoints (examples):

POST /api/v1/auth/oidc/callback — OIDC callback for SSO login
POST /api/v1/tokens/issue — issue ephemeral token for an agent
POST /api/v1/broker/invoke — proxy request to a configured model provider
GET /api/v1/audit — query audit logs (admin)

Use Cases

Centralized credential management for multi‑agent environments
Store provider API keys in the token vault and grant agents ephemeral access. Rotate or revoke credentials without redeploying agents.
Enforcing RBAC for model access
Restrict which teams or service accounts can call high‑cost or high‑risk models (e.g., GPT‑4) while allowing broader access to smaller models.
Audit trails and compliance
Record which agent or user invoked which model, with timestamps and request metadata—useful for security reviews and incident investigations.
Multi‑tenant SaaS or internal platform
Route tenant requests through the MCP gateway, isolating tokens per tenant and applying tenant‑specific RBAC policies.
Hybrid deployments (on‑prem or cloud)
Deploy the gateway inside a secure network to keep secret material in‑house while brokering requests to cloud model endpoints.

Getting Started Examples

Issue an ephemeral token (example curl):

curl -X POST "https://mcp.example.com/api/v1/tokens/issue" \
  -H "Authorization: Bearer <user-id-token>" \
  -H "Content-Type: application/json" \
  -d '{"role":"model-infer","ttl":"1h"}'

Invoke a model through the broker:

curl -X POST "https://mcp.example.com/api/v1/broker/invoke" \
  -H "Authorization: Bearer <ephemeral-token>" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4","input":"Summarize the following..."}'

For more details, configuration examples, and advanced deployment patterns, see the repository: https://github.com/webrix-ai/secure-mcp-gateway.

Webrix MCP Server: SSO, RBAC, Token Vaults