# Rowboat MCP Tool Integrations: Connecting Slack, Linear, and GitHub

> Explore Rowboat MCP tool integrations and learn how it connects Slack, Linear, and GitHub. Discover the power of Composio-hosted connectors for seamless external service access.

- Repository: [RowBoat Labs/rowboat](https://github.com/rowboatlabs/rowboat)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Rowboat's MCP (Modular Connectors Platform) layer exposes external SaaS services as callable tools through a centralized runtime that proxies requests to Composio-hosted connectors.**

Rowboat MCP tool integrations enable agents to interact with external services like Slack, Linear, and GitHub through a unified interface. This article examines how the MCP layer in the `rowboatlabs/rowboat` repository transforms these third-party APIs into first-class tools that agents can invoke programmatically.

## Understanding the MCP Architecture

### Server Configuration and Types

The foundation of Rowboat's MCP tool integrations begins with type definitions in **[`apps/x/packages/shared/src/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/shared/src/mcp.ts)**. Here, the `McpServerDefinition` Zod schema defines the structure for remote MCP server connections:

```typescript
// apps/x/packages/shared/src/mcp.ts
export const McpServerDefinition = z.object({
  url: z.string().url(),
  apiKey: z.string().optional(),
  // …
});

```

User-specific configurations persist in [`config/mcp.json`](https://github.com/rowboatlabs/rowboat/blob/main/config/mcp.json) and load through **[`apps/x/packages/core/src/mcp/repo.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/repo.ts)**. This repository pattern separates configuration management from runtime execution, allowing dynamic server registration without code changes.

### Core Runtime Functions

The MCP runtime implementation resides in **[`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts)**. This module provides three essential functions that power all Rowboat MCP tool integrations:

- **`listServers()`** – Returns the map of configured servers from the repository
- **`listTools(serverName)`** – Queries the remote MCP endpoint for available tool slugs on a specific server
- **`executeTool(serverName, toolSlug, input)`** – Forwards JSON payloads to the remote MCP endpoint and normalizes error responses

The remote MCP endpoint typically points to Composio-hosted services (e.g., `https://mcp.exa.ai/mcp`) that proxy requests to individual SaaS APIs like Slack, Linear, or GitHub.

## Connecting to External Services

### Slack Integration

Rowboat's Slack integration leverages the builtin-tools library in **[`apps/x/packages/core/src/application/lib/builtin-tools.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/lib/builtin-tools.ts)**. This file defines `slackToolHints` that map human-readable actions to Composio tool slugs, along with helper functions like `executeSlackTool`:

```typescript
// apps/x/packages/core/src/application/lib/builtin-tools.ts
type SlackToolHint = { patterns: string[] };
const slackToolHints: Record<string, SlackToolHint> = { … };

async function executeSlackTool(hintKey: keyof typeof slackToolHints, input: any) {
  if (!isSlackConnected) return { success: false, error: 'Slack is not connected' };
  const toolSlug = await resolveSlackToolSlug(hintKey);
  return await executeTool(currentMcpServer, toolSlug, input);
}

```

The specific tool catalog resides in **[`apps/x/packages/core/src/application/assistant/skills/slack/tool-catalog.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/slack/tool-catalog.ts)**, mapping actions like `sendMessage` to Composio slugs such as `SLACK_SEND_MESSAGE`.

### Linear Integration

Linear follows an identical architectural pattern to Slack. The MCP-integration skill exposes Linear operations through **[`apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts)**, which registers tools like `createIssue` and `listProjects`. 

When an agent invokes a Linear tool, the skill calls `executeTool` with the Linear server configuration, forwarding the request to Composio's Linear connector. Authentication occurs through API keys stored in the `McpServerDefinition` configuration, eliminating the need for agents to manage credentials directly.

### GitHub Integration

GitHub operations surface through the same MCP-integration skill, exposing actions like `create_issue`, `search_repos`, and `create_pr`. The skill definition in **[`apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts)** catalogs these operations:

```

| "GitHub operations" | github | `create_issue`, `search_repos`, … |

```

When executed, these tools route through `executeTool` to Composio's GitHub connector, which handles the actual GitHub API authentication and request formatting. This abstraction allows Rowboat agents to interact with repositories without implementing OAuth flows or API clients directly.

## Implementation Examples

### Listing Configured MCP Servers

```typescript
import { listServers } from '@x/core/mcp';

// Returns { [serverName]: { url, apiKey?, … } }
const servers = await listServers();
console.log(servers);

```

*Source*: [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) (function `listServers`)

### Sending a Slack Message

```typescript
import { sendMessage } from '@x/core/builtin-tools';

// Assumes a Slack server is configured and connected
await sendMessage({
  channel: 'C12345678',   // channel ID
  text: 'Hello from Rowboat!'
});

```

*Source*: [`apps/x/packages/core/src/application/lib/builtin-tools.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/lib/builtin-tools.ts) – `sendMessage` calls `executeSlackTool` which uses `executeTool` under the hood.

### Creating a GitHub Issue via MCP

```typescript
import { executeTool } from '@x/core/mcp';

await executeTool('default', 'github_create_issue', {
  owner: 'rowboat-labs',
  repo: 'rowboat',
  title: 'Bug report from MCP',
  body: 'Detailed description…'
});

```

*Source*: [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) – `executeTool` forwards the request to the remote MCP server, invoking Composio's GitHub connector.

## Summary

- **Rowboat MCP tool integrations** expose external SaaS services as callable functions through a centralized runtime layer.
- The **MCP core** in [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) provides `listServers`, `listTools`, and `executeTool` for dynamic server interaction.
- **Configuration** persists in [`config/mcp.json`](https://github.com/rowboatlabs/rowboat/blob/main/config/mcp.json) and loads through [`apps/x/packages/core/src/mcp/repo.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/repo.ts), separating credentials from code.
- **Builtin wrappers** in [`apps/x/packages/core/src/application/lib/builtin-tools.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/lib/builtin-tools.ts) provide typed, error-handled APIs for Slack, Linear, and GitHub operations.
- **Composio-hosted connectors** handle the actual SaaS API authentication and request formatting, allowing agents to interact with external services without managing OAuth flows directly.

## Frequently Asked Questions

### How does Rowboat authenticate with external services like Slack and GitHub?

Rowboat stores authentication credentials in the `McpServerDefinition` configuration object, typically located in [`config/mcp.json`](https://github.com/rowboatlabs/rowboat/blob/main/config/mcp.json) and managed by [`apps/x/packages/core/src/mcp/repo.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/repo.ts). When executing tools, the MCP runtime forwards these credentials to Composio-hosted connectors, which handle the actual OAuth or API key authentication with the external SaaS providers. Agents never directly access or manage these credentials.

### What is the difference between `executeTool` and the builtin tool wrappers?

The `executeTool` function in [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) is the low-level primitive that forwards raw JSON payloads to remote MCP servers. The builtin tool wrappers in [`apps/x/packages/core/src/application/lib/builtin-tools.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/lib/builtin-tools.ts) provide higher-level, typed abstractions for specific services like Slack. These wrappers handle input validation, resolve tool slugs from human-readable hints, check connection status, and normalize error responses before calling `executeTool` internally.

### Can Rowboat integrate with SaaS services beyond Slack, Linear, and GitHub?

Yes. The MCP architecture in Rowboat is designed to support any service that provides a Composio-compatible MCP endpoint. The `listTools` function dynamically discovers available tools from configured servers, meaning new SaaS integrations only require adding the server URL and API key to [`config/mcp.json`](https://github.com/rowboatlabs/rowboat/blob/main/config/mcp.json). The skill definition in [`apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts) can then expose these tools to LLM agents without code changes to the core runtime.

### Where are MCP server configurations stored in Rowboat?

MCP server configurations are stored in [`config/mcp.json`](https://github.com/rowboatlabs/rowboat/blob/main/config/mcp.json) at the user or project level. The repository implementation in [`apps/x/packages/core/src/mcp/repo.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/repo.ts) handles reading and writing this configuration, while the shared types in [`apps/x/packages/shared/src/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/shared/src/mcp.ts) define the schema using Zod for runtime validation. This separation allows the MCP runtime in [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) to remain agnostic of storage implementation details.