Overview

Rube is an MCP (Model Context Protocol) server that connects AI clients to 500+ apps and services through a unified tool API. Install the server alongside your AI client, authenticate it once with the services you need (Gmail, Slack, Asana, Google Sheets, etc.), and then let your model call simple, typed tools to send email, create tasks, post messages, add spreadsheet rows, and more. Rube implements the MCP tool discovery and invocation patterns so large language models can operate on real-world apps safely and predictably.

For developers, Rube reduces integration overhead: you configure provider credentials centrally, expose a single MCP-compatible endpoint to your model, and rely on Rube to handle OAuth flows, token refresh, connector-specific APIs, and result normalization. This is useful when you want to empower agents or assistant workflows with action capabilities across many platforms without wiring each integration individually into the model client.

Features

MCP-compliant tool discovery and invocation API
Pre-built connectors to 500+ apps (Gmail, Outlook, Slack, Asana, Trello, Google Sheets, Notion, Airtable, Zapier/Make, etc.)
Centralized OAuth handling and refresh token management
JSON-schema typed tools for safe model calls
Dockerized deployment and simple environment-based configuration
Audit logging and optional persistence for tool runs
Lightweight: designed to run alongside desktop, server-side, or embedded AI clients
Extensible provider framework for adding custom connectors

Installation / Configuration

Prerequisites: Node 18+ (or use Docker). Clone the repo, create an .env and start.

Clone and run locally:

git clone https://github.com/ComposioHQ/Rube.git
cd Rube
cp .env.example .env
# Edit .env with your credentials (see below)
npm install
npm run build
npm start

Environment variables (example):

PORT=3000
DATABASE_URL=postgresql://user:pass@localhost:5432/rube
JWT_SECRET=replace-with-secure-secret
BASE_URL=https://rube.example.com
PROVIDERS_CONFIG=./providers.json
LOG_LEVEL=info

Docker quickstart:

docker build -t rube .
docker run -p 3000:3000 \
  -e PORT=3000 \
  -e JWT_SECRET="supersecret" \
  -e BASE_URL="http://localhost:3000" \
  rube

Docker Compose (minimal):

version: "3.8"
services:
  rube:
    image: composio/rube:latest
    ports:
      - "3000:3000"
    env_file:
      - .env
    volumes:
      - ./providers.json:/app/providers.json

Configuring providers (providers.json)

[
  {
    "id": "gmail",
    "clientId": "GMAIL_CLIENT_ID",
    "clientSecret": "GMAIL_CLIENT_SECRET",
    "scopes": ["https://www.googleapis.com/auth/gmail.send"]
  },
  {
    "id": "slack",
    "clientId": "SLACK_CLIENT_ID",
    "clientSecret": "SLACK_CLIENT_SECRET",
    "scopes": ["chat:write", "channels:read"]
  }
]

Register the server with your AI client by pointing the client’s MCP base URL to Rube’s /mcp endpoint and providing your API key (JWT or static key depending on your deployment).

Available Tools / Resources

Rube exposes a catalog of typed tools. Examples include:

Tool ID	Description	Typical Connectors
send_email	Send an email with attachments and templating	Gmail, Outlook
create_task	Create a task in project management apps	Asana, Trello, ClickUp
append_row	Append a row to a spreadsheet	Google Sheets, Airtable
post_message	Post a message to a channel/user	Slack, Microsoft Teams
create_event	Create a calendar event	Google Calendar, Outlook Calendar
search_files	Search files across connected drives	Google Drive, OneDrive
zapier_trigger	Trigger a Zapier or Make webhook	Zapier, Make

You can view the full tool schema and discovery endpoint at:

GET /mcp/tools — returns JSON tool catalog
POST /mcp/run — invoke a tool (request includes tool id + input schema)

Server repository and docs:

https://github.com/ComposioHQ/Rube

Use Cases

Send a follow-up email after a meeting
- Model generates an intent to “send follow-up email to attendees”.
- Agent calls Rube’s send_email tool with subject/body/recipients.
- Rube uses the configured Gmail connector and returns message id and status.
Example invocation (curl):
```
curl -X POST https://rube.example.com/mcp/run \
  -H "Authorization: Bearer $RUBE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tool":"send_email","input":{"to":["[email protected]"],"subject":"Follow-up","body":"Thanks for meeting..."} }'
```
Create a task from chat
- User asks the assistant to “create a task to fix the bug in Asana”.
- Model calls create_task with task title, description, project id.
- Rube maps that to Asana’s API and returns task URL.
Append meeting notes to a spreadsheet
- After summarizing notes, the agent posts a row with timestamp, summary, and attendees to Google Sheets via append_row.
Cross-app workflows
- Trigger a Slack message, create a task, and log an audit row in a spreadsheet in one composite run. Rube supports sequential tool invocations and returns structured outputs for each step.

Security & Best Practices

Keep JWT_SECRET and provider client secrets out of source control.
Limit provider scopes to the minimum required for each tool.
Use server-side persistence for refresh tokens and implement role-based access if multiple users share a Rube instance.
Audit tool invocations and sanitize inputs where appropriate before passing to external APIs.

For full API reference and contribution guidelines, see the GitHub repository: https://github.com/ComposioHQ/Rube.

Rube MCP Server: Connect AI With 500+ Apps