# Introduction
Source: https://docs.weavable.ai/introduction

Plug real work context into your entire AI stack

<iframe title="Weavable" />

Weavable is the context layer between your stack and your agents — structured, scoped, and maintained — giving AI persistent access to your team's work across Jira, GitHub, Slack, Linear, Notion, HubSpot, Zendesk, and 25+ other tools through a single MCP connection.

Ask in a conversation:

> *Summarize what the team shipped this week and draft a status email for leadership.*

Or let an agent act on it:

> *Pull the latest customer feedback trends and draft a product brief.*

## Why Weavable

### One connection, all your tools

Skip setting up and maintaining individual MCP servers for every tool. One Weavable connection — one endpoint, one auth — gives AI access to 25+ tools at once. For agents, that's one reliable data source instead of a dozen fragile integrations.

### A connected graph, not disconnected fragments

Individual tool MCPs return siloed data. Weavable **contexts** combine multiple tools into a unified view, mapping relationships across your stack before any query runs. The model reasons over a connected graph, not five separate feeds to stitch together.

### Built on a changelog, not a snapshot

Weavable runs a continuous changelog across your stack — what changed, when, and what it connects to, tracked *before* you ask. So *"what's happening with Acme"* is built on accumulated changes across HubSpot, Jira, and Slack, not a snapshot taken a second ago.

### Deterministic pipeline, not raw API data

A deterministic pipeline scopes, ranks, and de-noises your data before any AI gets involved. Your model receives structured, ready-to-reason-about context — not thousands of lines of raw JSON. Same scoped foundation every run: same answer at 9am and at midnight.

### Portable across any AI

Set up your contexts once. Use them from Claude, ChatGPT, Cursor, Windsurf, custom agents, or anything else that supports MCP.

## Get connected

You'll need a Weavable account with at least one [context](/product/contexts) set up, and an AI assistant or agent that supports MCP.

The MCP server is at:

```
https://mcp.weavable.ai/mcp
```

See [Connect a client](/mcp/connect) for step-by-step setup for Claude, Claude Code, ChatGPT, VS Code, and other clients.

## Example use cases

* **Engineering manager** — *"Pull what the team shipped and what's blocked since yesterday, and give me three talking points for standup."*
* **Product manager** — *"Draft a weekly status email covering what shipped, what's in flight, and any risks."*
* **Sales lead** — *"Summarize which deals moved stage in HubSpot this week and draft follow-up notes for each."*
* **Support lead** — *"Identify the top themes in Zendesk tickets from the past two weeks and draft a summary for the product team."*
* **Design lead** — *"Pull Figma updates and Slack feedback since our last review and compile them into a changelog."*
* **Agents** — daily briefings, automated reports from this month's customer feedback, hourly P0 monitoring — no human in the loop.


# Connect a client
Source: https://docs.weavable.ai/mcp/connect

Configure Claude, Claude Code, ChatGPT, VS Code, and other MCP clients to connect to Weavable

Give your AI assistant access to Weavable through a single MCP connection. Pick your client below for setup steps.

## Server URL

The Weavable MCP server is available at:

```
https://mcp.weavable.ai/mcp
```

When prompted for a name, use:

```
weavable
```

Authentication happens via OAuth — sign in with your Weavable account when the client prompts you.

***

## Claude

