Custom MCP Servers: Building AI Agents That Understand Your Business Context

Your AI assistant doesn't know your business. It doesn't know your strategy, your customers, your competitive landscape, or your company's principles. Every conversation starts from zero.

This is the context problem—and it's why most AI tools feel generic. They're powerful but disconnected. They can write code, analyze data, and generate content, but they can't do any of that in the context of your specific business.

MCP (Model Context Protocol) changes this. It's a standard that lets AI agents connect to your systems and access live business context in real-time.

Here's how to build your own.

What Is MCP?

Model Context Protocol is an open standard developed by Anthropic that creates a bridge between AI models and external data sources. Think of it as an API layer specifically designed for AI context.

Before MCP, giving an AI agent business context meant:

• Pasting documents into chat windows
• Building custom integrations for each AI tool
• Hoping the model remembers context from previous conversations

With MCP, AI agents can:

• Query your systems directly
• Access live data without copy-paste
• Execute actions in your business tools
• Maintain context across sessions

The protocol defines three primitives:

Why Custom MCP Servers Matter

Generic AI tools have generic context. They know the internet but not your business.

Custom MCP servers solve this by exposing your specific context to AI agents:

• Strategy context: Mission, vision, current priorities
• Operational context: Active projects, team capacity, deadlines
• Customer context: Segments, preferences, history
• Competitive context: Market position, competitor moves

When an AI agent has this context, it doesn't just generate generic advice—it generates advice aligned with your specific situation.

This is the difference between:

"Consider implementing a customer loyalty program to improve retention."

And:

"Given your Q1 priority of reducing churn in the SMB segment, and your principle of 'earn trust through transparency,' consider a proactive outreach program that shares usage insights before renewal conversations."

Same question, different context, dramatically different value.

Building Your First MCP Server

MCP servers can be built in any language, but TypeScript/Node.js has the most mature SDK. Here's a minimal example:

Step 1: Project Setup

mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk

Step 2: Basic Server Structure

// server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const server = new Server(
  { name: 'my-business-context', version: '1.0.0' },
  { capabilities: { tools: {}, resources: {} } }
)

// Start the server
const transport = new StdioServerTransport()
server.connect(transport)

Step 3: Add a Resource (Read-Only Data)

Resources expose data that AI agents can read:

server.setRequestHandler('resources/list', async () => ({
  resources: [
    {
      uri: 'context://strategy/current',
      name: 'Current Strategy',
      description: 'Company strategy and priorities',
      mimeType: 'application/json'
    }
  ]
}))

server.setRequestHandler('resources/read', async (request) => {
  if (request.params.uri === 'context://strategy/current') {
    return {
      contents: [{
        uri: request.params.uri,
        mimeType: 'application/json',
        text: JSON.stringify({
          mission: 'Help businesses execute strategy with AI',
          currentPriorities: ['Reduce churn', 'Expand enterprise'],
          principles: ['Transparency', 'Customer-first', 'Ship fast']
        })
      }]
    }
  }
})

Step 4: Add a Tool (Actionable Capability)

Tools let AI agents take actions:

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_customer_context',
      description: 'Retrieve context about a specific customer',
      inputSchema: {
        type: 'object',
        properties: {
          customerId: { type: 'string', description: 'Customer ID' }
        },
        required: ['customerId']
      }
    }
  ]
}))

server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'get_customer_context') {
    const { customerId } = request.params.arguments
    // Fetch from your database
    const customer = await fetchCustomer(customerId)
    return {
      content: [{ type: 'text', text: JSON.stringify(customer) }]
    }
  }
})

Step 5: Connect to Claude Desktop

Add your server to Claude Desktop's configuration:

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "my-business-context": {
      "command": "node",
      "args": ["/path/to/my-mcp-server/dist/server.js"]
    }
  }
}

Restart Claude Desktop, and your custom context is now available in every conversation.

Real-World Integration Patterns

Pattern 1: Strategy-Aware Agents

Connect your strategy documentation to AI agents:

tools: [{
  name: 'get_strategic_context',
  description: 'Get relevant strategy context for a decision',
  inputSchema: {
    type: 'object',
    properties: {
      topic: { type: 'string', description: 'Decision topic' }
    }
  }
}]

When asked about product decisions, the agent queries your strategy, finds relevant priorities and principles, and grounds its response in your actual strategic framework.

Pattern 2: Customer Intelligence

Expose customer data (with appropriate access controls):

tools: [{
  name: 'analyze_customer_segment',
  description: 'Get insights about a customer segment',
  inputSchema: {
    type: 'object',
    properties: {
      segment: { type: 'string', enum: ['enterprise', 'smb', 'startup'] }
    }
  }
}]

The agent can now provide segment-specific recommendations instead of generic advice.

Pattern 3: Competitive Monitoring

Keep agents updated on competitive landscape:

resources: [{
  uri: 'context://competitive/landscape',
  name: 'Competitive Landscape',
  description: 'Current competitive intelligence'
}]

Responses now account for what competitors are doing—without you having to paste reports into every conversation.

Security and Access Control

MCP servers have full access to whatever you expose. Security matters:

Authentication

For sensitive data, implement authentication:

// Verify API key from environment or request
const apiKey = process.env.MCP_API_KEY
server.setRequestHandler('tools/call', async (request) => {
  const providedKey = request.params.arguments._apiKey
  if (providedKey !== apiKey) {
    throw new Error('Unauthorized')
  }
  // Proceed with tool execution
})

Principle of Least Privilege

Expose only what's needed:

• Read-only by default: Use resources for data, tools only for actions
• Scope narrowly: Customer lookup tool, not database access tool
• Audit everything: Log all MCP requests for review

Data Sensitivity Levels

Not all context should be equally accessible:

The Context Infrastructure Stack

MCP servers are one piece of a larger context infrastructure:

┌─────────────────────────────────────────┐
│           AI Agents (Claude, etc.)      │
├─────────────────────────────────────────┤
│              MCP Protocol               │
├─────────────────────────────────────────┤
│           Your MCP Servers              │
├─────────────────────────────────────────┤
│  Strategy │ Customer │ Ops  │ Competitive│
│   Data    │   Data   │ Data │    Data    │
└─────────────────────────────────────────┘

The MCP server layer translates between your business systems and AI agent protocols. Done well, it becomes invisible—agents just know your context without explicit prompting.

This is how you move from AI tools that require constant context-setting to machine-readable strategy and AI agents that execute strategy autonomously.

Getting Started

You don't need to build everything at once. Start with one high-value context:

1. Pick your highest-friction context: What do you paste into AI chats most often?
2. Build a minimal MCP server: One resource or tool
3. Connect to Claude Desktop: Test in real conversations
4. Iterate: Add context based on what you actually need

The goal isn't a perfect context infrastructure on day one. It's reducing the friction between AI capability and business context—one integration at a time.

Key Takeaways

• MCP bridges AI and business context through a standard protocol
• Three primitives: Resources (read), Tools (act), Prompts (workflows)
• Custom servers expose your specific context to any MCP-compatible AI
• Start simple: One high-value context, one minimal server
• Security matters: Authenticate, scope narrowly, audit everything

Continue Reading

• The MCP Protocol: How AI Agents Access Business Context — Deep dive into the protocol architecture
• How AI Closes the Strategy Execution Gap — Why context-aware AI changes execution
• Strategy Is a Living System, Not a Document — Building strategy as infrastructure