Github Linear

CI failures, PRs and security alerts become Linear issues and Slack posts, evidence attached.

An MCP server with 25 workflows across GitHub, Linear, Slack, Notion, Google Docs, Google Calendar, Firecrawl, Google Sheets and Tavily. Each workflow is a prompt your agent runs as a slash command, over the 59 tools it needs and no others.

uv tool install https://github.com/r28ai/github-linear-mcp/releases/download/v0.1.0/github_linear_mcp-0.1.0-py3-none-any.whl
claude mcp add dev -- github-linear-mcp

It installs with uv from this repository's release, with no git and nothing to build; nothing but Charter and the libraries it uses comes from PyPI. To update, run the install line from the latest release. If a desktop app cannot find github-linear-mcp, give it the full path from which github-linear-mcp (where github-linear-mcp on Windows).

Then ask your agent to connect your apps, or run /mcp__dev__setup.

Connect your apps

Ask the agent to connect one ("connect Linear"). It tells you where to get that app's key and the command that stores it, and the next call works, with no restart. The agent never asks for a key in the chat.

Or connect everything this server uses from a terminal:

github-linear-mcp login            # each app in turn
github-linear-mcp login github     # just one
github-linear-mcp status           # what is connected

Tokens and keys go to your operating system's keychain (macOS Keychain, Windows Credential Manager, the Secret Service on Linux), and are checked with one read-only call to the app's own API before they are kept. Every key, token and OAuth client is yours: we register no app with any of these services, and nothing passes through a server of ours, because there isn't one.

App	How it connects	Or set
GitHub	Your own key (get one), entered once.	GITHUB_TOKEN
Linear	Your own key (get one), entered once.	LINEAR_API_KEY
Slack	Your own key (get one), entered once. A bot token from your own Slack app, which the guide sets up in about three minutes.	SLACK_BOT_TOKEN
Notion	Your own key (get one), entered once. Then share the pages it should see with the integration.	NOTION_API_KEY
Google	Browser sign-in, over your own OAuth client (make one).	GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET
Firecrawl	Your own key (get one), entered once.	FIRECRAWL_API_KEY
Tavily	Your own key (get one), entered once.	TAVILY_API_KEY

A variable set in your client's config always wins over the keychain.

Workflows