<Steps>
  <Step title="Open Claude's connector settings">
    Go to [claude.ai/customize/connectors](https://claude.ai/customize/connectors), or in the desktop app go to **Customize → Connectors**.
  </Step>

  <Step title="Add a custom connector">
    Click **+** and choose **Add custom connector**.
  </Step>

  <Step title="Enter the connection details">
    * **Name:** `weavable`
    * **Remote MCP Server URL:** `https://mcp.weavable.ai/mcp`
  </Step>

  <Step title="Connect">
    Find **weavable** under **Not Connected** and click **Connect**.
  </Step>

  <Step title="Authorize">
    Sign in with your Weavable account when prompted and authorize Claude.
  </Step>

  <Step title="Try a prompt">
    ```
    From Weavable summarise any changes from {context name} in the past week
    ```
  </Step>
</Steps>

***

## Claude Code

<Steps>
  <Step title="Add the MCP server">
    In your terminal, run:

    ```bash theme={null}
    claude mcp add --transport http weavable https://mcp.weavable.ai/mcp
    ```
  </Step>

  <Step title="Verify the connection">
    Open Claude Code and run the **/mcp** command.
  </Step>

  <Step title="Try a prompt">
    Reference `weavable` explicitly in prompts:

    ```
    From Weavable summarise any changes from {context name} in the past week
    ```
  </Step>
</Steps>

***

## ChatGPT

<Steps>
  <Step title="Enable Developer mode">
    In ChatGPT, open **Settings → Connectors → Advanced** and toggle **Developer mode** on. Requires Pro, Plus, Business, Enterprise, or Edu.
  </Step>

  <Step title="Create a connector">
    Back in **Settings → Connectors**, click **Create**.
  </Step>

  <Step title="Fill in the details">
    * **Name:** `weavable`
    * **MCP Server URL:** `https://mcp.weavable.ai/mcp`
    * **Authentication:** OAuth
  </Step>

  <Step title="Authorize">
    Sign in with your Weavable account when prompted to authorize ChatGPT.
  </Step>

  <Step title="Use it in a conversation">
    Enable the **weavable** connector for the conversation and try:

    ```
    From Weavable summarise any changes from {context name} in the past week
    ```
  </Step>
</Steps>

***

## VS Code

<Steps>
  <Step title="Open the command palette">
    In the top menu bar, click **View → Command Palette…**
  </Step>

  <Step title="Add an MCP server">
    Type **MCP: Add Server…** and select the option, then choose **HTTP (HTTP or Server-Sent Events)**.
  </Step>

  <Step title="Enter the connection details">
    * **URL:** `https://mcp.weavable.ai/mcp`
    * **ID / name:** `weavable`
  </Step>

  <Step title="Authorize">
    Sign in with your Weavable account when prompted and authorize VS Code.
  </Step>

  <Step title="Try a prompt">
    Prompt the VS Code agent to use weavable:

    ```
    From Weavable summarise any changes from {context name} in the past week
    ```
  </Step>
</Steps>

***

## Other clients

Any MCP-compatible client or agent framework — Cursor, Windsurf, custom agents — can connect with these details:

* **URL:** `https://mcp.weavable.ai/mcp`
* **Name:** `weavable`
* **Transport:** Streamable HTTP

Auth happens automatically via OAuth — sign in with your Weavable account when prompted.

Example prompt:

```
From Weavable summarise any changes from {context name} in the past week
```


# MCP server overview
Source: https://docs.weavable.ai/mcp/overview

What the Weavable MCP server is and how it fits into your AI stack

The Model Context Protocol (MCP) is an open standard that lets AI assistants and agents connect to external tools and data sources through a uniform interface. Weavable runs a hosted MCP server that exposes your [contexts](/product/contexts) to any MCP-compatible client.

One endpoint, one sign-in, every MCP-compatible client.

<Frame>
  <img alt="Weavable MCP endpoint connecting to Claude, ChatGPT, Cursor, and any custom agent" />
</Frame>

## How it works

When a client calls a Weavable [tool](/mcp/tools), it doesn't get raw API data from Slack or Jira dumped at the model. The request runs through Weavable's pipeline first: your context scopes the query to the data sources you configured, related items are pulled in across tools, and results are de-noised and ranked before being returned as structured markdown the model can reason over directly.

<Frame>
  <img alt="Weavable MCP architecture: AI client connects through MCP, contexts pull from connected tools, results flow back as structured context" />
</Frame>

## Authentication

Sign in once with your Weavable account and your client stays connected — no per-tool credentials and no per-app reconfiguration. The MCP client only sees your contexts; it never gets direct access to your underlying app connections. All requests are scoped to you: tools can only return contexts you own or have been shared on, and each context only returns the data sources it was configured with.

Most clients (Claude, Claude Code, ChatGPT, VS Code, Cursor, etc.) handle sign-in automatically. See [Connect a client](/mcp/connect) for per-client setup.

## What you can do with it

Three tools, composable into most workflows:

* [`list-contexts`](/mcp/tools#list-contexts) — discover what contexts you have, their data sources, and which insights are compatible
* [`context-summary`](/mcp/tools#context-summary) — generate a written summary from a context, scoped by query and time range
* [`context-insight`](/mcp/tools#context-insight) — generate a markdown chart, table, or other visualization for a context

The full reference, including parameters and example payloads, is on the [Tool reference](/mcp/tools) page.


# Tool reference
Source: https://docs.weavable.ai/mcp/tools

Reference for the tools exposed by the Weavable MCP server

The Weavable MCP server exposes three tools. All tools require an authenticated session — see [Connect a client](/mcp/connect) for setup.

The typical workflow is:

1. Call **`list-contexts`** to discover what's available and to obtain `contextId`s and `insightId`s.
2. Call **`context-summary`** with a `contextId`, a natural-language `query`, and a time range to generate a written summary.
3. Call **`context-insight`** with a `contextId` and an `insightId` from step 1 to generate a markdown insight (chart/table/visualization rendered as markdown).

***

## list-contexts

Lists all contexts accessible by the authenticated user. Each entry describes the context's data sources and the insight IDs that are compatible with it.

### Parameters

*None.*

### Returns

A JSON array of context objects:

| Field                | Type                  | Description                                                                                                         |
| -------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `id`                 | string                | Context ID. Pass to `context-summary` and `context-insight`.                                                        |
| `title`              | string                | Human-readable context title.                                                                                       |
| `created`            | string (ISO datetime) | When the context was created.                                                                                       |
| `updated`            | string (ISO datetime) | When the context was last updated.                                                                                  |
| `dataSources`        | array                 | Data sources backing the context. Each item has `app` (e.g. `"GitHub"`), `name`, and an optional `type`.            |
| `compatibleInsights` | array                 | Insights that can be generated against this context. Each item has `id` and `name`. Pass `id` to `context-insight`. |

Contexts with no data sources are omitted. Results are sorted by most recently created first.

### Example

```json theme={null}
[
  {
    "id": "ctx_01HXYZ...",
    "title": "Engineering weekly",
    "created": "2026-04-21T10:14:00.000Z",
    "updated": "2026-05-06T08:02:11.000Z",
    "dataSources": [
      { "app": "GitHub", "name": "weavable/api", "type": "Repository" },
      { "app": "Linear", "name": "Backend", "type": "Team" }
    ],
    "compatibleInsights": [
      { "id": "insight_pr_throughput", "name": "PR throughput" },
      { "id": "insight_issue_burndown", "name": "Issue burndown" }
    ]
  }
]
```

***

## context-summary

Generates a written summary from a context using a natural-language query and a time range.

### Parameters

| Name        | Type   | Required | Description                                                                        |
| ----------- | ------ | -------- | ---------------------------------------------------------------------------------- |
| `contextId` | string | yes      | The ID of the context to summarize, from `list-contexts`.                          |
| `query`     | string | yes      | The question, summarization instruction, or prompt.                                |
| `fromDate`  | string | yes      | Start of time range. ISO date (`2025-02-25`) or datetime (`2025-02-25T00:00:00Z`). |
| `toDate`    | string | no       | End of time range, same format as `fromDate`. Defaults to now.                     |
| `timeZone`  | string | no       | IANA timezone (e.g. `America/New_York`). Defaults to UTC.                          |

### Returns

Markdown text containing the generated summary. While the summary is being generated, the server emits MCP `notifications/progress` events (rendered by the client as a running word count) so the UI stays responsive during long generations.

If the request fails, the response is returned with `isError: true` and the text contains a human-readable error message.

### Example

Request:

```json theme={null}
{
  "contextId": "ctx_01HXYZ...",
  "query": "Summarise PRs merged and notable issues opened",
  "fromDate": "2026-04-30",
  "toDate": "2026-05-07",
  "timeZone": "America/New_York"
}
```

Response (text content, truncated):

```markdown theme={null}
## Engineering weekly — Apr 30 to May 7

**PRs merged (12)**
- Auth: migrated session token storage to satisfy compliance review …
- Frontend: reworked the canvas share modal …

**Notable issues opened (3)**
- P0: webhook retries timing out for Slack connector …
```

***

## context-insight

Generates a markdown insight (chart, table, or other visualization rendered as markdown) for a context using a given insight ID. Only `insightId`s returned by `list-contexts` for that context are valid.

### Parameters

| Name        | Type   | Required | Description                                                                                |
| ----------- | ------ | -------- | ------------------------------------------------------------------------------------------ |
| `contextId` | string | yes      | The ID of the context.                                                                     |
| `insightId` | string | yes      | The ID of the insight to generate, from the `compatibleInsights` array on `list-contexts`. |

### Returns

Markdown text with the rendered insight, prefixed with the insight title as an `## H2` heading.

If the context cannot be found or the user lacks access, the response text is `"Context not found or access denied"`. If the insight isn't compatible with the context, the response explains that and points back to `list-contexts`.

### Example

Request:

```json theme={null}
{
  "contextId": "ctx_01HXYZ...",
  "insightId": "insight_pr_throughput"
}
```

Response (text content, truncated):

```markdown theme={null}
## PR throughput

| Week         | Opened | Merged | Median time to merge |
| ------------ | ------ | ------ | -------------------- |
| 2026-04-21   | 18     | 14     | 1d 4h                |
| 2026-04-28   | 22     | 19     | 0d 21h               |
```


# Adding a connection
Source: https://docs.weavable.ai/product/connections/adding

Connect Weavable to one of your team's tools via OAuth

For most companies, connecting your Weavable account with supported apps like Notion or Slack is quick and seamless. However, some organizations have security policies that require admin approval before new integrations can be used.

<Steps>
  <Step title="Log in to Weavable">
    Sign in to your Weavable account.
  </Step>

  <Step title="Pick an app to connect">
    From the **Apps** page, select the app you want to connect (Notion, Slack, Linear, etc.).
  </Step>

  <Step title="Authorize Weavable">
    Complete the connection process — you'll be redirected to the app to authorize Weavable.
  </Step>

  <Step title="Wait for admin approval (if required)">
    If admin approval is needed, your IT/admin team will receive a notification. See the [admin approval table](/product/connections/overview#admin-approval-by-app) on the overview page for per-app references. Once approved, return to Weavable and reconnect the app.
  </Step>

  <Step title="Wait for processing">
    The connection will now start processing. This usually takes a few minutes. Once it's done, the connection is ready to use in [contexts](/product/contexts).
  </Step>
</Steps>


# Email inbox forwarding
Source: https://docs.weavable.ai/product/connections/email-forwarding

Forward selected emails from Gmail, Outlook, or any provider into a Weavable inbox

You can automatically forward selected emails from your inbox (like Gmail or Outlook) to Weavable.

## Create a Weavable email inbox

<Steps>
  <Step title="Open the Apps page">
    From the Weavable sidebar, go to **Apps**.
  </Step>

  <Step title="Click Email">
    <Frame>
      <img alt="Email button on the Apps page" />
    </Frame>
  </Step>

  <Step title="Name your inbox">
    Give your inbox a name. For example, if you're forwarding support emails, you can name it `Support`. If you're forwarding emails from a customer like Acme, you can name it `Acme`.
  </Step>

  <Step title="Get your forwarding address">
    Click **Next**. Weavable will generate an email address you can use. Copy this address and follow the steps below for your email provider.
  </Step>
</Steps>

***

## Outlook

### Forward specific emails (using rules)

<Steps>
  <Step title="Open Outlook">
    Open Outlook (desktop or web).
  </Step>

  <Step title="Open rules">
    Go to **Settings → View all Outlook settings → Mail → Rules** (on the web), or **Home → Rules → Manage Rules & Alerts → New Rule** (in the desktop app).
  </Step>

  <Step title="Choose the trigger">
    Choose **Apply rule on messages I receive**.
  </Step>

  <Step title="Set conditions">
    Under conditions, select how to identify the messages you want to forward:

    * From a specific sender or domain
    * Containing certain words in the subject or body
  </Step>

  <Step title="Set the action">
    Under actions, choose **forward it to people or public group**, then enter your Weavable inbox address.
  </Step>

  <Step title="Save the rule">
    Click **Next**, name the rule, ensure **Turn on this rule** is checked, and click **Finish** / **Save**.
  </Step>
</Steps>

Only emails matching your selected criteria will be forwarded to Weavable.

### Forward emails from a specific folder

<Steps>
  <Step title="Open rules">
    Go to **File → Manage Rules & Alerts** (or **Home → Rules → Manage Rules & Alerts**).
  </Step>

  <Step title="Create a new rule">
    Click **New Rule → Apply rule on messages I receive → Next**.
  </Step>

  <Step title="Pick the folder">
    In the conditions list, check **which is in the specified folder** and choose the folder you want to forward from.
  </Step>

  <Step title="Set the action">
    In the actions step, select **forward it to people or public group**, then enter your Weavable inbox address.
  </Step>

  <Step title="Save the rule">
    Click **Next**, give the rule a name, make sure **Turn on this rule** is checked, and click **Finish**.
  </Step>

  <Step title="(Optional) Backfill existing emails">
    To forward existing emails already in that folder, choose **Run this rule now on messages already in this folder** before saving.
  </Step>
</Steps>

***

## Gmail

### Step 1: Add your Weavable forwarding address

<Steps>
  <Step title="Open settings">
    Sign in to Gmail. Click the ⚙️ gear icon → **See all settings → Forwarding and POP/IMAP**.
  </Step>

  <Step title="Add the address">
    Under **Forwarding**, click **Add a forwarding address** and enter your Weavable inbox address.
  </Step>

  <Step title="Save">
    Click **Save Changes**.
  </Step>
</Steps>

### Step 2: Create a filter to forward specific emails

<Steps>
  <Step title="Open filters">
    Go to **Settings → Filters and Blocked Addresses → Create a new filter**.
  </Step>

  <Step title="Set criteria">
    Add your filter criteria — sender, keywords, or subject.
  </Step>

  <Step title="Create the filter">
    Click **Create filter**.
  </Step>

  <Step title="Set the forward action">
    Check **Forward it to**, select your Weavable inbox address, and click **Create filter** again.
  </Step>
</Steps>

You can create multiple filters to forward different types of emails to different Weavable inboxes.

***

## Other email providers or clients

If you use a different email provider, consult their documentation for how to forward or filter incoming emails. If you need help, reach out to us at [support@weavable.ai](mailto:support@weavable.ai).


# Tracking GitHub commits
Source: https://docs.weavable.ai/product/connections/github-commits

Configure a GitHub webhook to send commit activity to Weavable, in addition to PRs

The Weavable GitHub integration tracks PRs in your connected repositories by default. To track all commits — not just PRs — add a webhook in GitHub.

<Steps>
  <Step title="Open GitHub settings">
    Go to your **GitHub Organization** or **repository** page and click **Settings**.

    Going to the **Organization** page lets you track all repositories in the org. Going to an individual **repository** page tracks just that repo.
  </Step>

  <Step title="Open Webhooks">
    In the **Settings** page, click **Webhooks** in the left sidebar.
  </Step>

  <Step title="Add a webhook">
    Click **Add Webhook**.
  </Step>

  <Step title="Set the webhook properties">
    * **Payload URL:** `https://app.thatworks.ai/api/connectors/hook/github`
    * **Content Type:** `application/json`
    * Leave the rest at their defaults: **Secret** must be empty, **SSL Verification** is enabled, and events are set to **push**.

    <Frame>
      <img alt="GitHub webhook configuration form with the Weavable payload URL and application/json content type" />
    </Frame>
  </Step>

  <Step title="Save">
    Click **Add Webhook**.
  </Step>
</Steps>


# Connecting HubSpot
Source: https://docs.weavable.ai/product/connections/hubspot

Grant the HubSpot permissions Weavable needs and connect your account

To connect your HubSpot account to Weavable, you must be a **super admin** *or* have the HubSpot **App Marketplace Access** permission. This permission allows a user to install and authorize third-party apps.

## Who can connect HubSpot

* HubSpot super admins automatically have App Marketplace Access.
* Any user can connect HubSpot as long as they have App Marketplace Access enabled.
* If a user can't connect, an admin must grant this permission.

## Granting App Marketplace Access

HubSpot accounts manage user permissions in two ways: **individual user permissions** or **permission sets**. The flow you'll follow depends on which one your account uses.

### Check which one applies

<Steps>
  <Step title="Sign in as a super admin">
    Log in to HubSpot as a super admin.
  </Step>

  <Step title="Open user settings">
    In the upper-right, click **Settings**, then go to **Users & Teams** in the left sidebar.
  </Step>

  <Step title="Find the user">
    Search for the user you want to grant access to.
  </Step>

  <Step title="Check the Permission Sets column">
    * If **no permission set is assigned** (`--`), follow [Grant permission directly](#grant-permission-directly) below.
      <Frame>
        <img alt="HubSpot Users & Teams page with no permission set assigned to the user (dashes in the Permission Sets column)" />
      </Frame>
    * If **a permission set is assigned**, follow [Grant access through a permission set](#grant-access-through-a-permission-set) below.
      <Frame>
        <img alt="HubSpot Users & Teams page with a permission set assigned to the user" />
      </Frame>
  </Step>
</Steps>

### Grant permission directly

Use this flow if your HubSpot account does not use permission sets.

<Steps>
  <Step title="Sign in as a super admin">
    Log in to HubSpot as a super admin.
  </Step>

  <Step title="Open user settings">
    In the upper-right, click **Settings**, then go to **Users & Teams** in the left sidebar.
  </Step>

  <Step title="Edit the user">
    Hover over the user who needs access and click **Edit Permissions**.
  </Step>

  <Step title="Open Settings Access">
    In the left sidebar, select **Settings Access** under **Account**.
  </Step>

  <Step title="Enable App Marketplace Access">
    Toggle **App Marketplace Access** on, then click **Save**.

    <Frame>
      <img alt="App Marketplace Access toggle enabled on the Settings Access page" />
    </Frame>
  </Step>
</Steps>

The user can now connect HubSpot to Weavable.

### Grant access through a permission set

Use this flow if your HubSpot account uses permission sets — you'll update the set itself, and every user assigned to it inherits the access.

<Steps>
  <Step title="Sign in as a super admin">
    Log in to HubSpot as a super admin.
  </Step>

  <Step title="Open user settings">
    In the upper-right, click **Settings**, then go to **Users & Teams** in the left sidebar.
  </Step>

  <Step title="Open the Permission Sets tab">
    Click the **Permission Sets** tab and select the relevant permission set.
  </Step>

  <Step title="Open Settings Access">
    In the left sidebar, select **Settings Access** under **Account**.
  </Step>

  <Step title="Enable App Marketplace Access">
    Toggle **App Marketplace Access** on, then click **Save**.

    <Frame>
      <img alt="App Marketplace Access toggle enabled on the Settings Access page" />
    </Frame>
  </Step>
</Steps>

All users assigned to that permission set will now automatically have the access they need to connect HubSpot.


# Overview
Source: https://docs.weavable.ai/product/connections/overview

How OAuth connections work in Weavable, what's supported, and how permissions and sharing are handled

## How OAuth connections work

OAuth is a secure, industry-standard protocol that allows Weavable to securely connect with your other apps. When you connect Weavable to an app like Slack or Notion, all communication between Weavable and your connected apps happens over secure, encrypted connections to protect your privacy. Your actual login credentials are never shared with Weavable — instead, the OAuth token acts as a secure bridge that you can disconnect at any time.

## How permissions work

When you connect Weavable to another app, the access is limited to whatever permissions you already have in that app. For example, if you can only view certain Notion pages or Slack channels, you will only be able to access those same resources from Weavable. Weavable can't see or access anything that you couldn't access yourself. You can revoke access at any time, giving you and your team full control over your data.

## Sharing connections

While most users typically connect apps using their own OAuth credentials, some companies prefer having a single user (such as a shared or service account) make the connections and then share those connections with other team members on Weavable.

Weavable allows for this to happen securely. Once a user connects an application, they can click the share button in the connected app settings to share the connection with other users. These other users won't be able to modify the OAuth connection or data, but will be able to use it to create automations and summaries.

See [Sharing a connection](/product/connections/sharing) for step-by-step instructions.

## Admin approval by app

For most companies, connecting Weavable to apps like Notion or Slack is quick and seamless. Some organizations require admin approval before new integrations can be used — the table below summarizes the policy for the apps where this is most common. See [Adding a connection](/product/connections/adding) for the step-by-step flow.

| Application         | Approval required?                                                                                                            | Who can connect                                                                                                       | How to connect                                                                        | References                                                                                                                      |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Notion**          | **Enterprise:** admin approval may be required if enforced. **Individual:** any user can install.                             | **Enterprise:** anyone unless restricted by workspace admins. **Standard:** anyone with appropriate page permissions. | Connect from Weavable. If approval is required, admins will be notified by Notion.    | [Add & manage integrations](https://www.notion.com/help/add-and-manage-connections-with-the-api#enterprise-connection-settings) |
| **Slack**           | **Enterprise Grid:** admin approval required if enforced. **Standard:** workspace admins control app installation.            | Anyone (if permitted by admin settings).                                                                              | Connect from Weavable. If approval is required, admins will be notified by Slack.     | [Adding Slack apps](https://slack.com/intl/en-gb/help/categories/360000047926)                                                  |
| **Linear**          | **Enterprise:** admin approval typically required. **Team:** anyone.                                                          | Admin users.                                                                                                          | Connect from Weavable. If approval is required, admins will be notified by Linear.    | [Third-party apps](https://linear.app/docs/third-party-application-approvals)                                                   |
| **GitLab**          | **Ultimate:** admin approval may be required. **Other plans:** no approval required, but admins may disable third-party apps. | Anyone.                                                                                                               | Connect from Weavable.                                                                | [Integration allow list](https://docs.gitlab.com/administration/settings/project_integration_management/#integration-allowlist) |
| **Atlassian**       | Admins may disable third-party applications.                                                                                  | Anyone.                                                                                                               | Connect from Weavable. If approval is required, admins will be notified by Atlassian. | [Manage your apps](https://support.atlassian.com/confluence-cloud/docs/manage-your-apps/)                                       |
| **Figma**           | No restrictions.                                                                                                              | Anyone.                                                                                                               | Connect from Weavable.                                                                |                                                                                                                                 |
| **Microsoft Teams** | Approval from admin required.                                                                                                 | Admin users. Can be shared with team members — Weavable follows Teams' permission model.                              | Connect from Weavable.                                                                |                                                                                                                                 |

## All supported tools

* Asana
* Atlassian Jira
* Atlassian Confluence
* Azure DevOps
* Bitbucket
* ClickUp
* Email Inbox
* Figma
* Fireflies
* GitHub
* GitLab
* Gong
* Google Analytics
* Google Drive
* HubSpot
* Linear
* Microsoft Teams
* Miro
* Monday
* Notion
* Slack
* Toggl
* Trello
* Zendesk


# Removing a connection
Source: https://docs.weavable.ai/product/connections/removing

Disconnect a tool from Weavable and revoke its access

<Steps>
  <Step title="Open the connected app">
    From the **Apps** page, click on the connected app you want to disconnect under the **Connected By You** section.
  </Step>

  <Step title="Disconnect">
    Click the **Disconnect** button in the modal.
  </Step>
</Steps>

<Warning>
  All data related to that app will be deleted, including any references to it in your [contexts](/product/contexts).
</Warning>


# Sharing a connection
Source: https://docs.weavable.ai/product/connections/sharing

Share an OAuth connection so teammates can build contexts from data they can't access directly

Any user with admin or editor role can share their app connections with others in their organization. This lets teammates create contexts using data they wouldn't normally have access to.

## Why this matters

By default, when you connect an app to Weavable, it can only see what *you* have access to in that app. If you connect Jira and don't have access to a "Super Secret Board," Weavable can't see it either.

Shared connections let you make your access available to others — so teammates can build contexts from data they can't see in the app itself.

## What sharing does and doesn't do

When you share a connection, others can:

* Use it inside Weavable to create contexts
* Query those contexts from any MCP-connected AI assistant or agent

But they **cannot**:

* Access the app itself (Jira, ClickUp, Linear, etc.) outside Weavable
* Browse or interact with the app — they can only use it inside Weavable

Think of it as borrowing someone's access just to generate a summary — nothing more.

## How to share a connection

<Steps>
  <Step title="Open the Apps page">
    From the Weavable sidebar, go to **Apps**. You'll see all the apps you're connected to.
  </Step>

  <Step title="Select a connected app">
    Click into the app you want to share. You'll see options to **Share this connection** and to **Reconnect / Disconnect**.
  </Step>

  <Step title="Choose who to share with">
    * Keep it private to yourself
    * Share with **everyone** in your organization (e.g. everyone at `company.com`)
    * Share with **specific users** by entering their email addresses
  </Step>
</Steps>

## When a connection is shared with you

The app will appear under **Connected by others**, with the name of the person who shared it. You'll have access — within Weavable only — to all projects and workspaces visible through that connection.

When you create a context, the shared app and its projects, workspaces, or folders are available as a data source. You can preview the data, configure filters, prompts, and grouping just like with your own connection.

<Note>
  This does not give you access to the app itself — only visibility through Weavable for the purpose of creating contexts.
</Note>

## Who this is for

* Product or sales ops creating summaries across multiple teams
* Operations or business leads coordinating cross-functional work
* Anyone who needs visibility without requesting direct access to the source tool


# Contexts
Source: https://docs.weavable.ai/product/contexts

Create a focused slice of your work data that AI can reason from

Contexts are how Weavable knows what data to reason from — a focused slice of your work data that you query from your AI stack. Different jobs need different data, so you build a context per job: one for renewals, one for support themes, one for engineering activity.

## Create a context

Just describe what you need, the same way you'd prompt any AI. For example:

> *Monitor deal pipeline progress and customer engagement activities using HubSpot and Zendesk support tickets.*

Weavable detects the relevant data sources from your connected apps and walks you through three steps:

<Steps>
  <Step title="Open the context creation page">
    Go to the [context creation page](https://weavable.thatworks.ai/0/context/new).
  </Step>

  <Step title="Describe what you want to create">
    On the **What do you want to create?** screen, type a natural-language description of the context.

    Prefer this to **Or create manually** unless you already know exactly which data sources you want.
  </Step>

  <Step title="Confirm the apps">
    Weavable suggests apps based on your description. Confirm them as-is, swap them out, or pick from the full list.
  </Step>

  <Step title="Confirm the data sources">
    Within each app, Weavable may pre-select specific data sources from your description. Confirm them as-is, swap them out, or pick your own — for example, a particular project, board, channel, repository, or pipeline.

    <Tip>
      Always point to data you actually care about, not everything you have access to. Narrower contexts give faster, more accurate answers.
    </Tip>
  </Step>
</Steps>

Your context is now ready. Primary data sources are set, and Weavable has prefilled instructions for how to use the data.

## Edit a context

Open the context to change its name, instructions, or data sources. Each context has two kinds of data sources:

* **Primary data sources** — the main signal the context is built around. These drive what's in scope when the context is queried.
* **Enrichment data sources** — additional context that gets pulled in to make answers richer (people, related items, etc.).

## Test a context

Use **Open Test Playground** to preview what the context can already answer. It's a good proxy for the kind of depth and detail you'll get when you query the context through your AI stack via [MCP](/mcp/overview).

## Share a context

Share a context with teammates already on Weavable so they get access to the same focused slice of data — without having to connect apps or build their own context.

From the context, open **Share This Context** and choose:

* **Selected people in your organization** — share with specific teammates by email
* **Share with everyone in your organization** — share with everyone on your Weavable workspace

Think of it as giving the right people exactly what they need, without exposing anything they shouldn't see.

<Note>
  Sharing a context is different from [sharing a connection](/product/connections/sharing). A shared context lets others query the same scoped data; a shared connection lets others build their *own* contexts on top of your OAuth credentials.
</Note>

## Connect to your AI

When you're ready, hit **Connect MCP** on the context to get your endpoint and per-client setup instructions for [Claude, Claude Code, ChatGPT, VS Code, and other clients](/mcp/connect).


# Quickstart
Source: https://docs.weavable.ai/quickstart

From zero to your first context plugged into AI in a few minutes

## Sign up

Create an account [here](https://weavable.thatworks.ai/auth/signup).

## Connect your first tool

<iframe title="Connect your first tool" />

## Create a context

<iframe title="Create a context" />

## Connect MCP and share

<iframe title="Connect MCP and share" />