> ## Documentation Index
> Fetch the complete documentation index at: https://gleanfeed.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect over MCP

> Connect an AI assistant to Glean Feed, approve read or write access, and confirm the connection with a safe first prompt.

Connect an AI assistant to Glean Feed when you want to work with customer feedback and product updates in conversation. You choose one workspace and approve what the assistant may read or change. Glean Feed uses the open Model Context Protocol (MCP) to provide those approved tools without giving the assistant your password or an API key.

## What you can do

* Triage new feedback and summarize recurring themes.
* Research requests and their customer conversations.
* Draft an update from completed work.
* Review or move roadmap work.
* Build custom agent workflows around supported Glean Feed operations.

For a first connection, have the client request read-only scopes when it supports permission selection. Request write scopes only for a specific workflow and after you are comfortable reviewing proposed changes.

## Prerequisites

Before connecting, you need:

* Access to the Glean Feed workspace you want the assistant to use.
* A current MCP client that supports remote servers and OAuth.
* Permission to add a remote connector in that client. Client plan and organization rules may limit who can add one.
* The Glean Feed endpoint:

```text theme={null}
https://app.gleanfeed.com/api/mcp
```

You can copy the endpoint from **Settings → MCP** in the Glean Feed dashboard. Glean Feed hosts the server, so there is no local command or package to run.

## Connect

The shared flow is the same for every client:

<Steps>
  <Step title="Add the remote endpoint">
    Add `https://app.gleanfeed.com/api/mcp` as a remote MCP server. The client discovers Glean
    Feed's sign-in and permission flow from that URL.
  </Step>

  <Step title="Open the sign-in">
    Choose **Connect**, **Authorize**, or your client's equivalent. Your browser opens Glean Feed;
    the assistant never receives your password.
  </Step>

  <Step title="Return to the assistant">
    After approval, return to the client and enable Glean Feed for the conversation or workspace
    where you want to use it.
  </Step>
</Steps>

### Client instructions

The endpoint and approval flow stay the same; only the client setup differs.

<Tabs>
  <Tab title="Claude">
    Claude Desktop or claude.ai — add Glean Feed as a custom connector.

    Remote custom connectors require a Claude Pro, Max, Team, or Enterprise plan. On Team and
    Enterprise, an Owner or Primary Owner must add the organization connector before members can
    connect it individually.

    **Pro or Max**

    1. Open **Settings → Connectors** and choose **Add custom connector**.
    2. Name it **Glean Feed**, paste the endpoint URL, and choose **Add**.
    3. Find Glean Feed and click **Connect**, then complete the Glean Feed approval.

    **Team or Enterprise**

    1. An Owner or Primary Owner opens **Settings → Connectors → Organization connectors**, chooses
       **Add custom connector**, and adds the Glean Feed endpoint.
    2. A member opens **Settings → Connectors**, finds Glean Feed in the organization's connectors,
       and clicks **Connect**.
    3. The member completes the Glean Feed workspace and scope approval.
  </Tab>

  <Tab title="Cursor">
    Add the endpoint to your Cursor MCP config — Cursor handles the sign-in.

    ```json ~/.cursor/mcp.json theme={null}
    {
      "mcpServers": {
        "glean-feed": {
          "url": "https://app.gleanfeed.com/api/mcp"
        }
      }
    }
    ```

    Use `~/.cursor/mcp.json` for every project, or a project-level `.cursor/mcp.json` for one repo. Then open **Cursor Settings → MCP** and authorize when the browser sign-in opens.
  </Tab>

  <Tab title="Codex">
    OpenAI's CLI — add the server to `config.toml`, then sign in from your terminal.

    ```toml ~/.codex/config.toml theme={null}
    [mcp_servers.glean-feed]
    url = "https://app.gleanfeed.com/api/mcp"
    ```

    Then run:

    ```bash theme={null}
    codex mcp login glean-feed
    ```

    This opens the OAuth sign-in in your browser. (`codex mcp logout glean-feed` disconnects.)
  </Tab>

  <Tab title="VS Code">
    GitHub Copilot's agent mode — add it to your workspace MCP config.

    ```json .vscode/mcp.json theme={null}
    {
      "servers": {
        "glean-feed": {
          "type": "http",
          "url": "https://app.gleanfeed.com/api/mcp"
        }
      }
    }
    ```

    VS Code opens the OAuth sign-in automatically the first time it connects. You can also run **MCP: Add Server** from the Command Palette and paste the URL.
  </Tab>

  <Tab title="Any MCP client">
    Any assistant that supports remote MCP can connect. Add the endpoint as a **remote Streamable HTTP** server (not a local command). The client discovers the OAuth configuration from the server, registers itself, and opens the Glean Feed sign-in.

    The server speaks the Streamable HTTP transport and authenticates with OAuth 2.1, including Dynamic Client Registration — so most current clients connect with nothing more than the URL.
  </Tab>
