MCP Server Integration

What is MCP?

The Model Context Protocol (MCP) is an open standard published by Anthropic that lets AI models call tools exposed by external servers. Your MCP server defines functions (tools) that the AI can invoke — your server handles the execution and returns a result.

AgentNDX's sales agent runs on Claude via the Vercel AI SDK, both of which have native MCP support. This means we can connect your MCP server at near-zero infrastructure cost — making AgentNDX the only sales agent platform that supports live data via MCP.

Quick-start: build your server with AI

Copy this prompt into Claude, ChatGPT, or your AI coding tool to generate a working MCP server for your business in minutes:

Build a minimal MCP (Model Context Protocol) server using the
@modelcontextprotocol/sdk Node.js package with HTTP/SSE transport.

My business: [describe your business — e.g. "a restaurant in Miami"]

I need these tools exposed via MCP:
- [tool 1 — e.g. "get_todays_specials() → returns tonight's menu as a string"]
- [tool 2 — e.g. "check_waitlist() → returns current wait time in minutes"]
- [tool 3 — optional]

Requirements:
1. Use HTTP/SSE transport (not stdio)
2. Listen on PORT env var, default 3001
3. Expose a /sse endpoint for MCP connections
4. Each tool should have a clear description and typed parameters
5. Include a simple Bearer token auth check using AUTH_TOKEN env var
6. Include a Dockerfile and a one-command deploy instruction for Railway or Render

The server will be connected to an AgentNDX sales agent so visitors can get
real-time answers. Return all tool results as plain strings.

Replace the bracketed sections with your own business details and tools. The generated server deploys to Railway, Render, or any Node.js host in under 5 minutes.

How it works

1. A visitor asks your agent a question that requires live data.
2. The agent calls a tool on your MCP server (e.g. mcp_check_availability).
3. Your server executes the tool and returns the result.
4. The agent incorporates the live result into its response.

All MCP calls are made server-side from our API — your MCP server URL and auth token are never exposed to the visitor's browser. Tool calls time out after 3 seconds; if your server doesn't respond in time, the agent continues without the live data and logs the failure.

Use cases

Building your MCP server

Your MCP server must use HTTP/SSE transport (not stdio — stdio requires a local process and can't be reached over the network). It must also use an HTTPS URL — plain HTTP is rejected.

Example: Node.js (TypeScript)

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";
import { z } from "zod";

const app = express();
const server = new McpServer({ name: "my-business-mcp", version: "1.0.0" });

// Auth middleware — check Bearer token on every MCP request
app.use("/sse", (req, res, next) => {
  const token = req.headers.authorization?.replace("Bearer ", "");
  if (token !== process.env.AUTH_TOKEN) {
    res.status(401).json({ error: "Unauthorized" });
    return;
  }
  next();
});

// Define your tools
server.tool(
  "get_todays_specials",
  "Returns tonight's menu specials",
  {},
  async () => {
    // Replace with your real data source
    const specials = await fetchTonightsSpecials();
    return { content: [{ type: "text", text: specials.join(", ") }] };
  },
);

server.tool(
  "check_availability",
  "Check appointment availability for a given date",
  { date: z.string().describe("Date in YYYY-MM-DD format") },
  async ({ date }) => {
    const slots = await getAvailableSlots(date);
    return { content: [{ type: "text", text: slots.length > 0
      ? `Available: ${slots.join(", ")}`
      : "No slots available on this date"
    }] };
  },
);

// Wire up SSE transport
app.get("/sse", async (req, res) => {
  const transport = new SSEServerTransport("/message", res);
  await server.connect(transport);
});

app.post("/message", express.json(), async (req, res) => {
  // handle incoming messages
});

app.listen(process.env.PORT ?? 3001);

Example: Python (FastAPI)

from mcp.server.fastmcp import FastMCP
import uvicorn, os

mcp = FastMCP("my-business-mcp")
AUTH_TOKEN = os.environ["AUTH_TOKEN"]

@mcp.tool()
async def get_todays_specials() -> str:
    """Returns tonight's menu specials."""
    # Replace with your real data source
    specials = await fetch_todays_specials()
    return ", ".join(specials)

@mcp.tool()
async def check_availability(date: str) -> str:
    """Check appointment availability. date: YYYY-MM-DD"""
    slots = await get_available_slots(date)
    if slots:
        return f"Available: {', '.join(slots)}"
    return "No slots available on this date"

# Mount with Bearer token middleware
app = mcp.get_sse_app()

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 3001)))

Connecting your server to AgentNDX

1. Deploy your MCP server to any HTTPS host (Railway, Render, Fly.io, Vercel, your own VPS).
2. Go to Dashboard → AI Agent → Live Data tab.
3. Enter your server's SSE endpoint URL (e.g. https://my-server.railway.app/sse).
4. Optionally enter an auth header (e.g. Authorization: Bearer my-secret).
5. Click Test Connection — you'll see your exposed tools listed if the connection succeeds.
6. Toggle Enable, click Save Settings.

Your agent will now call your MCP tools during live conversations. Tools are prefixed with mcp_ internally to prevent naming conflicts with built-in tools.

Security model

Tool naming

All tools from your MCP server are automatically prefixed with mcp_ when passed to the agent. So a tool named check_availability on your server becomes mcp_check_availability in the agent. This prevents conflicts with AgentNDX's built-in tools (like lead_capture).

Use the Tool allowlist field in the dashboard to restrict which tools the agent can call. Leave it blank to allow all tools exposed by your server.

Limits

Error handling

If your MCP server is unreachable, returns an error, or times out:

• The agent continues the conversation without the live data.
• The failure is logged and visible in your Sentry dashboard.
• The agent falls back to its knowledge base and will say “I'm not able to check that right now — let me connect you with the team.”

Design your tools to return plain strings for best results. The agent handles JSON but plain text is easier to incorporate into natural conversation.