MCP Servers

Connect Opulent to any tool that exposes an MCP interface — internal systems, proprietary APIs, and community tools

What is MCP?

MCP (Model Context Protocol) is an open standard that lets any tool expose its capabilities to AI agents. If a service has an MCP server, Opulent can connect to it and use its tools without requiring a custom integration.

This means Opulent's connector ecosystem is not limited to what the Opulent team has manually built. As the MCP ecosystem grows — and it's growing fast — Opulent gains new capabilities automatically.

Why MCP Matters

Pre-built connectors cover the most common tools. But every organization has:

• Internal tools no one else uses
• Proprietary APIs built in-house
• Niche services with no standard connector
• Legacy systems that don't fit the standard integration model

MCP solves this. Build an MCP server once for any tool, and any MCP-compatible agent — including Opulent — can use it.

Connecting a Public MCP Server

Many popular tools already expose MCP servers. Connect them in minutes:

From the Connector Panel

1. Go to Settings → Connectors → MCP Servers → Add Server
2. Enter the MCP server URL
3. Add any required credentials (API key, token)
4. Click Connect

The agent discovers all tools the server exposes and makes them available immediately.

Community MCP Servers

A growing library of community-built MCP servers is available for:

Find available MCP servers at the MCP Registry.

Building a Custom MCP Server

Connect any internal tool or proprietary API by building a lightweight MCP server.

What You Need

• A system with tools or data you want Opulent to access
• The ability to run a small HTTP server (Node.js, Python, or any language)
• An MCP SDK (available for Node.js, Python, Go, Rust)

Example: Internal CRM MCP Server (Node.js)

import { MCPServer, Tool } from '@modelcontextprotocol/sdk';

const server = new MCPServer({
  name: 'acme-internal-crm',
  version: '1.0.0'
});

server.addTool({
  name: 'get_customer',
  description: 'Retrieve customer record by ID or email',
  parameters: {
    type: 'object',
    properties: {
      identifier: { type: 'string', description: 'Customer ID or email address' }
    },
    required: ['identifier']
  },
  handler: async ({ identifier }) => {
    const customer = await internalCRM.getCustomer(identifier);
    return { content: [{ type: 'text', text: JSON.stringify(customer) }] };
  }
});

server.addTool({
  name: 'update_customer_status',
  description: 'Update the status field for a customer record',
  parameters: {
    type: 'object',
    properties: {
      customer_id: { type: 'string' },
      status: { type: 'string', enum: ['active', 'churned', 'at_risk', 'vip'] }
    },
    required: ['customer_id', 'status']
  },
  handler: async ({ customer_id, status }) => {
    await internalCRM.updateStatus(customer_id, status);
    return { content: [{ type: 'text', text: `Updated ${customer_id} to ${status}` }] };
  }
});

server.listen({ port: 3100 });

Once deployed, add https://your-internal-domain.com:3100 to Opulent's MCP Servers list. The agent can now read and update your internal CRM.

Example: Legacy API Wrapper (Python)

from mcp import MCPServer, tool

server = MCPServer("legacy-inventory-system")

@tool(description="Query inventory levels by SKU or product category")
def get_inventory(sku: str = None, category: str = None):
    result = legacy_api.inventory_query(sku=sku, category=category)
    return result.to_dict()

@tool(description="Create a purchase order for restocking")
def create_purchase_order(sku: str, quantity: int, supplier_id: str):
    po = legacy_api.create_po(sku, quantity, supplier_id)
    return {"po_id": po.id, "estimated_arrival": po.eta}

server.run(host="0.0.0.0", port=3200)

MCP Server Security

Authentication

Your MCP server should require authentication. Opulent supports:

• Bearer tokens — Standard API key in the Authorization header
• OAuth 2.0 — For user-level permissions
• IP allowlisting — Restrict to Opulent's outbound IPs

Recommended Security Practices

• Expose only the operations the agent needs — no admin endpoints
• Use read-only credentials where possible for research and analysis tasks
• Log all MCP calls for audit purposes
• Use HTTPS with a valid certificate
• Validate all inputs before passing to your backend systems

What the Agent Can Do with MCP

Once a server is connected, the agent uses its tools naturally in any task:

"Check our internal inventory system for all products with stock below
reorder threshold. For each, create a purchase order and notify the
procurement team via Slack."

The agent:

1. Calls get_inventory(category="all") via your MCP server
2. Filters items below threshold
3. Calls create_purchase_order(...) for each
4. Posts summary to Slack via the Slack connector

No code written by you — just a connected MCP server and a natural language instruction.

MCP vs. Direct Connectors

Common Questions

Does the MCP server need to be publicly accessible? It needs to be reachable from Opulent's agent infrastructure. You can use a secure tunnel (e.g., ngrok for development, or a private network connection for production).

How does Opulent know what tools the server exposes? Opulent calls the MCP server's list_tools endpoint on connection and caches the tool definitions. The agent uses these definitions to decide when to call each tool.

Can I restrict which workspaces can use a given MCP server? Yes. MCP server connections are scoped per workspace. Enable them selectively.

Is there a limit on how many MCP servers I can connect? No hard limit. Practical limits depend on plan tier.

Can I use MCP servers in scheduled tasks and webhook-triggered workflows? Yes. Any active connector — including MCP servers — is available in automated workflows.