MCP Servers: Connect Your AI Agents to Any External Platform

August 25, 2026 · 3 min read

CEO @ Optimly

Your AI agents just got a lot more powerful.

Today we're launching MCP Servers — a new feature that lets you connect any Model Context Protocol server to Optimly. Once connected, every agent in your workspace can call the server's tools directly during conversations, with no code changes required.

What is MCP?

The Model Context Protocol is an open standard that defines how AI agents discover and call external tools. Think of it as a universal plug: any platform that exposes an MCP server becomes immediately usable by any MCP-compatible agent.

The ecosystem is already large and growing fast. MCP servers exist for:

GitHub — read repos, open issues, create pull requests
Notion — query pages, create notes, update databases
Slack — post messages, read channels, search conversations
Jira — create tickets, update status, query backlogs
Google Drive / Docs / Sheets — read and write documents
Any custom internal system — expose your own tools over HTTP

Before MCP, connecting an AI agent to an external tool meant writing custom integration code for every platform, maintaining API clients, and rebuilding the same auth plumbing over and over. MCP removes all of that.

How It Works in Optimly

The integration is entirely at the user level — you register your MCP servers once, and all your agents in that workspace get access automatically.

1. Register your MCP server

Go to MCP Servers in the sidebar (or through Integrations → MCP Servers). Click Add server and fill in:

Name — a label for your team (e.g. "GitHub Tools", "Internal CRM")
URL — the base URL of your MCP server (Streamable HTTP transport)
Authentication — none, Bearer token, or API key header

That's it. No YAML config files, no environment variables to restart services for.

2. Your agents discover tools automatically

When a conversation starts, each agent checks your registered MCP servers and calls tools/list to discover what's available. The tools are injected into the agent's ReAct loop alongside its built-in capabilities (lead capture, email handoff, knowledge retrieval, etc.).

The agent sees tool names, descriptions, and input schemas — exactly as the MCP server advertises them.

3. The agent calls tools as needed

During a conversation, if the user asks something that needs an external tool, the agent calls it via tools/call (standard JSON-RPC 2.0) and incorporates the result into its response.

User: "Can you open a GitHub issue for the bug we discussed?"
Agent: calls create_issue on your GitHub MCP server
Agent: "Done — I've opened issue #142: 'Login timeout on mobile' in your repo."

From the user's perspective it's seamless. From yours, the conversation is fully tracked in Optimly as usual.

Authentication Options

Type	When to use
None	Public or internally-trusted MCP servers
Bearer token	OAuth tokens, personal access tokens
API key header	Custom header (e.g. `X-API-Key`) with a secret value

Auth credentials are stored per server and sent on every request. The secret value is never returned in API read responses.

Example: Connecting to a GitHub MCP Server

Several open-source GitHub MCP servers are available. Here's how to wire one up:

# Run the GitHub MCP server (example using a community image)
docker run -p 3000:3000 -e GITHUB_TOKEN=ghp_xxx ghcr.io/example/github-mcp-server

Then in Optimly:

Name: GitHub Tools
URL: https://your-server.example.com/mcp
Auth type: Bearer token
Token: ghp_xxx

Your agents now have access to every tool the server exposes: list_repos, create_issue, get_pull_request, search_code, and more.

Building Your Own MCP Server

Any HTTP server that speaks JSON-RPC 2.0 and implements the two core methods is MCP-compatible:

POST /mcp
Content-Type: application/json

{"jsonrpc":"2.0","method":"tools/list","id":1}

{
  "jsonrpc": "2.0",
  "result": {
    "tools": [
      {
        "name": "get_order_status",
        "description": "Get the current status of a customer order",
        "inputSchema": {
          "type": "object",
          "properties": {
            "order_id": { "type": "string" }
          },
          "required": ["order_id"]
        }
      }
    ]
  },
  "id": 1
}

POST /mcp
Content-Type: application/json

{"jsonrpc":"2.0","method":"tools/call","params":{"name":"get_order_status","arguments":{"order_id":"ORD-4821"}},"id":2}

That's the entire protocol. If you have an internal API, wrapping it as an MCP server typically takes less than an hour.

What This Unlocks

With MCP Servers, your AI agents stop being isolated responders and become active participants in your business workflows.

A support agent can check real order status instead of asking users to "contact the team." A sales agent can log a call note in your CRM as soon as it ends. A knowledge agent can pull the latest doc version from Notion before answering. An ops agent can create a ticket the moment an issue is identified.

The integration is live today. Head to Dashboard → MCP Servers to add your first server.

What is MCP?​

How It Works in Optimly​

1. Register your MCP server​

2. Your agents discover tools automatically​

3. The agent calls tools as needed​

Authentication Options​

Example: Connecting to a GitHub MCP Server​

Building Your Own MCP Server​

What This Unlocks​

Further Reading​