integrations
/integrations
Discover and call the tools a connected integration exposes, such as Linear, GitHub, Sentry, or Notion, through `superset mcp` (or its alias `paradev mcp`). Use when the user wants something done in a connected service, asks what an integration can do or which tools it has, wants a specific tool called, asks why an integration's tools are failing, or when another skill expects `mcp__linear__*`-style tools that are not in your tool list.
- Author
- superset-sh ↗
- Repository
- superset ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Discover and call the tools a connected integration exposes, such as Linear, GitHub, Sentry, or Notion, through `superset mcp` (or its alias `paradev mcp`). Use when the user wants something done in a connected service, asks what an integration can do or which tools it has, wants a specific tool called, asks why an integration's tools are failing, or when another skill expects `mcp__linear__*`-style tools that are not in your tool list.
Arguments
/integrations what you want done in a connected service
Original author description
Discover and call the tools a connected integration exposes, such as Linear, GitHub, Sentry, or Notion, through `superset mcp` (or its alias `paradev mcp`). Use when the user wants something done in a connected service, asks what an integration can do or which tools it has, wants a specific tool called, asks why an integration's tools are failing, or when another skill expects `mcp__linear__*`-style tools that are not in your tool list.
How it works
- 1. Find the integration
- 2. List the tools before calling one
- 3. Call it
- When another skill expects tools you do not have
- Reading a failure
- Anti-patterns
SKILL.md preview
---
name: integrations
description: Discover and call the tools a connected integration exposes, such as Linear, GitHub, Sentry, or Notion, through `superset mcp` (or its alias `paradev mcp`). Use when the user wants something done in a connected service, asks what an integration can do or which tools it has, wants a specific tool called, asks why an integration's tools are failing, or when another skill expects `mcp__linear__*`-style tools that are not in your tool list.
argument-hint: what you want done in a connected service
allowed-tools: Bash(superset mcp:*) Bash(paradev mcp:*) Bash(superset plugins:*) Bash(paradev plugins:*) Bash(superset skills:*) Bash(paradev skills:*)
---
# Calling an integration's tools
`paradev` is an alias for the `superset` CLI: every `superset` command here also runs as `paradev`.
An integration is an installed plugin with a connected account. Its tools do not run here.
`superset mcp` hands the call to Paradev's API, which attaches the stored credential and
forwards it to the plugin's MCP server. No token is ever written to this machine, which is
also why a sandbox with no route to Linear can still file a Linear issue.
Installing, connecting, and marketplaces belong to the `plugins` skill. This one starts once
something is connected, and it is two steps: list the tools, then call one.
## 1. Find the integration
```bash
superset plugins list # one row per connected account, one row if none yet
```
Read the `STATUS` column. `connected: <account>` is callable. `needs connection` means the
skills are installed but no account is authorized, so its tools will fail until someone
connects one; that is a connect step, not a bug. `not installed` is a connection whose plugin
is gone: the credential is still live, and the `PLUGIN` column holds the connector it belongs
to. `CONNECTION` holds the connection id, empty on a row with no connection yet. A plugin with
two connected accounts has two rows.
## 2. List the tools before calling one
```bash
superset mcp tools --plugin linear
superset mcp tools --plugin linear | jq -r '.[].tool' # names only; descriptions run long
```
Names and descriptions come from the plugin's own server, not from anything in this repo, and
they change between plugin versions. Never call a tool you have not listed.
The listing gives a name and a description, but **no input schema**. The description is where
the plugin documents its arguments, so read the full description of the tool you are about to
call rather than the filtered name list. If the shape is still ambiguous, a wrong call comes
back as a tool error naming the offending field; correct it from there.
## 3. Call it
```bash
superset mcp call-tool list_issues --plugin linear
superset mcp call-tool create_issue --plugin linear '{"team":"ENG","title":"Export 500s"}'
echo '{"team":"ENG","title":"..."}' | superset mcp call-tool create_issue --plugin linear -
```
The tool name is the first positional and the plugin travels in `--plugin`, always. Arguments
are the second positional, default `{}`, and `-` reads them from stdin. Use stdin for anything
secret, since an argument is visible in `ps` and in shell history.
What comes back is the MCP result verbatim: a `content` array whose text parts are usually
themselves JSON strings.
```bash
superset mcp call-tool list_issues --plugin linear | jq -r '.content[0].text' | jq
```
## When another skill expects tools you do not have
A plugin ships its own skills, and they are written against native MCP tools: the Linear,
GitHub, and Sentry skills declare `allowed-tools: mcp__linear__*` and reach for tools by that
name. Those tools exist only where the plugin's MCP server was written into this agent's
config, which installing through the CLI does not do, and which today happens for Claude Code
and Codex only. On every other agent the tool list will not have them.
That is this skill's job. When the tools a plugin's skill assumes are missing, do not stop and
do not tell the user the integration is unavailable. The same operations sit on the connected
account, one command away:
```bash
superset mcp tools --plugin linear # what the account can actually do
superset mcp call-tool create_issue --plugin linear '{"team":"ENG","title":"..."}'
```
Keep following the skill you were reading, since its judgment about what makes a good issue or
a good triage still applies. Only the transport changes.
## Reading a failure
| What you see | What it means |
| --- | --- |
| `"x" is not connected. Connect an account first.` | Nothing is authorized under that name. Also what an uninstalled plugin looks like. Run `superset plugins connect x`, or install it first. |
| `--connection takes a plugin name now, not a connection id.` | You passed a UUID. The handle is the plugin name: `--plugin <name>`. |
| `Pass --plugin <name>.` | `superset mcp tools` with no target. |
| `Missing required argument: <tool>` | `call-tool` takes the tool name first; the plugin goes in `--plugin`. |
| `Arguments must be JSON: ...` | The second positional is a JSON object, quoted as one shell word. Passing the plugin as a positional lands here. |
| 401 or 403 from the tool itself | Read the error before acting. Reconnect only when it names an invalid, revoked, or expired credential. A 403 that names a scope, a permission, or a resource means the connected account lacks that access, and reconnecting the same account changes nothing. |
| `needs connection` in `plugins list` | Installed, unauthorized. Nothing you pass to `mcp` fixes this. |
## Anti-patterns
- Calling a tool without listing tools first. You are guessing at a name and a schema the
plugin owns.
- `--connection` or `--plugin-id`. Deprecated aliases for `--plugin`, and both reject a UUID.
- Passing a credential as a command argument when the command reads stdin.
- Picking one of several connected accounts yourself. Which account acts is the user's call.
- Reconnecting on any 403. Half of them are a permissions problem on the account you already
have.
- Reaching for `superset plugins sync` when a call fails on authorization. Sync converges
skills on this machine; it has nothing to do with credentials.
- Installing or connecting a plugin to see what it offers. That writes to the user's account
and reaches every machine they sign in on, so ask first and use the `plugins` skill.
Files in this package (2)
- SKILL.md 6 KB
- agents/openai.yaml 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · superset-sh/superset | 100 | MIT |
| automattic/wordpress-activitypub | 100 | MIT |
| wasintoh/toh-framework | 100 | MIT |
Database snapshot: 13.11.2026 · package version befd20536b40 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100plugins
Install Paradev (formerly Superset) plugins, connect the accounts they need, and call their MCP tools through the credential proxy. Use when the user wants a plugin installed, removed, enabled, or connected, asks what tools a plugin exposes, wants to call one, adds a… - 100mcp-servers
Install, configure, authenticate, and troubleshoot MCP (Model Context Protocol) servers for this agent. Use when the user asks to add/install/remove an MCP server, connect a tool like Linear/Sentry/Supabase/GitHub via MCP, set up mcp.json, or when MCP tools are failing or need OAuth login. - 100papi-integration-recipe
Use when the user wants to feed data from a connected MCP tool (Sentry, Linear, GitHub, Slack, or any other) into PAPI. Demonstrates the "host agent = integration bus" pattern: read from the external tool, map to PAPI shape, write via PAPI tool. PAPI never owns connectors — the… - 100dev-tool-integrations
Connects a startup's dev tools: GitHub and Vercel notifications into Slack, Linear issues linked to branches and PRs, Sentry alerts into Slack, with step-by-step setup and a connectivity map. Use when the user asks to connect GitHub, Slack, Linear, Jira, Sentry or Vercel, set up… - 90vc:mcp-management
Manage MCP servers - discover, analyze, execute tools/prompts/resources. Use for MCP integrations, intelligent tool selection, multi-server management, context-efficient capability discovery. - 100working-with-mcp
Use when user mentions MCPProxy/MCP tools (e.g., "check buildkite mcp", "use slack mcp") or when you need to discover or call tools through MCPProxy - immediately checks if mcp__MCPProxy__* tools are available, suggests /mcp reconnect if missing (MCPProxy MCP server not…