# Integrations

**Integrations** connects your workspace to the tools your team already uses. Connect your Git
provider so Productmind can reach your repositories, your issue tracker to import work, Slack to
post updates to a channel, or your helpdesk to bring in customer conversations. You can also
connect your own MCP servers for your agents. Everyone, whatever their role, can connect their own
accounts in those tools, and see which MCP clients on their machine, such as Claude Code, are
connected to Productmind.

<Availability permission="Any role: MCP Clients and User connections, to connect your own accounts and assistants. The Owner or Admin role: MCP Servers and Workspace integrations. Anyone who can run an import can also connect the tool it imports from there." />

## Key concepts

**Integration.** A tool Productmind can connect to, such as Jira or Slack. Each one appears as a
card in the catalog.

**Connection.** Your workspace's link to one of those tools. A connection belongs to the workspace
you are in: each workspace connects its own tools.

**Workspace integration.** A connection that acts on behalf of Productmind, for everyone in the
workspace. For example, the Slack integration posts workspace activity to a channel.

**User connection.** A connection to your own account in a tool, so Productmind can act as you.
Several tools have both kinds, which is why the catalog lists, for example, both **GitHub** and
**GitHub (User)**.

**Automation.** Something an integration can do on its own when an event happens in the connected
tool. Each automation has an on/off switch on the integration's page.

## The Integrations page at a glance