Workflow	What you get	Apps
Failing CI → bug with the log excerpt failing_ci_to_bug_with_the_log_excerpt	A red main branch becomes an owned issue with the failing step quoted, not a channel ping.	GitHub, Linear, Slack
Link every PR to its Linear issue link_every_pr_to_its_linear_issue	No orphan PRs, so cycle reports and changelogs stop missing work.	GitHub, Linear
Security alerts → Linear security_alerts_to_linear	Critical alerts get owners and due dates in the tracker the team actually reads.	GitHub, Linear
Leaked secret → page a human leaked_secret_to_page_a_human	An exposed key is an urgent issue and a loud message within minutes.	GitHub, Linear, Slack
Release → changelog page and announcement release_to_changelog_page_and_announcement	Every release has a readable changelog without a release manager writing it.	GitHub, Notion, Slack
Standup digest per person standup_digest_per_person	Yesterday's PRs and today's issues in a DM, so standup is about blockers.	GitHub, Linear, Slack
Stale review nudger stale_review_nudger	PRs waiting more than a day get a polite DM to the right reviewer.	GitHub, Slack
Linear issue → branch and draft PR linear_issue_to_branch_and_draft_pr	Starting work on an issue sets up the branch, the PR and the link.	Linear, GitHub
Incident timeline → postmortem draft incident_timeline_to_postmortem_draft	The timeline is assembled from what happened, and action items are tracked from minute one.	Slack, GitHub, Google Docs, Linear
Postmortem actions tracked to done postmortem_actions_tracked_to_done	Follow-ups from the postmortem become linked issues with a review date.	Google Docs, Linear, Google Calendar
Slack bug report → Linear slack_bug_report_to_linear	The thread becomes an issue with repro steps, and the thread gets the link.	Slack, Linear
GitHub issues mirrored into Linear github_issues_mirrored_into_linear	Open-source reports enter the internal tracker without double triage.	GitHub, Linear
Vendor deprecation → affected files vendor_deprecation_to_affected_files	A deprecation notice arrives already mapped to the code that uses the old API.	Firecrawl, GitHub, Linear
On-call handoff on_call_handoff	The next on-call starts with open urgents and unread alerts in one message.	Google Calendar, Linear, GitHub, Slack
Deploy approval from Slack deploy_approval_from_slack	Production deploys gated on an explicit 'approve' in a thread, with the reviewer on record.	GitHub, Slack
Flaky test ledger flaky_test_ledger	Tests that fail and pass on retry get counted until one crosses the line and gets an issue.	GitHub, Google Sheets, Linear
CI spend report ci_spend_report	Which workflows burn the minutes, weekly, before the bill does it.	GitHub, Google Sheets, Slack
PR → design note in Docs pr_to_design_note_in_docs	A large PR gets a readable explanation for reviewers outside the team.	GitHub, Google Docs
Dependency choice with real repo health dependency_choice_with_real_repo_health	Library choices recorded with stars, activity and bus factor, not vibes.	Tavily, GitHub, Notion
Slack debate → ADR in the repo slack_debate_to_adr_in_the_repo	The decision and its reasons get committed next to the code they govern.	Slack, GitHub, Linear
Repo onboarding doc repo_onboarding_doc	A new engineer gets a map of an unfamiliar repo and who to ask.	GitHub, Google Docs
Stale PR cleanup stale_pr_cleanup	Month-old PRs are closed with a note and the author is told, so the queue means something.	GitHub, Slack
TODO/FIXME debt register todo_fixme_debt_register	Debt hiding in comments becomes a list someone can prioritise.	GitHub, Linear, Google Sheets
Repo docs → engineering wiki repo_docs_to_engineering_wiki	The wiki mirrors docs/ in the repo instead of drifting from it.	GitHub, Notion, Slack
Release credits for contributors release_credits_for_contributors	Every release thanks the people who made it, by name.	GitHub, Slack

Every prompt takes one optional argument, details: the repo, team, channel, customer or date range you mean, so the agent does not have to ask. In Claude Code, put it in quotes, or only its first word arrives:

/mcp__dev__failing_ci_to_bug_with_the_log_excerpt "repo acme/api, Linear team ENG, post in #eng-alerts"

Reads run without asking. Before anything that creates, sends, changes or deletes, the prompt tells the agent to show you the call and wait.

17 of the 25 workflows need no Google or Granola credential.

Other clients

Claude Desktop: install uv if you have not, since Claude Desktop starts the server with it, then open the .mcpb from the latest release. Claude asks for any keys in its own settings and keeps them in your keychain. The first start takes a few seconds longer, while uv installs it.

VS Code (.vscode/mcp.json): VS Code asks for each key the first time the server starts and stores it securely. Leave out any you stored with login.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "github-token",
      "description": "GitHub: Personal access token",
      "password": true
    },
    {
      "type": "promptString",
      "id": "linear-api-key",
      "description": "Linear: Personal API key",
      "password": true
    },
    {
      "type": "promptString",
      "id": "slack-bot-token",
      "description": "Slack: Bot token (xoxb-\u2026)",
      "password": true
    },
    {
      "type": "promptString",
      "id": "notion-api-key",
      "description": "Notion: Integration secret (ntn_\u2026)",
      "password": true
    },
    {
      "type": "promptString",
      "id": "google-client-secret",
      "description": "Google: OAuth client secret",
      "password": true
    },
    {
      "type": "promptString",
      "id": "firecrawl-api-key",
      "description": "Firecrawl: API key",
      "password": true
    },
    {
      "type": "promptString",
      "id": "tavily-api-key",
      "description": "Tavily: API key",
      "password": true
    }
  ],
  "servers": {
    "dev": {
      "type": "stdio",
      "command": "github-linear-mcp",
      "env": {
        "GITHUB_TOKEN": "${input:github-token}",
        "LINEAR_API_KEY": "${input:linear-api-key}",
        "SLACK_BOT_TOKEN": "${input:slack-bot-token}",
        "NOTION_API_KEY": "${input:notion-api-key}",
        "GOOGLE_CLIENT_SECRET": "${input:google-client-secret}",
        "FIRECRAWL_API_KEY": "${input:firecrawl-api-key}",
        "TAVILY_API_KEY": "${input:tavily-api-key}",
        "GOOGLE_CLIENT_ID": ""
      }
    }
  }
}

