Skip to main content

Managing Integrations

The Integrations page connects RubixKube with your existing tools for notifications, metrics, workflows, and agent capabilities.
Integrations header with metrics
Search and filter controls
Integration cards catalog

System Integrations

Slack

Get incident notifications in Slack

Setup:
  1. Click “Connect Slack”
  2. Authorize RubixKube app
  3. Select channel for alerts
  4. Configure notification rules

PagerDuty

Page on-call for critical incidents

Setup:
  1. Click “Connect PagerDuty”
  2. Enter integration key
  3. Map severity levels
  4. Test integration

Prometheus

Enhanced metrics collection

Setup:
  1. Enter Prometheus endpoint
  2. Configure scrape interval
  3. Verify connection

Webhooks

Custom integrations

Setup:
  1. Add webhook URL
  2. Select events to trigger
  3. Configure payload format

Notification Rules

Configure when to be notified: - HIGH severity incidents only
  • All incidents
  • RCA report completion
  • Cluster disconnection
Delivery channels: - Slack messages
  • PagerDuty alerts
  • Webhook calls
  • Email (coming soon)

Custom Integrations

Custom Integrations let you connect your own private MCP servers and REST APIs to RubixKube. Once registered, their tools appear automatically alongside system integrations — available to the SRI Agent through Chat, with zero extra plumbing.
Enterprise feature. Custom integrations are available on the Enterprise plan. Free and Pro tenants will see a 403 response.

Two Protocols

Custom integrations support two protocols. Choose based on what you’re connecting:

MCP Server

Connect a private Model Context Protocol server — the same standard used by system integrations. Supports SSE, HTTP, and stdio transports.Best for: MCP-native tools like Linear, GitHub, Notion, or any server that speaks MCP.

REST API

Expose any REST API as agent tools by defining tool schemas and HTTP mappings. No MCP server needed — RubixKube translates tool calls to HTTP requests.Best for: Internal APIs, ticketing systems, CMDB, or any service with a REST endpoint.

Adding an MCP Server

Add Custom Integration dialog showing MCP Server and REST API protocol options with metadata fields
1

Open Integrations

Navigate to Integrations in the left sidebar.
2

Click + Add Custom Integration

Select MCP Server as the protocol type.
3

Fill in Metadata

FieldDescription
NameURL-safe slug (lowercase, numbers, hyphens). Unique per tenant
Display NameHuman-readable name for the integration card
DescriptionShort description of what this integration does
Logo URLURL to the integration’s logo/icon
CategoryCategory for filtering (e.g., version_control, project_management)
4

Configure MCP Connection

