Connect integrations and the MCP server to self-hosted Plane

Integrations connect a Plane workspace to tools such as GitHub, Slack, GitLab, Bitbucket, and Sentry.

On a self-hosted instance, you turn each one on yourself, with an app on the provider's side and its keys in plane.env. This lesson sets up GitHub end to end, the other four in one pass, and Plane's MCP server, so AI tools can create work items and query projects.

Integrations run in one container called silo, at /silo on your Plane domain.

God mode's GitHub and GitLab pages set up sign-in, not integrations. Silo turns each of the five on only when its keys are in plane.env.

1. Until then, the integration's card in Workspace settings, then Integrations, reads Not configured, and tells workspace admins to contact their instance admin.
2. Set the keys and restart Plane, and the card shows Configure instead.

Integrations need the Pro plan or higher. On the Free plan, each card shows Upgrade.

1. On GitHub, create a GitHub App in your organization's developer settings. Its callback, setup, and webhook URLs all point at /silo on your Plane domain.
2. Opt out of expiring user tokens, or the connection stops working after a while.
3. Set the permissions and events the docs list, create the app, then generate a client secret and a private key.
4. Plane needs five values: the app's ID, its client ID and secret, its private key, and its slug. Use the slug, not the display name.
5. Encode the private key on one line with base64 -w 0. Prime CLI won't take a value with line breaks.
6. One command sets all five: sudo prime-cli configure, with -e before each key.

sudo prime-cli configure \
  -e GITHUB_APP_ID=<app-id> \
  -e GITHUB_APP_NAME=<app-slug> \
  -e GITHUB_CLIENT_ID=<client-id> \
  -e GITHUB_CLIENT_SECRET=<client-secret> \
  -e "GITHUB_PRIVATE_KEY=$(cat private_key.pem | base64 -w 0)"

Configure lists the five keys, with the secret and private key masked, and asks before writing plane.env and restarting Plane.

After the restart, the GitHub card shows Configure. A workspace admin connects the organization and installs the app on all repositories or only some. An organization connects to only one workspace on the instance.

Then admins and members can each connect a personal GitHub account, so their actions show under their own name instead of the app's bot.

1. On Slack, create the app from the docs' manifest, with your Plane domain in each of its URLs. Its keys are the client ID, the client secret, and the signing secret, which lets Plane check that requests come from Slack.
2. For GitLab, add a confidential application with Plane's redirect URI and six scopes. Its ID and secret are the keys.
3. Bitbucket needs an OAuth consumer with Plane's callback URL. Plane takes its key and secret, and any random string as a webhook secret.
4. Sentry needs a public integration with Plane's webhook and redirect URLs and the docs' schema. Copy its client ID and secret. Plane also needs the integration's slug and the Sentry URL. Set the URL even for sentry.io, because plane.env ships it empty.
5. One configure command sets all twelve keys, and one restart turns all four on.
6. Back in Slack's Event Subscriptions, retry the request URL. Plane answers it only once Slack's keys are set.

For a self-hosted instance, you run the MCP server yourself, and register it in Plane as an OAuth app.

1. Under Integrations, Build your own creates the app. Its setup URL is the server's address, and both its redirect URIs point at the server.
2. Tick read and write on all workspace resources. Narrower scopes make the sign-in fail.
3. Create the app and copy its client ID and secret. Plane shows the secret only once.
4. Docker Compose runs the server next to Valkey, which stores its tokens. Its variables name your Plane address, the client ID and secret, and its own public address.
5. docker compose up -d starts it on port 8211. Put TLS in front, because sign-in fails without HTTPS.
6. To check it, curl /http/mcp. A 401 means it's up and waiting for a sign-in.
7. Then add the server to an MCP client, such as VS Code. On first use, you sign in to Plane and choose a workspace.

The server acts as the person who signed in, so their role in the workspace still applies.

All five integrations now run from keys in plane.env, and AI tools reach your workspace through your own MCP server.