What is an MCP server, and does your business need one?

MCP in one paragraph

An MCP server sits between an AI assistant and one of your systems: your CRM, a database, the help desk or an internal API. It tells the assistant which actions are available, like “look up an order by number” or “create a support ticket”, and carries them out when the assistant asks. Because it’s a standard, the same server works with any AI app that supports MCP, instead of a separate integration for each one.

What a server can offer

A small working example

Here is a complete MCP server for a support team, written in TypeScript with the official SDK. It has one of each building block. In a real project the order lookup would query your order system read-only; here it reads three sample orders so the example stays short.

// A minimal MCP server for a support team: one tool, one resource, one prompt.
// Runs over stdio, which is how desktop AI apps start local servers.
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod';

// In a real server this is a read-only query against your order system
const ORDERS: Record<string, { status: string; carrier?: string; eta?: string; items: number }> = {
  '4821': { status: 'shipped', carrier: 'UPS', eta: '2026-11-03', items: 2 },
  '4822': { status: 'delayed at warehouse', eta: '2026-11-06', items: 1 },
  '4823': { status: 'delivered', carrier: 'USPS', items: 3 },
};

const server = new McpServer({ name: 'order-desk', version: '1.0.0' });

// Tool: an action the AI can take
server.registerTool(
  'look_up_order',
  {
    title: 'Look up an order',
    description: 'Status, carrier and expected delivery date for one order number.',
    inputSchema: { orderNumber: z.string().regex(/^\d{4,8}$/).describe('Order number, digits only') },
    annotations: { readOnlyHint: true },
  },
  async ({ orderNumber }) => {
    const order = ORDERS[orderNumber];
    const text = order ? JSON.stringify({ orderNumber, ...order }) : `No order ${orderNumber} found.`;
    return { content: [{ type: 'text', text }], isError: !order };
  }
);

// Resource: information the AI can read
server.registerResource(
  'returns-policy',
  'policies://returns',
  { title: 'Returns policy', mimeType: 'text/markdown' },
  async (uri) => ({
    contents: [{ uri: uri.href, text: '# Returns\n- 30 days from delivery\n- Unused items in original packaging\n- Refund to the original payment method within 5 business days' }],
  })
);

// Prompt: a ready-made instruction the team can reuse
server.registerPrompt(
  'delay_reply',
  {
    title: 'Reply to a delayed order',
    description: 'Draft a short, honest reply to a customer whose order is late.',
    argsSchema: { orderNumber: z.string() },
  },
  ({ orderNumber }) => ({
    messages: [{
      role: 'user',
      content: { type: 'text', text: `Look up order ${orderNumber} with look_up_order, then draft a three-sentence reply: apologize, give the new delivery date, and offer to cancel if it no longer works for them. Don't promise anything the order data doesn't support.` },
    }],
  })
);

await server.connect(new StdioServerTransport());

To check it behaves, we connected to it the way an AI app does, with a short test client, and used each capability once, including two bad requests:

To use it from a desktop AI app such as Claude Desktop, you add the server to the app’s MCP configuration, and the app starts it when needed:

{
  "mcpServers": {
    "order-desk": {
      "command": "node",
      "args": ["/path/to/build/order-desk.js"]
    }
  }
}

A production server adds sign-in, permissions per person, a real data source and an audit log. Our finance MCP server tutorial walks through all of that against a PostgreSQL database.

What it looks like day to day

• A support agent asks “what’s happening with order 4821?” and gets the answer from the order system without opening it.
• A salesperson pulls an account’s full history from the CRM before a call.
• Someone in operations asks a question of the database in plain English, read-only.
• Staff create tickets, tasks or draft replies without switching between five tools.

When you don’t need one

Keeping it safe

Giving AI access to your systems deserves the same care as giving a new employee access. Start read-only and add actions that change data one at a time. The server gets only the permissions it needs, through proper sign-in, and every action is logged so you can see what the AI did and why.

How a project usually runs

1. Pick the one or two systems people ask about most, often the CRM, the order system or the help desk.
2. List the real questions your team asks each week. Those become the first tools.
3. Build those read-only and test them against the real questions.
4. Add actions that change data one at a time, with approval where it matters.
5. Roll out to a small group before widening access.

From your side, it helps to know which AI app your team will use, to have API access to the systems, to write down what the AI must never do on its own, and to have someone who can check the early answers for accuracy.

Questions to ask any MCP provider

• Which actions can the AI take by itself, and which need approval?
• How does the server sign in to our systems, and can we see and revoke that access?
• Is every action logged and searchable?
• Where does our data go when the AI reads it, and is any of it stored?
• What happens if someone asks the AI to do something it shouldn’t?

Good answers to those matter more than any feature list. There’s more on our MCP development service, and on how MCP fits into AI agents.