MCP Servers

Connect your agents to databases, APIs, and external services using the Model Context Protocol.

What is MCP?

MCP (Model Context Protocol) is a standard that lets AI agents connect to external tools and data sources. Think of MCP servers as plugins for your agents — they give agents the ability to actually do things beyond just having a conversation.

Without MCP, an agent can only talk. With MCP, an agent can:

• Query your database and return real results
• Read files from a repository
• Create GitHub issues
• Fetch data from any internal API
• Run custom scripts

An MCP server is a small program that exposes a set of tools. When an agent needs to do something — like run a SQL query — it calls the appropriate MCP tool, gets back the result, and incorporates it into its response.

You don’t need to build MCP servers from scratch. There are many open-source MCP servers for common tools. SlackHive also supports inline TypeScript MCPs — you can paste code directly into the UI without deploying anything.

How SlackHive manages MCP

SlackHive manages MCP servers at the platform level. You add a server once to the global catalog, then assign it to any number of agents.

When an agent starts, SlackHive launches all its assigned MCP servers and keeps them running. There’s no per-message startup overhead — once the agent is live, its tools are always ready.

Tool names follow the pattern mcp__{serverName}__{toolName}. For example, a server named redshift with a query tool is called as mcp__redshift__query.

Adding a server to the catalog

1. Open MCP Servers

   In the sidebar, click MCP Servers (under Settings).

2. Click Add Server

   Give it a name and description. The name becomes part of every tool name from this server (mcp__{name}__...).

3. Choose a transport type

   Select how SlackHive connects to this server (see the Transport Types section below).

4. Enter the configuration

   Fill in the command, URL, or script depending on your transport type.

5. Test and save

   Click Test Connection to verify the server starts and responds correctly. Then click Save.

Transport types

There are four ways to run an MCP server:

Transport	Use case
stdio	A local process (Node.js script, Python script, binary) — most common
sse	A remote server accessible via HTTP server-sent events
http	A remote server accessible via HTTP
TypeScript inline	Paste TypeScript source directly — no deployment needed

Configuration examples

Redshift / Data Warehouse

Give your data analyst agent the ability to run real SQL queries:

{
  "name": "redshift",
  "type": "stdio",
  "description": "Read-only Redshift query access",
  "config": {
    "command": "node",
    "args": ["/path/to/redshift-mcp/dist/index.js"],
    "envRefs": {
      "DATABASE_URL": "REDSHIFT_DATABASE_URL"
    }
  }
}

Notice the envRefs instead of env. This references a secret from the encrypted store rather than embedding the connection string directly. See Keeping secrets safe below.

Filesystem Access

Give an agent read access to files in a directory — useful for code review or documentation agents:

{
  "name": "filesystem",
  "type": "stdio",
  "description": "Read files from the codebase",
  "config": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/your/repo"]
  }
}

The agent can then use mcp__filesystem__read_file, mcp__filesystem__list_directory, etc.

Remote API (SSE)

Connect to a remote MCP server over the network:

{
  "name": "analytics-api",
  "type": "sse",
  "description": "Internal analytics data API",
  "config": {
    "url": "https://mcp.internal.example.com/sse",
    "headers": {
      "Authorization": "Bearer your-token-here"
    }
  }
}

Inline TypeScript

The most convenient option for internal tools: paste TypeScript source directly into the UI. SlackHive writes it to disk and runs it — no separate deployment needed.

Select TypeScript inline script as the transport type, then paste your implementation:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-tool", version: "1.0.0" });

server.tool(
  "lookup_customer",
  { customer_id: z.string() },
  async ({ customer_id }) => ({
    content: [{ type: "text", text: `Customer ${customer_id}: Acme Corp, Plan: Pro` }],
  })
);

const transport = new StdioServerTransport();
await server.connect(transport);

This is ideal for simple tools you want to prototype quickly, or for internal utilities you don’t want to expose as file paths.

Assigning servers to agents

Once a server is in the catalog, you can assign it to agents:

• During agent creation — Step 4 (Tools) of the wizard
• After creation — from the agent’s Tools tab

An agent can have any number of MCP servers assigned. All tools from all assigned servers become available to the agent.

Keeping secrets safe

Never paste database credentials, API keys, or passwords directly into MCP config env fields. Use the encrypted env store instead.

The env store encrypts secrets at rest using AES-256. Values are never returned by the API or shown in the browser — only the key names are visible.

1. Add your secret to the store

   1. Go to Settings → Env Vars in the sidebar
   2. Click Add Variable
   3. Enter a name (e.g. REDSHIFT_DATABASE_URL) and the secret value
   4. Click Save — the value is encrypted immediately
2. Reference it in your MCP config

   In your MCP server configuration, use envRefs to map the store key to the environment variable name the server expects:

   {
     "envRefs": {
       "DATABASE_URL": "REDSHIFT_DATABASE_URL"
     }
   }
   

   When the agent starts, the runner decrypts REDSHIFT_DATABASE_URL from the store and injects it as DATABASE_URL into the MCP process environment.

The raw secret never appears in API responses, browser dev tools, or log files.

Testing a server

From Settings → MCP Servers, click the Test button next to any server. SlackHive starts the server process and verifies it responds to initialization. Results appear inline.

If a server fails to start, the agent still runs — an error is logged, but the agent continues without that server’s tools. Check the agent’s Logs tab for details.

Next steps

Agent Tools & Permissions

Control exactly which MCP tools each agent can use.

Env Vars

Configure your encryption key and other platform settings.