Cursor (.cursor/mcp.json) starts it the same way:

{
  "mcpServers": {
    "dev": {
      "command": "github-linear-mcp"
    }
  }
}

Codex (~/.codex/config.toml) starts a turn without waiting for a server unless it is required, and then the agent has none of its tools. required = true makes the session wait for it, and startup_readiness = "catalog" waits for its tool list rather than just its connection:

[mcp_servers.dev]
command = "github-linear-mcp"
required = true
startup_readiness = "catalog"
startup_timeout_sec = 30

Name the server dev. A host builds each tool's name from that key, and a longer one can push a tool past the 64 characters a function name allows.

Built with Charter

Every tool here is a Charter declaration: a Pydantic schema saying where each field goes on the wire. Charter's runtime builds the request, attaches and refreshes the credential, and trims the response before the model reads it. It runs in your process, with no proxy and no telemetry.

The 59 tool schemas come to 57,249 tokens.

The same tools work in your own agent, without MCP:

from charter.adapters.openai import to_openai_tools
from charter_packs_mcp import FAMILIES

tools = FAMILIES["engineering"].tools()
definitions = to_openai_tools(tools)   # or charter.adapters.langchain

Need an API that isn't here? Write a pack: your coding agent writes the declarations, and Charter's conformance suite checks them.

All 59 tools

• GitHub: github_actions_list_workflow_runs, github_actions_list_jobs_for_run, github_actions_download_job_logs, github_pulls_list, github_dependabot_list_alerts, github_code_scanning_list_alerts, github_secret_scanning_list_alerts, github_releases_get_latest, github_repos_compare_commits, github_search_issues, github_pulls_list_requested_reviewers, github_git_refs_get, github_git_refs_create, github_pulls_create, github_repos_list_commits, github_issues_list_for_repo, github_issues_create_comment, github_search_code, github_notifications_list, github_actions_list_pending_deployments, github_actions_review_pending_deployments, github_actions_list_runs_for_workflow, github_checks_list_annotations, github_actions_get_run_usage, github_pulls_get, github_pulls_list_files, github_pulls_get_diff, github_search_repositories, github_repos_get, github_repos_list_contributors, github_repos_create_or_update_file, github_repos_get_readme, github_repos_list_languages, github_pulls_update, github_repos_get_content, github_releases_update
• Linear: linear_issue_create, linear_attachments_for_url, linear_search_issues, linear_attachment_create, linear_issues_list, linear_issue_get, linear_issue_relation_create
• Slack: slack_chat_post_message, slack_conversations_open, slack_users_list, slack_conversations_history, slack_conversations_replies
• Notion: notion_pages_create, notion_pages_update_markdown
• Google Docs: gdocs_documents_create, gdocs_documents_get
• Google Calendar: gcalendar_events_insert, gcalendar_events_list
• Firecrawl: firecrawl_monitor_create, firecrawl_monitor_checks_list
• Google Sheets: gsheets_spreadsheets_values_append, gsheets_spreadsheets_values_update
• Tavily: tavily_search

License

Apache 2.0.