MCP Integration

Connect Fabric AI to external tools using the Model Context Protocol (MCP).

The Model Context Protocol (MCP) enables Fabric AI agents to interact with external tools and services. Connect to GitHub, Jira, Slack, Notion, and dozens of other tools to automate your workflows.

What is MCP?

MCP (Model Context Protocol) is an open standard that allows AI models to interact with external tools and data sources in a standardized way.

┌─────────────────────────────────────────────────────────────────┐
│                        Fabric AI Agent                          │
│                              │                                   │
│                              ▼                                   │
│                    ┌─────────────────┐                          │
│                    │   MCP Client    │                          │
│                    └─────────────────┘                          │
│                              │                                   │
└──────────────────────────────┼──────────────────────────────────┘
                               │
         ┌─────────────────────┼─────────────────────┐
         │                     │                     │
         ▼                     ▼                     ▼
┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐
│  GitHub MCP     │   │   Jira MCP      │   │   Slack MCP     │
│  Server         │   │   Server        │   │   Server        │
└─────────────────┘   └─────────────────┘   └─────────────────┘
         │                     │                     │
         ▼                     ▼                     ▼
    GitHub API            Jira API            Slack API

Benefits

For Users

Natural language commands to control external tools
No need to switch between applications
Automated workflows across multiple services

For Agents

Standardized tool discovery
Consistent authentication
Error handling built-in

Available MCP Servers

Fabric includes a registry of pre-configured MCP servers:

Development & Collaboration

Server	Capabilities
GitHub	Issues, PRs, repositories, code search
GitLab	Issues, merge requests, projects
Jira	Tickets, sprints, projects, boards
Linear	Issues, projects, cycles
Notion	Pages, databases, blocks
Confluence	Pages, spaces, search

Communication

Server	Capabilities
Slack	Messages, channels, threads
Discord	Messages, channels, threads
Teams	Messages, channels, meetings

Cloud & Infrastructure

Server	Capabilities
AWS	S3, Lambda, EC2, and more
Cloudflare	Workers, D1, R2, KV
Vercel	Deployments, domains, env vars

Productivity

Server	Capabilities
Google Drive	Files, folders, sharing
Dropbox	Files, folders, sharing
Calendar	Events, scheduling

Search & Research

Server	Capabilities
Brave Search	Web search
Google Search	Web search
Exa	AI-powered search

Setting Up MCP Servers

Navigate to Settings

Go to Settings → MCP Servers.

Browse Registry

Click Add Server to see available servers in the registry.

Select a Server

Choose the server you want to connect (e.g., GitHub).

Authenticate

Depending on the server, you'll authenticate via:

OAuth (Recommended)

Click "Connect with OAuth"
Authorize in popup window
Tokens stored automatically

API Key

Get API key from the service
Paste into Fabric
Click "Save"

Test Connection

Click Test Connection to verify it works.

Enable Server

Toggle the server to Enabled. It's now available for agents.

Authentication Methods

OAuth 2.0 (Recommended)

For servers that support OAuth:

Discovery — Fabric finds OAuth endpoints automatically
DCR — Dynamic Client Registration if supported
Authorization — User authorizes in popup
Token Storage — Tokens encrypted and stored securely
Auto-refresh — Tokens refresh automatically

User clicks "Connect"
        │
        ▼
┌───────────────────────────────────────┐
│       OAuth Authorization             │
│                                       │
│  Fabric AI wants to access your       │
│  GitHub account.                      │
│                                       │
│  Permissions:                         │
│  • Read repositories                  │
│  • Create issues                      │
│  • Manage pull requests               │
│                                       │
│        [Authorize]  [Cancel]          │
└───────────────────────────────────────┘
        │
        ▼
    Token stored securely

API Key

For servers that use API keys:

Get key from service dashboard
Paste into Fabric settings
Key is encrypted before storage
Key is decrypted only when needed

No Authentication

Some servers work without authentication:

Public search APIs
Open data sources
Local development servers

Using MCP Tools

In Conversations

Simply ask the agent to use a connected tool:

"Create a GitHub issue for the login bug we discussed"

"Post a summary of this PRD to the #engineering Slack channel"

"Create Jira stories from the user requirements above"

With the Orchestrator

The Orchestrator automatically discovers and uses MCP tools:

Request: "Create auth stories in Jira"
            │
            ▼
┌─────────────────────────────────────────┐
│  Orchestrator Analysis                   │
│  • Task: Create Jira tickets            │
│  • Search MCP tools...                   │
│  • Found: jira-mcp → create_issue       │
│  • Permission: Approved (trusted)        │
│  • Execute tool                          │
└─────────────────────────────────────────┘

Tool Discovery

Agents discover tools automatically:

┌─────────────────────────────────────────────────────────────┐
│                   MCP Tool Discovery                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  Server: jira-mcp                                           │
│                                                              │
│  Tools:                                                      │
│  • create_issue - Create a new Jira issue                   │
│  • update_issue - Update existing issue                      │
│  • search_issues - Search for issues                         │
│  • get_issue - Get issue details                            │
│  • add_comment - Add comment to issue                       │
│  • transition_issue - Change issue status                    │
│                                                              │
│  Resources:                                                  │
│  • projects - Available Jira projects                        │
│  • users - Team members                                      │
│  • statuses - Issue statuses                                 │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Multi-Tenant Security

MCP connections are scoped per user/organization:

Personal Connections

Connect your personal GitHub account
Only you can use these connections
Isolated from organization connections

Organization Connections

Connect organization accounts (e.g., company Jira)
All organization members can use
Managed by organization admins

Isolation

┌─────────────────────────────────────────────────────────────┐
│                    Organization A                            │
│  ┌────────────────┐  ┌────────────────┐                     │
│  │ GitHub (Org)   │  │  Jira (Org)    │                     │
│  └────────────────┘  └────────────────┘                     │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐ │
│  │ User 1                                                  │ │
│  │ ┌──────────────┐                                        │ │
│  │ │Slack (Personal)                                       │ │
│  │ └──────────────┘                                        │ │
│  └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    Organization B                            │
│  ┌────────────────┐  ┌────────────────┐                     │
│  │ GitHub (Org)   │  │ Linear (Org)   │  ← Different!       │
│  └────────────────┘  └────────────────┘                     │
└─────────────────────────────────────────────────────────────┘

Transport Types

MCP servers communicate via different transports:

SSE (Server-Sent Events)

Real-time streaming
Best for long-running operations
Used by most cloud servers

HTTP

Standard request/response
Simple and reliable
Good for simple operations

STDIO

Local process communication
Used for development
Self-hosted servers

Health Monitoring

Fabric monitors MCP server health:

┌─────────────────────────────────────────────────────────────┐
│                   MCP Server Health                          │
├─────────────────────────────────────────────────────────────┤
│ GitHub         ● Healthy     Last check: 2 min ago          │
│ Jira           ● Healthy     Last check: 2 min ago          │
│ Slack          ⚠️ Degraded   Rate limited, cooling down     │
│ Notion         ● Healthy     Last check: 2 min ago          │
└─────────────────────────────────────────────────────────────┘