MCP configuration showing Server URL, Transport, Auth type, and API Token fields
FieldDescription
Server URLFull URL to your MCP server endpoint (e.g., https://mcp.zapier.com/api/v1/connect)
TransportSSE (default), HTTP, or stdio
Auth TypeBearer / API Key (default), OAuth2, or None
Auth Header PrefixPrefix for the Authorization header (default Bearer, use Token for GitHub)
API TokenYour authentication token
You can also use the Edit as JSON panel on the right to configure the integration directly as JSON.
5

Test Connection

After creation, click Test to verify connectivity. The test negotiates the MCP handshake with the remote server and updates the health status on the card.
Once connected, the integration’s tools appear immediately in the MCP gateway — no restart or config change needed.

Adding a REST API

Add Custom Integration dialog with REST API selected and metadata fields
1

Select REST API Protocol

Choose REST API as the protocol type when adding a new custom integration.
2

Enter Metadata

Fill in the metadata fields: Name (slug), Display Name, Description, Logo URL, and Category.
3

Enter Base URL and Auth

REST API configuration showing Base URL, Auth type, Access token, and Custom headers
FieldDescription
Base URLBase URL of your API (e.g., https://api.example.com)
Auth TypeBearer token, API Key, Basic auth, or OAuth2
Access TokenYour authentication token (encrypted at rest)
Custom HeadersOptional static headers merged into every request (click + Add header)
4

Define Tools

Tools section with Import from OpenAPI and Define manually tabs
You can define tools in two ways:
  • Import from OpenAPI — upload or paste an OpenAPI 3.x / Swagger 2.0 spec to auto-generate tools
  • Define manually — click + Add tool to define each tool by hand
Each tool represents one API operation the SRI Agent can invoke:
FieldDescription
NameTool identifier (e.g., list_tickets)
DescriptionWhat the tool does — the agent reads this to decide when to use it
HTTP MethodGET, POST, PUT, PATCH, or DELETE
PathURL path appended to the base URL (supports path params like /tickets/{id})
ParametersQuery params and body params for the tool
5

Create and Test

Click Add Integration and then Test to verify connectivity. REST tests probe common health paths (/healthcheck, /healthz, /health, /ping) with your configured auth.

Managing Custom Integrations

Editing a Custom Integration

To update an existing custom integration, click on its card in the catalog and select Edit. The edit form opens pre-populated with all current values.
1

Open the Integration Card

Find the custom integration in the catalog. Custom integrations are shown in the Custom section below the system integrations.
2

Click Edit

Click the Edit (pencil) icon on the integration card or in the settings panel.
3

Update Fields

Modify any metadata or connection settings:
FieldBehavior on Update
Display Name / Description / Logo URL / CategoryUpdated immediately
Connection settings (URL, transport, etc.)Replaced on save
Credentials (API token, OAuth config)Passing new credentials replaces them entirely (re-encrypted). Omit to preserve existing credentials.
ToolsAdd, remove, or redefine tool schemas
4

Save Changes

Click Save to apply. The updated integration takes effect immediately in the MCP gateway.

Other Integration Actions

Disable / Re-enable — Toggle the integration’s status between active and disabled. Disabled integrations are excluded from the MCP gateway. Tool Filtering — Control which tools are available to agents:
  • Enabled tools — allowlist of specific tool names. Empty means all tools allowed.
  • Disabled tools — blocklist applied after the allowlist. If a tool appears in both, it’s blocked.
Delete — Permanently removes the integration and all associated credentials. Test Connection — Run a health check at any time. Health status is displayed on the integration card with consecutive failure count and last error.

Authentication

Credentials are passed plaintext on create — the server encrypts them before storing. They are always masked in responses.
{
  "auth_type": "bearer",
  "api_token": "your-token-here"
}
For user-facing OAuth flows (e.g., Atlassian, GitHub):
{
  "auth_type": "oauth2",
  "oauth": {
    "grant_type": "authorization_code",
    "client_id": "your-client-id",
    "client_secret": "your-client-secret",
    "authorization_url": "https://provider.com/oauth/authorize",
    "token_url": "https://provider.com/oauth/token",
    "scope": "read write",
    "use_pkce": true
  }
}
Or with OIDC discovery (auto-discovers endpoints from issuer URL):
{
  "auth_type": "oidc",
  "oauth": {
    "grant_type": "authorization_code",
    "client_id": "your-client-id",
    "issuer_url": "https://auth.provider.com",
    "scope": "openid read:data",
    "use_pkce": true
  }
}
For server-to-server flows:
{
  "auth_type": "oauth2",
  "oauth": {
    "grant_type": "client_credentials",
    "client_id": "your-client-id",
    "client_secret": "your-client-secret",
    "token_url": "https://provider.com/oauth/token",
    "scope": "api:read api:write"
  }
}
Set auth_type: “none” and omit credentials entirely.
{ "access_token": "eyJhbGciOi..." }
Also accepts api_token or token.
{ "api_key": "your-api-key" }
{ "username": "alice", "password": "s3cr3t" }

OAuth Flows

For OAuth-based integrations, RubixKube handles the full authorization code flow:
1

Create the Integration

Register the integration with auth_type: “oauth2” and your OAuth credentials (client ID, secret, URLs).
2

Authorize

Click Authorize on the integration card. This opens the OAuth provider’s consent page in a popup or redirect.
3

Complete Consent

After you approve, the provider redirects back to RubixKube’s callback endpoint. Tokens are automatically encrypted and stored.
4

Token Refresh

Token refresh happens automatically during tool calls. You can also manually trigger a refresh from the integration card to verify token health.
OAuth discovery: RubixKube can auto-discover authorization and token URLs from the MCP server’s .well-known/oauth-authorization-server or the standard OIDC .well-known/openid-configuration endpoint.

How Custom Integrations Appear to Agents

Once created, custom integration tools surface automatically in the tenant’s MCP gateway alongside system integration tools:
  • Tool discovery — custom tools appear in tools/list and discover_tools()
  • Tool executiontools/call routes to your server or API with the configured auth
  • Namespacing — tools are namespaced by the integration’s name slug
There’s no difference between a system integration tool and a custom integration tool from the agent’s perspective. Both go through the same MCP gateway.

Custom vs System Integrations

System IntegrationsCustom Integrations
SourceGlobal registry (managed by RubixKube)Tenant self-served
ProtocolDetermined by registrymcp or rest (your choice)
VisibilityAll tenants (based on config)Your tenant only
Tool definitionsFrom registryYou provide them
DeletionDisable onlyHard delete
PlanAll plansEnterprise only

What You Learned

  • Available system integrations (Slack, PagerDuty, Prometheus, Webhooks)
  • Notification rules and delivery channels
  • How to register private MCP servers and REST APIs as custom integrations
  • Authentication options: Bearer, OAuth 2.1, API Key, Basic Auth
  • How custom integrations appear automatically in the MCP gateway


Need Help?