OpenTool

One MCP server. All your tools. Fully open-source and self-hosted.

OpenTool gives AI agents secure, authenticated access to your tools via a single MCP connection. Connect GitHub, Notion, Slack, and more — then point any MCP-compatible agent at OpenTool with one API key.

Built for solo developers building with AI agents.

Why OpenTool

Install

CLI

# npm (recommended)
npm i -g opentool-cli

# or run without installing
npx opentool-cli

# or curl installer
curl -fsSL https://raw.githubusercontent.com/Aditya251610/opentool/main/install.sh | bash

SDKs

# TypeScript
npm i @opentool-ts/sdk

# Python
pip install opentool-sdk

Quickstart (Hosted)

1. Get your API key Sign up at opentool.space → Settings → Generate API key

2. Connect your tools Go to the dashboard → Tools → Connect GitHub, Notion, Slack etc.

3. Connect your agent

For VS Code / Copilot / Claude Code, add to mcp.json:

{
  "servers": {
    "opentool": {
      "type": "http",
      "url": "https://opentool.onrender.com/mcp",
      "headers": {
        "Authorization": "Bearer <TOKEN>"
      }
    }
  }
}

Or use the CLI:

opentool init       # guided setup
opentool login      # authenticate
opentool tools      # see your connected tools
opentool            # launch interactive REPL

That's it. Your agent now has access to all your connected tools.

Self-Hosting

Prerequisites: Docker + Docker Compose

git clone https://github.com/Aditya251610/opentool
cd opentool
cp .env.example .env
# Fill in your OAuth app credentials in .env
docker-compose up -d

Dashboard available at http://localhost:3000 MCP server available at http://localhost:3001

Production Deployment

• Self-Hosting Guide — Docker Compose, manual setup, reverse proxy, health checks, backups

• Security Guide — Encryption, authentication, threat model, data handling

Key production checklist:

• Use HTTPS with valid SSL certificates

• Set a strong TOKEN_ENCRYPTION_KEY (64 hex characters)

• Configure SERVER_URL and DASHBOARD_URL for your domain

• Back up your encryption key separately from database backups

• CSP and HSTS headers are enabled by default

Supported Tools

26 providers, 133 tools — and growing.

Developer & DevOps

Cloud Platforms

Productivity & Communication

Messaging & Notifications

Payments & Data

Want a tool added? Open an issue or contribute a tool.

CLI

The CLI ships with an interactive REPL and scriptable subcommands:

opentool                    # Launch interactive REPL
opentool tools --json       # List tools (machine-readable)
opentool exec github.list_issues --args '{"owner":"me","repo":"myrepo"}'
opentool doctor             # Run 9-point diagnostics
opentool completion --install  # Shell completions (bash/zsh/fish)

REPL features: Tab completion, ghost-text suggestions, Ctrl+R history search, fuzzy "did you mean?", readline keybindings, update notifications.

Full reference: docs/cli-reference.md

Project Structure

opentool/
├── apps/
│   ├── server/          # MCP server + Auth broker + REST API (Hono)
│   │   └── tools/       # Tool definitions (26 providers, 133 tools)
│   └── dashboard/       # Next.js dashboard
├── packages/
│   ├── cli/             # opentool-cli — interactive CLI + REPL
│   ├── sdk/ts/          # @opentool-ts/sdk — TypeScript SDK
│   ├── sdk/python/      # opentool — Python SDK
│   └── tool-schema/     # Shared tool definition types
├── install.sh           # curl | sh installer
└── docker-compose.yml

Contributing a Tool

Tools are self-contained modules in apps/server/tools/. Each tool exports:

import { defineTool } from '@opentool/tool-schema'

export const myTool = defineTool({
  id: 'my-tool.action',
  name: 'My Tool Action',
  description: 'What this tool does',
  authType: 'oauth2',
  inputSchema: z.object({
    param: z.string().describe('What this param does'),
  }),
  execute: async ({ input, auth }) => {
    // auth.accessToken available here
    // return result
  },
})

1. Fork the repo

2. Add your tool in apps/server/tools/yourprovider/

3. Register it in apps/server/src/registry/index.ts

4. Add OAuth config in .env.example

5. Open a PR

Full guide: docs/contributing-a-tool.md

Tech Stack

• Server — Hono, TypeScript, Prisma, Postgres, Redis

• Dashboard — Next.js 14, Auth.js

• CLI — TypeScript, Ink (React for terminals), Commander

• Protocol — MCP (Model Context Protocol) TypeScript SDK + gRPC (Protocol Buffers)

• SDKs — TypeScript (npm) + Python (PyPI)

• Monorepo — Turborepo + pnpm

• Security — AES-256-GCM encryption, CSP/HSTS headers, session obfuscation

Documentation

Full docs at docs/:

• Quickstart — Zero to connected tools in 5 minutes

• Self-Hosting — Docker or manual setup

• Configuration — Every env var and OAuth setup

• Architecture — How it all fits together

• Authentication — OAuth flows and token management

• Tools — All 26 providers, 133 tools

• MCP Integration — Claude, Cursor, any MCP client

• SDK Reference — TypeScript and Python

• CLI Reference — Terminal tool management

• API Reference — Every REST endpoint

• Contributing a Tool — Add a provider in ~100 lines

• Security — Encryption, tokens, threat model

• Troubleshooting — Common issues and fixes

• gRPC Transport — High-performance binary transport with streaming

Roadmap

• Core MCP server with 26 providers, 133 tools

• OAuth auth broker with token encryption

• Dashboard (Next.js)

• CLI with interactive REPL (opentool-cli on npm)

• TypeScript SDK (@opentool-ts/sdk on npm)

• Python SDK (opentool-sdk on PyPI)

• Production hardening (CSP, HSTS, retry logic, 211 tests)

• CI/CD with automated releases (release-please + tag-based publishing)

• curl installer (install.sh)

• gRPC transport (streaming execution, batch tools, mTLS, Kubernetes-native)

• Cloud providers (AWS, GCP, Azure)

• Microsoft 365 integration (Outlook, Calendar, Teams)

• Atlassian suite (Jira, Confluence)

• Messaging providers (Telegram, Discord, Twilio)

• PayPal payments integration

• Token analytics and usage tracking

• Team/org support (RBAC, invites, SSO, org-scoped keys and connections)

• Tool marketplace

• Webhook support

• Plugin system for custom tools

License

MIT — use it, fork it, self-host it, build on it.