At the top-right of any page, choose the **Integrations** icon, then **View all** in the
[Integrations panel](#the-integrations-panel) that opens. With the **Owner** or **Admin** role, you
can also choose **Integrations** in the sidebar, under **Settings**.

<Screenshot id="integrations-page" alt="The Integrations page: the Add MCP server tile, then the MCP Clients section with Claude Code, Codex and GitHub Copilot" />

**The toolbar** holds the search box, which matches names and descriptions, and three filters:
**All**, **Connected** and **Available**. Search and the filters apply to the tool cards under
**User connections** and **Workspace integrations**, not to **MCP Servers** or **MCP Clients**.
When nothing matches, the page says "No integrations found. Try a different search term."
Productmind remembers your search and filter for this workspace in this browser.

The page has up to four sections, from top to bottom:

| Section | Who sees it | What it holds |
| --- | --- | --- |
| **MCP Servers** | Owner and Admin | **Add MCP server**, then one card for each MCP server you have connected. See [MCP Servers](#mcp-servers). |
| **MCP Clients** | Everyone | The address MCP clients use to connect to Productmind, and a card each for **Claude Code**, **Codex** and **GitHub Copilot**. See [MCP Clients](#mcp-clients). |
| **User connections** | Everyone | Tools you connect with your own account: "Perform actions on behalf of your connected user." |
| **Workspace integrations** | Owner and Admin | Tools connected for the whole workspace: "System-level integrations that act on behalf of Productmind." |

With any other role, the page shows **MCP Clients** and **User connections**. If your
organization's plan doesn't include Integrations, an Owner or Admin sees one card naming the plan
that does, in place of **MCP Servers** and **Workspace integrations**.

**Each integration card** shows the tool's logo, name, status (**Connected** or **Not
connected**) and description. **Needs reconnect** means the tool is still connected to your
workspace but has stopped working, and someone has to reconnect it: see
[To reconnect a tool that stopped working](#to-reconnect-a-tool-that-stopped-working). Such a card
stays under the **Connected** filter. If the integration offers automations, the card says how
many, for example **3 automations**. Choosing a card connects the tool, or opens its page if it
is connected: the card says **Connect**, **Manage** or **Reconnect**. Each section says how many
of its tools are connected.

The catalog includes:

| Group | Tools |
| --- | --- |
| **User connections** | GitHub (User), GitLab (User), Bitbucket (User), Slack (User), Google |
| **Workspace integrations** | Asana, Bitbucket, Confluence, Freshdesk, GitHub, GitLab, Jira, Linear, Notion, Slack, Zendesk |

### The Integrations panel

The **Integrations** tab of the [activity panel](/user-guide/get-started/finding-your-way-around#the-activity-panel)
opens the same catalog beside any page, with a tab for each group: **Workspace**, **User**,
**MCP Servers** and **MCP Clients**. With a role other than **Owner** or **Admin**, you see
**User** and **MCP Clients**. Productmind remembers the tab you last had open. Choose **View all**
to open the Integrations page.

## Connecting a tool

### To connect a tool

1. Open the Integrations page: at the top-right of the page, choose the **Integrations** icon, then
   **View all**.
2. Find the tool's card, and choose it. With a role other than **Owner** or **Admin**, the page
   lists the tools under **User connections**, which you connect with your own account.
3. Do what the tool asks for. Depending on the tool, Productmind either takes you straight to the
   tool to approve access, or opens a **Connect** dialog first.
4. If you are taken to the tool, sign in there if you need to, and approve access.

You return to **Integrations**, which shows "*Tool* connected successfully", and the card reads
**Connected**.

The **Connect** dialog can offer up to three ways to connect, as tabs:

| Tab | How it works |
| --- | --- |
| **OAuth** | Choose **Authorize**, and approve access in the tool. |
| **Own OAuth app** | For a tool that runs on your own server, or for an OAuth application of your own. Create the application in the tool, paste the callback URL the dialog shows into it, then enter the application's credentials and choose **Authorize**. |
| **Access token** | Paste a token or API key you created in the tool, and choose **Connect**. You can also give the connection a name. |

When a tool offers only one way, the dialog shows it without tabs. For GitLab, each tab says which
application or token to create, with which scopes and role.

If the tool refuses what you entered, for example a token it rejects, the dialog says why and keeps
what you entered, so you can correct it.

:::note
Some tools ask an administrator of the tool to approve the installation. Until they do,
Productmind shows "Installation is pending org admin approval. It will activate once approved."
:::

### To connect GitHub

GitHub connects through the Productmind GitHub App, which you install on a GitHub organization or
on your personal GitHub account. Only an owner of the organization, or the owner of the personal
account, can complete the connection.

1. In the sidebar, choose **Integrations**.
2. Under **Workspace integrations**, choose **GitHub**.
3. On GitHub, choose the organization or account to install the app on, and the repositories
   Productmind can access.
4. The first time you connect GitHub, GitHub asks you to authorize Productmind. Approve it. GitHub
   asks you only once, not every time you connect.

Productmind checks with GitHub that you own the organization or account the app is installed on,
and then completes the connection. You return to **Integrations**, which shows "GitHub connected
successfully", and the GitHub card reads **Connected**.

If you are not an owner, ask an owner of the organization to connect GitHub. See
[Only an owner can connect GitHub](#only-an-owner-can-connect-github).

### To connect GitLab

Connect GitLab for the workspace once. The way you connect it decides how everyone in the workspace
connects their own GitLab account later:

| Tab | What you set up | How members connect their own account |
| --- | --- | --- |
| **OAuth** | Approve Productmind's GitLab.com application. | They sign in to GitLab.com through the same application. |
| **Own OAuth app** | An OAuth application of your own, on your GitLab server or in a GitLab.com group. | They sign in through your application, on your server. Nobody creates another application. |
| **Access token** | An access token, usually a group access token. | They connect a personal access token of their own, on your server. |

1. In the sidebar, choose **Integrations**.
2. Under **Workspace integrations**, choose **GitLab**.
3. Choose a tab, and follow the steps the dialog shows.

You return to **Integrations**, which shows "GitLab connected successfully", and the GitLab card
reads **Connected**. GitLab's page then shows the account Productmind acts as, and lets you move
between a token and OAuth without disconnecting: see
[Managing the GitLab connection](#managing-the-gitlab-connection).

#### To set up your own GitLab OAuth application

1. In GitLab, create the application once, in one of these places:
   - **Group › Settings › Applications** (recommended): the application belongs to the group.
   - **Admin › Applications**: for the whole GitLab server. Mark it **Trusted** so members don't
     see an approval screen.
   - **Edit profile › Applications**: the application belongs to your own account.
2. Set its **Redirect URI** to the callback URL that the **Own OAuth app** tab of the **Connect
   GitLab** dialog shows. Choose the copy button beside it to copy it.
3. Turn **Confidential** on, and select the scopes **api** and **read_user**.
4. Save the application.
5. In the **Own OAuth app** tab, enter your GitLab server's address under **Instance URL** (leave
   it empty for GitLab.com), then paste the **Application ID** and **Secret**.
6. Choose **Authorize**, and approve access in GitLab.

Your members sign in through this application. They never create one of their own.

#### Which GitLab access token to create

- A **group access token** is the one for a team: it reaches every project in the group, and it
  keeps working when people leave. A project access token reaches one project, and a personal
  access token acts as the person who created it.
- Give it at least the **Developer** role, and **Maintainer** where only Maintainers may merge into
  protected branches.
- Give it the scopes **api**, **read_repository** and **write_repository**. Group and project
  tokens need the repository scopes for the sessions' clones and pushes.
- Access tokens expire. Replace the token before its expiry date.

### To open a connected tool's page

1. Open the Integrations page: at the top-right of the page, choose the **Integrations** icon, then
   **View all**.
2. Choose the tool's card. A connected card says **Manage** where an unconnected one says
   **Connect**.

The tool's page opens. Every role can open the page of a tool connected with their own account,
under **User connections**, to check it or disconnect it. The page of a workspace integration or
an MCP server is for the **Owner** and **Admin** roles: with any other role, Productmind takes you
back to **Integrations**. The tool's page shows:
- its status, description and connection date, with its own actions, such as an import button,
  and **Disconnect**;
- depending on the tool, **Notifications**, **Automations**, webhook details or **Tools available**.

### To disconnect a tool

1. Open the tool's page.
2. Choose **Disconnect**.
3. Read what disconnecting does, and choose **Disconnect** again to confirm. For most tools,
   Productmind says "Workflows depending on it will stop."

Productmind shows "*Name* disconnected", and you return to **Integrations**.

:::caution
Anything that relies on the connection stops working until you connect the tool again: for
example, imports, automations, channel notifications, or access to the repositories behind your
applications.
:::

Disconnecting **GitHub** also uninstalls the Productmind GitHub App from the GitHub organization or
account it was installed on, and the confirmation says so. To connect GitHub again, an owner
installs the app again and chooses its repositories again.

Disconnecting **GitLab** also ends Productmind's access at GitLab when the connection was made with
OAuth, the workspace's connection and a member's own alike. A connection made with an access token
leaves the token valid: revoke it in GitLab if it is no longer needed.

Connecting **GitLab** again after disconnecting it makes a new connection with a new Webhook URL.
Productmind moves each project's webhook onto it where the connection's GitLab account can manage
the project's webhooks; give the other projects' webhooks the new URL in GitLab. Members who signed
in through it sign in again. To change the token or the account, use the **Connection** tab on
GitLab's page instead: see [Managing the GitLab connection](#managing-the-gitlab-connection).

### To reconnect a tool that stopped working

When a tool refuses to renew Productmind's access, for example because someone revoked it in the
tool, its card shows **Needs reconnect** and the tool's page shows **This connection needs
re-authorising** with the date it started failing.

1. Open the tool's page.
2. Choose **Reconnect**.
3. If the **Connect** dialog opens, for example because you connected the tool with your own
   OAuth client, enter the details again and choose **Authorize**.
4. Approve access in the tool again.

You return to the tool's page, and **This connection needs re-authorising** is gone.

### To reconnect GitHub

When the Productmind GitHub App is uninstalled from the GitHub organization or account, or
suspended there, Productmind can no longer reach your repositories. The GitHub card shows **Needs
reconnect**, and GitHub's page shows **GitHub can no longer reach this connection**
with the date it started failing.

1. Open GitHub's page.
2. Choose **Reconnect**.
3. On GitHub, install the app on the organization or account again, and choose its repositories.
   As with a first connection, only an owner of the organization, or the owner of the personal
   account, can complete this.
4. If GitHub asks you to authorize Productmind, approve it.

You return to **Integrations**, which shows "GitHub connected successfully", and the card reads
**Connected**. The connection is the same one as before, so your applications and sessions keep
their repository links.

If the app was **suspended** rather than uninstalled, an owner of the organization can also
unsuspend it in the organization's GitHub settings. The connection then recovers on its own,
without reconnecting.

## Working with connected tools

### Git providers

GitHub, GitLab and Bitbucket give Productmind access to the repositories behind your
[applications](/user-guide/engineering/applications) and
[coding sessions](/user-guide/sessions/overview).

**GitHub (User)**, **GitLab (User)** and **Bitbucket (User)** connect your own account. The
pull requests of a coding session you create are then opened as you, in every repository your
account can push to, and the workspace's connection opens the rest. When your workspace pushes as
the session's creator, your account pushes the session's changes too, for now on GitLab and
Bitbucket only: see
[Who pushes a session's code](/user-guide/settings/workspace-settings/coding-sessions#how-who-pushes-behaves).
You can connect your account from the session itself, under **Draft a plan**. See
[Who opens the pull requests](/user-guide/sessions/pull-requests#who-opens-the-pull-requests).

**The workspace's GitLab connection.** Productmind reads your projects, pushes the sessions'
branches and opens their merge requests with it, as the account it acts as: see
[Managing the GitLab connection](#managing-the-gitlab-connection). That account is the committer
of every commit it pushes, so GitLab push rules that check the committer accept them. When your
workspace pushes as the session's creator, the creator's own account pushes wherever it can, and
is then the committer.

#### To connect your own GitLab account

How you connect **GitLab (User)** depends on how your workspace connected GitLab:

| Your workspace connected GitLab with | When you choose **Connect GitLab** |
| --- | --- |
| Productmind's GitLab.com application, or its own OAuth application | GitLab's sign-in page opens straight away, on your workspace's GitLab. Approve access. |
| An access token | The **Connect** dialog asks for a personal access token. **Instance URL** is your workspace's GitLab, filled in for you. |
| Nothing yet | The dialog offers **Authorize**, which signs you in to GitLab.com. Using a self-hosted GitLab? An admin connects GitLab for the workspace first, then you connect to it. |

When the dialog asks for a token, create a **personal access token on your own account**:

1. In GitLab, go to **Edit profile › Access tokens**, or choose **Create token on** your GitLab
   server in the dialog, which opens that page with the name and scope filled in.
2. Give the token the **api** scope: GitLab has no narrower scope that can open a merge request
   as you.
3. Copy the token, paste it into **Personal access token**, and choose **Connect**.

Productmind shows "GitLab (User) connected successfully". Your account needs at least the
**Developer** role on the projects your sessions change. Group and project access tokens act as a
bot, not as you, and are refused.

If you reinstalled or changed Productmind's access in your Git provider and your applications
can no longer reach their repositories, open the provider's page and choose **Repair repository
links**. Productmind points the applications, sessions, releases and channel notifications that
used the old connection at the current one, and tells you how many links it repaired, and which
repositories it still can't reach. On GitLab it also moves each project's webhook that still
delivers to the old connection onto the current one, and says how many it moved and how many it
could not check. It is safe to choose more than once. The button is there for the **Owner** and
**Admin** roles, and for anyone with **Applications: Update**.

### Managing the GitLab connection

Every clone, push, merge request and merge that a session, a scan or a release makes on GitLab
goes through the workspace's GitLab connection, as the GitLab account behind it, except the merge
requests opened as their session's creator, and the pushes of a workspace that pushes as the
session's creator. GitLab's page shows that account, what it can do on
your applications' repositories, and the webhook that keeps Productmind told about merge
requests, in four tabs:

<Tabs>
<Tab label="Connection">

**Acts as** names the account, whether it's a person or a bot, how it's connected (**OAuth** or
**Access token**) and on which GitLab server.

- With an access token, Productmind acts as the token's account: a group or project access token
  acts as its bot user, and a personal access token as the person who created it.
- With OAuth, Productmind acts as the person who approved access. Commits, merge requests and
  merges carry their name, with their role on each project, and the connection stops working if
  they leave or lose access. Approve with a GitLab account kept for Productmind, not your own.

To change the token or the account without disconnecting:

1. Choose **Switch to OAuth** or **Replace token** (a token connection), or **Authorize again** or
   **Switch to access token** (an OAuth connection). Your GitLab server's address is filled in and
   locked: another server is a new connection.
2. For OAuth, enter your GitLab application's **Application ID** and **Secret** (on GitLab.com you
   can choose Productmind's application instead), choose **Authorize**, and approve access in
   GitLab as the account Productmind should act as. For a token, paste it into **Access token**
   and choose **Save token**.

**Acts as** names the new account. The connection is the same one, so your applications'
repository links and the webhook keep working, and so do members' own personal access tokens.
With another OAuth application, or a token in place of OAuth, members who signed in through the
old application connect their GitLab account again.

GitLab's OAuth access expires after two hours, and Productmind renews it on its own. Leave
**Admin › Settings › General › Account and limit › Maximum allowable lifetime for OAuth access
tokens** at two hours: each renewal ends the access a running session holds, which it then has to
get again, so a shorter lifetime means more of that. If GitLab refuses, for example because the
application was deleted or its secret changed, the card shows **Needs reconnect**: choose
**Authorize again**. An access token expires on the date you chose: replace it before then.

</Tab>
<Tab label="Repository access">

What the account can do on each application's repository, checked with GitLab when you open the
page. Choose **Check again** after you change a role in GitLab.

| What Productmind does | Role the account needs on the project |
| --- | --- |
| Read code and branches, clone for scans and sessions | **Reporter** |
| Push a session's branch, open and update merge requests, tag a release | **Developer** |
| Merge into a protected branch, for a session or a release | Whichever role the branch's protection allows to merge: **Maintainer** by default |

Each repository shows **Full access**, **Cannot merge into** a branch (the merge needs the role
named, or a person merges in GitLab), **Read only** (sessions can't push: the account needs
**Developer**), **Not visible** (add the account to the project) or **Not checked** (GitLab didn't
answer: check again).

</Tab>
<Tab label="Webhook">

GitLab tells Productmind about merge requests through a webhook on each project. Without it,
Productmind never learns that a session's merge request was merged or closed.

Productmind adds the webhook itself when an application is linked to a GitLab project, wherever
the connection's GitLab account can manage the project's webhooks: that takes the **Maintainer**
or **Owner** role on the project, or an administrator of the GitLab server. **Project webhooks**
lists every project your applications use, read from GitLab when you open the tab:

| Status | What it means |
| --- | --- |
| **Delivers to Productmind** | The webhook sends the project's merge requests to Productmind. |
| **Added by Productmind** or **Re-pointed to this connection** | Productmind just added the webhook, or moved it from a connection that was replaced. |
| **Not added yet** or **Points at an old connection** | Choose **Add webhooks**. |
| **Add it by hand** | The connection's account can't manage the project's webhooks. Give the account the **Maintainer** role and choose **Add webhooks**. A webhook added with the steps below doesn't update sessions and releases. |
| **GitLab turned it off after failed deliveries** | In GitLab, send a test request from the webhook: GitLab turns it back on once one succeeds. |
| **Not found** or **Could not add it** | GitLab's own reason is shown. |

**Add webhooks** adds the missing webhooks, moves the ones that point at an old connection, and
sets the connection's secret again on the others. Productmind keeps a secret for each GitLab
connection, sets it on the webhooks it adds through that connection, and never shows it to anyone.
It is listed under **Webhook secrets** as **Productmind**: revoking it stops those webhooks until
you choose **Add webhooks** again. Productmind never removes a webhook. Choose **Check again**
after you change a role in GitLab.

Only the webhooks Productmind adds update your sessions and releases. Webhooks set up before each
connection had a secret of its own no longer do: choose **Add webhooks** once on each GitLab
connection to give them its secret. Then, under **Webhook secrets**, revoke the secret marked
**Earlier secret**: no webhook needs it any more.

A webhook you add by hand no longer updates sessions and releases either: its token is one someone
in your workspace holds, so Productmind can't tell its deliveries from anyone else's. Where you
can, give the connection's account the **Maintainer** role and choose **Add webhooks** instead.

To add the webhook by hand, on a project marked **Add it by hand** (the **Webhook** tab lists
these steps too):

1. On the **Webhook** tab, copy the **Webhook URL**.
2. In GitLab, open the project's **Settings › Webhooks** and choose **Add new webhook**. It takes
   the **Maintainer** role.
3. Paste the URL into **URL**. Choose **Generate signing token**, and copy the token GitLab shows:
   it shows it only once.
4. Back on the **Webhook** tab, under **Signing tokens**, paste the token into **Signing token**,
   optionally enter the project's name in **Project**, and choose **Add signing token**.
5. In GitLab, under **Trigger**, select **Merge request events**, and choose **Add webhook**.

Every project's webhook has its own signing token, so add one for each project. Each token you add
is listed under **Webhook secrets** with its project and its last four characters, and you can
revoke it there.

Instead of a signing token, a webhook can use a secret token: under **Webhook secrets**, choose
**Mint new secret**, then **Mint secret**, copy the secret, and paste it into GitLab's **Secret
token**. One secret serves every project. GitLab marks the secret token as not recommended, and a
webhook may have both.

GitLab turns a webhook off after deliveries fail. Once its token is added, open the webhook in
GitLab and send a test request: when the test succeeds, GitLab turns the webhook back on.

Replacing the token or the account keeps the Webhook URL. Disconnecting GitLab and connecting it
again makes a new connection with a new URL: Productmind moves the webhooks the account can manage
onto it, and the ones added by hand need the new URL.

</Tab>
<Tab label="Automations">

**GitLab to Productmind MR Event** passes each merge request your webhook reports as opened,
closed, merged or reopened to Productmind, which links it to its session, records deployments and
advances releases. Keep it on.

</Tab>
</Tabs>

### Jira and Asana

Once Jira or Asana is connected, its page offers **Import tasks from Jira** or **Import tasks
from Asana**. Both open the same import wizard as **Tasks**. See
[Tasks](/user-guide/tasks#to-import-tasks-from-jira).

When you connect Jira in the **Connect** dialog, choose **OAuth** to approve access in Atlassian,
or **Access token** to enter your Atlassian account email, an API token and your Jira Cloud URL.
Asana offers **OAuth** or an Asana personal access token.

### Freshdesk and Zendesk

Connect a helpdesk to import its support conversations into Productmind. See
[Freshdesk and Zendesk](/user-guide/settings/freshdesk-and-zendesk).

### Slack notifications

Once Slack is connected, its page has a **Notifications** section, where you choose which
channels Productmind posts workspace activity to: new work, status changes and assignments.
Description edits and reordering are not posted.

Each post opens with one line that says what happened and who did it, starting with the kind of
item, for example "Task status changed to Done by @alex". Below it, a card shows a short summary
when there is one, then the item's status and other details. A link to the item follows on a line
of its own, then an **Open** button. A small gray line closes the card with the Productmind logo,
the item's path, for example "tasks/513", and when it happened in your own time zone, for example
"Today at 11:23 AM".

#### To post workspace activity to a Slack channel

1. Open the Slack page, and under **Notifications**, choose **Add channel**.
2. Under **Channel**, choose the channel.
3. Under **Events**, select the events it should receive. They are grouped by **Features**,
   **Feature requests**, **Bug reports**, **Tasks**, **Code** and **Releases**.
4. Choose **Add channel**.

The channel appears in the list, with the groups of events it receives. Use its switch to pause
it, **Edit channel** to change it, or **Remove channel** to stop posting there.

Productmind must be a member of a private channel before it can post there. If a delivery fails,
the channel's row says why, for example "Invite the Productmind bot to #*channel*".

### MCP Servers

An MCP (Model Context Protocol) server gives your agents extra tools, such as reading from
another system your team uses. Once connected, you can attach it to a custom agent. You can also
connect an MCP server while you attach one to a custom agent. See
[Definitions](/user-guide/engineering/agents/definitions). **MCP Servers** is for the **Owner**
and **Admin** roles.

<Screenshot id="integrations-add-mcp" alt="The Add MCP server dialog, with the MCP server URL and Name fields, the Workspace and Just me scope buttons, and Advanced (OAuth client)" />

#### To connect an MCP server

1. On **Integrations**, under **MCP Servers**, choose **Add MCP server**.
2. Enter the **MCP server URL**. Productmind finds out from the server how to sign in to it.
3. If you want, enter a name under **Name (optional)**.
4. Under **Scope**, choose:
   - **Workspace**: "Agents run by anyone in this workspace can use this server."
   - **Just me**: "Only agents run on your behalf can use this server."
5. Choose **Connect**.
6. If the server needs you to sign in, you are taken to it. Approve access there.

Productmind shows "MCP server connected", and a card for the server appears under **MCP
Servers**, showing its name, its host name, **You** or **Workspace**, and how it signs in.

If the server can't register Productmind by itself, Productmind shows "This MCP server requires
an OAuth Client ID and Secret. Please fill them in below." and opens **Advanced (OAuth client)**.
Enter the **OAuth Client ID** and, if the server needs one, the **OAuth Client Secret**, and choose
**Connect** again.

#### To choose which of a server's tools agents can use

1. On **Integrations**, under **MCP Servers**, choose the server's card.
2. Under **Tools available**, turn a tool on or off. The **Filter tools** box narrows a long list.

The switch shows the tool's new state, and the change is saved at once.

Productmind lists a server's tools the first time you open its page, and **Last synced** shows
when. Choose **Refresh** to load them again after the server changes.

### MCP Clients

**MCP Clients** shows the address that MCP clients, such as Claude Code, Codex and GitHub Copilot,
use to connect to Productmind. Every role sees it. Choose **Copy** to copy the address, and add it
to your agent. Each agent's card has a **Setup guide** link to that agent's own instructions.

An agent's card says **You're connected** once you have signed in to Productmind from that agent,
and **Not connected** until then. The cards show your own connections, not your teammates'. See
[AI assistants (MCP)](/user-guide/tools/ai-assistants).

## How integrations behave

**Connections belong to a workspace.** Connecting a tool in one workspace doesn't connect it in
your other workspaces.

**Imports also connect.** The import wizards, for example **Import from Jira** on **Tasks**, start
with a **Connect** step when the tool isn't connected yet. Anyone who can run the import can
connect the tool there, without the **Owner** or **Admin** role. A tool connected there appears as
connected here.

**Your own accounts connect where you are asked to.** Besides **User connections**, you can connect
your own Slack account from your profile, and your own GitHub, GitLab or Bitbucket account from a
coding session you created. Either way, it appears as connected here.

## Permissions

| To | You need |
| --- | --- |
| Open **Integrations**, see **MCP Clients**, and connect, open and disconnect your own accounts under **User connections** | Any role |
| See **Integrations** in the sidebar | The **Owner** or **Admin** role |
| See **MCP Servers** and **Workspace integrations**, connect those tools and servers, disconnect them, and change their settings (automations, filters, notification channels) | The **Owner** or **Admin** role |
| Choose **Repair repository links** | The **Owner** or **Admin** role, or **Applications: Update** |
| Connect GitHub | The **Owner** or **Admin** role, and in GitHub, being an owner of the organization the app is installed on, or the owner of the personal account |
| Connect Jira or Asana from the import wizard on **Tasks** | **Tasks: Create** |
| Connect Freshdesk or Zendesk from the import wizard on **Customer support** | **Customer meetings & support: Create** |

## Troubleshooting

### Integrations is missing from the menu

The sidebar shows **Integrations** to the **Owner** and **Admin** roles. With any other role, choose
the **Integrations** icon at the top-right of the page, then **View all**.

### MCP Servers and Workspace integrations are missing

They are for the **Owner** and **Admin** roles. Ask one of them to connect a workspace tool or an
MCP server. If you have one of those roles and see a card naming a plan in their place, your
organization's plan doesn't include Integrations.

### A tool's page takes you back to Integrations

The page of a workspace integration or an MCP server is for the **Owner** and **Admin** roles.
With any other role, Productmind takes you back to **Integrations**. You can open the page of a
tool you connected with your own account, under **User connections**.

### "Connection failed" after approving access

The tool didn't complete the connection. Try again. For **Own OAuth app**, check that the
callback URL in your OAuth application matches the one in the **Connect** dialog exactly.

### "Your workspace's GitLab application doesn't allow the access Productmind asks for."

The OAuth application your workspace's GitLab connection uses doesn't allow a scope Productmind
asks for. In GitLab, open the application and select the scopes **api** and **read_user**, then
connect again. A member who sees this message asks an admin to change the application.

### "Your workspace's GitLab connection changed while you were signing in."

An admin connected your workspace's GitLab through another application, or disconnected it, while
you were signing in. Connect your GitLab account again.

### "GitLab did not grant the api scope, so nothing was saved."

GitLab approved access without the **api** scope, which every clone, push and merge request needs.
In GitLab, open your application, select the scopes **api** and **read_user**, save it, and
connect again. If you were replacing the connection, it still works as before.

### GitLab says "The requested scope is invalid, unknown, or malformed."

Your GitLab application lacks a scope Productmind asks for, so GitLab stops before you can approve,
and you stay on its page. In GitLab, open the application, select the scopes **api** and
**read_user**, save it, and connect again from Productmind. Nothing changed in Productmind: a
connection you were replacing still works as before.

### Replacing GitLab's connection says it is on another server

A replacement must use the same GitLab server as the connection: its applications, sessions and
webhook name projects on that server. Projects on two GitLab servers are different projects, even
with the same number or path. To use another server, disconnect GitLab and connect it again, then
choose **Add webhooks** on the **Webhook** tab, and give the projects marked **Add it by hand** the
new Webhook URL.

### Merge requests stopped updating sessions after GitLab was reconnected

Disconnecting and connecting GitLab again made a new connection, and GitLab still sends merge
request events to the old Webhook URL. On the **Webhook** tab on GitLab's page, choose **Add
webhooks**: it moves each webhook the connection's account can manage onto the new connection. For
a project marked **Add it by hand**, give the connection's account the **Maintainer** role and
choose **Add webhooks** again: a webhook added by hand doesn't update sessions.

### Merge requests stopped updating sessions and releases

Only the webhooks Productmind adds, each with its own connection's secret, update sessions and
releases. On the **Webhook** tab on each GitLab connection's page, choose **Add webhooks** once:
webhooks set up before each connection had a secret of its own then get it. A webhook added by
hand, and Bitbucket's pull requests, don't update sessions and releases: mark such a session
completed from the session itself.

### "This connection link has expired or was already used."

Too much time passed between choosing the tool's card and finishing in the tool, or the link was
used once already. Connect the tool again from **Integrations**.

### Only an owner can connect GitHub

Productmind shows "Only an owner of the GitHub organization, or the owner of the personal account,
can connect it to Productmind." Ask an owner of the organization to connect GitHub. If your
organization uses SAML single sign-on, the owner also needs an active single sign-on session in
GitHub.

### "This GitHub installation is already connected to another Productmind workspace."

A GitHub organization or account connects to one Productmind workspace at a time. Disconnect GitHub
in the other workspace first, then connect it here. Because disconnecting uninstalls the
Productmind GitHub App, an owner installs it again when you connect.

### A Slack channel receives nothing

If the channel is private, invite Productmind to it. Check that the channel's switch is on, and
that it is subscribed to the events you expect.

### A session failed with "GitHub access for this workspace was removed"

The Productmind GitHub App is no longer installed on the GitHub organization or account your
session's repositories belong to (or the session says it was suspended). The session shows
**Reconnect GitHub**: reconnect GitHub (see [To reconnect GitHub](#to-reconnect-github)), then
choose **Retry** on the session. If you don't see **Reconnect GitHub**, ask an Owner or Admin of
your workspace to reconnect it.

### An application can't reach its repository after a reconnect

Open the Git provider's page and choose **Repair repository links**. If Productmind still lists
the repository as unreachable, the connection no longer has access to it. Give Productmind access
to that repository in your Git provider.

## Related topics

- [Freshdesk and Zendesk](/user-guide/settings/freshdesk-and-zendesk)
- [Applications](/user-guide/engineering/applications)
- [Tasks](/user-guide/tasks)
- [Definitions](/user-guide/engineering/agents/definitions)
- [AI assistants (MCP)](/user-guide/tools/ai-assistants)
- [Profile and notifications](/user-guide/profile-and-notifications)