</Tabs>

Prefer not to touch config files? Copy this prompt into your coding agent — or open it straight in Cursor — and it'll add the server to the right config and walk you through the sign-in. You'll also find it under **Settings → MCP** in the dashboard.

<Prompt description="Connect the Glean Feed MCP server to your assistant." icon="sparkles" actions={["copy", "cursor"]}>
  Connect the Glean Feed MCP server for me.

  It's a remote MCP server (Streamable HTTP + OAuth 2.1 — no API key, no local command).
  Endpoint: [https://app.gleanfeed.com/api/mcp](https://app.gleanfeed.com/api/mcp)

  Add it as an MCP server named "glean-feed" to the right config for the MCP client I'm using (for example \~/.cursor/mcp.json for Cursor, or \~/.codex/config.toml for Codex), using the remote URL above — not a local command. Then tell me how to finish the OAuth sign-in (for Codex, run `codex mcp login glean-feed`) and show me the exact config you added so I can confirm it.
</Prompt>

## Approve a workspace and permissions

Glean Feed asks you to choose one workspace and review the scopes requested by the client. A scope is a named permission such as `feedback:read` or `roadmap:write`.

For a read-only first connection, configure the client to request this set when it supports scope selection:

```text theme={null}
feedback:read   changelog:read   roadmap:read   workspace:read
```

The consent screen shows the complete requested set. You approve that set or cancel the connection; you cannot remove individual scopes on the Glean Feed screen. To change the grant, revoke it and reconnect with the client requesting a different set.

The OAuth connection is bound to your identity, that workspace, and the approved request. The assistant cannot switch the connection to another workspace. An ID outside the approved workspace returns not found, and losing workspace access or revoking the connection cuts off the next request.

<Warning>
  Write scopes let an assistant create or change workspace content. If a client requests more access
  than you intend to grant, cancel instead of approving. Request only the write scope needed for a
  planned workflow, and review the proposed action before allowing the tool call.
</Warning>

## Confirm the connection

Use a read-only prompt first:

<Prompt description="Confirm read-only access to the selected workspace." icon="list-checks" actions={["copy", "cursor"]}>
  Summarize this Glean Feed workspace for me. Tell me the workspace name, then list the five most
  recent feedback requests with their stage. Do not change anything.
</Prompt>

The connection works when the assistant names the workspace and returns recent requests, or clearly says that none exist. If it reports a missing scope, revoke the connection and reconnect after configuring the client to request that scope.

## Example prompts

### Read-only feedback review

```text theme={null}
Group the 20 most recent feedback requests into themes. Cite the request titles in each group,
call out likely duplicates, and recommend what I should investigate next. Do not change anything.
```

### Purposeful write workflow

After reconnecting with a grant that includes `changelog:write`, use a draft-first prompt:

```text theme={null}
Review the completed roadmap work and recent feedback. Propose a short changelog update with a
title, body, and relevant linked requests. Show me the complete draft first. Create it as a draft
only after I approve the text; do not publish it.
```

## Install optional agent skills

Install packaged workflows when you want your agent to follow a repeatable process for changelog drafting, feature evaluation, or feedback triage:

```bash theme={null}
npx skills add MSW-Digital/glean-feed-skills
```

The installer lets you choose individual skills. See [Agent skills](/api/agent-skills) for selective install commands, required scopes, and copyable starter prompts.

## Permission reference

Each tool requires the scope shown. Read tools do not expose customer personal data, and a missing ID or an ID outside the connected workspace returns not found.

### Read tools

| Tool                      | Scope            | What it does                                                            |
| ------------------------- | ---------------- | ----------------------------------------------------------------------- |
| `list_feedback`           | `feedback:read`  | List feedback requests, optionally filtered by stage, board, or search. |
| `get_feedback_request`    | `feedback:read`  | Get one feedback request by id.                                         |
| `list_feedback_comments`  | `feedback:read`  | List the comments on a feedback request.                                |
| `list_changelog`          | `changelog:read` | List changelog entries, including drafts.                               |
| `get_changelog_entry`     | `changelog:read` | Get one changelog entry by id.                                          |
| `list_changelog_comments` | `changelog:read` | List the comments on a changelog entry.                                 |
| `list_tags`               | `changelog:read` | List the workspace's tags (id, name, color) for use with `tagIds`.      |
| `list_roadmap`            | `roadmap:read`   | List roadmap items, including optional target delivery.                 |
| `get_roadmap_item`        | `roadmap:read`   | Get one roadmap item by id, including optional target delivery.         |
| `get_workspace`           | `workspace:read` | Get the workspace summary without customer personal data.               |

### Write tools

| Tool                            | Scope             | What it does                                                                                                      |
| ------------------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------- |
| `create_feedback_request`       | `feedback:write`  | Create a feedback request on a board.                                                                             |
| `update_feedback_request`       | `feedback:write`  | Edit a request's title or description.                                                                            |
| `set_feedback_status`           | `feedback:write`  | Set a request's moderation status.                                                                                |
| `set_feedback_stage`            | `feedback:write`  | Set a request's product stage; pending and closed are private, other stages are public.                           |
| `promote_feedback_to_roadmap`   | `roadmap:write`   | Promote a request at an explicit roadmap stage, optionally set delivery, and return the linked item and feedback. |
| `preview_feedback_linear_issue` | `roadmap:write`   | Resolve the accepted request, Linear destination, proposed issue, and existing link without creating work.        |
| `send_feedback_to_linear`       | `roadmap:write`   | Create and link one Linear issue after explicit confirmation; retries return the active issue.                    |
| `merge_feedback_requests`       | `feedback:write`  | Merge a duplicate request into another; moves votes and comments, then closes the duplicate.                      |
| `add_comment`                   | `comments:write`  | Post a comment or staff reply on a request.                                                                       |
| `create_changelog_entry`        | `changelog:write` | Create a changelog draft (version, tags, linked requests, scheduled publish time, reaction/comment toggles).      |
| `update_changelog_entry`        | `changelog:write` | Edit a changelog entry (title, body, version, tags, linked requests, schedule, reaction/comment toggles).         |
| `publish_changelog_entry`       | `changelog:write` | Publish a changelog entry (emails customers with an address who have not opted out on first publish).             |
| `delete_changelog_entry`        | `changelog:write` | Permanently delete a changelog entry (cascades to links/reactions/comments).                                      |
| `add_changelog_comment`         | `comments:write`  | Post a comment or staff reply on a changelog entry.                                                               |
| `create_roadmap_item`           | `roadmap:write`   | Create a roadmap item (also creates a backing feedback request), optionally with target delivery.                 |
| `update_roadmap_item`           | `roadmap:write`   | Edit a roadmap item's title, description, or target delivery.                                                     |
| `move_roadmap_stage`            | `roadmap:write`   | Move a roadmap item to a stage.                                                                                   |

For Linear execution, call `preview_feedback_linear_issue` first. Show the returned request title, destination team/project, and proposed issue title to the user, then call `send_feedback_to_linear` only after explicit confirmation. Both tools use the workspace's existing Linear connection and permitted defaults/overrides; the create tool makes external work and is idempotent for the active link.

## Troubleshooting

* **The endpoint must be reachable over the public internet.** The assistant (or its cloud backend) connects to `https://app.gleanfeed.com/api/mcp` directly — there's nothing to run locally.
* **Use a current client version.** Remote MCP and OAuth support is recent in most clients; if a connection fails, update the client first.
* **Re-approval after revoking.** If you revoke a client under **Settings → MCP**, it stops working immediately and has to reconnect and be approved again.

## Revoke access

Open **Settings → MCP** in Glean Feed, find the connected client, and choose **Revoke**. The connection stops working on its next request. Remove the connector from the assistant's settings too if you no longer want it listed there.

To reconnect later, add or enable the server again and complete a new approval. Revoking an old connection does not grant a replacement connection any access.

## Next steps

<Columns cols={2}>
  <Card title="Scopes" icon="https://mintcdn.com/gleanfeed/XujswKjVl9A7LyQN/icons/key.svg?fit=max&auto=format&n=XujswKjVl9A7LyQN&q=85&s=bef0e09f655d6e92652b5049ef64ab72" href="/api/scopes" width="24" height="24" data-path="icons/key.svg">
    Decide what an assistant should be allowed to do.
  </Card>

  <Card title="Examples" icon="https://mintcdn.com/gleanfeed/XujswKjVl9A7LyQN/icons/rocket.svg?fit=max&auto=format&n=XujswKjVl9A7LyQN&q=85&s=1dfbf3c65c490009d6014cfb2bd08963" href="/api/examples" width="24" height="24" data-path="icons/rocket.svg">
    Try REST filtering, pagination, and server-side request creation.
  </Card>
</Columns>
