Model Context Protocol: A Standard for Engineering AI Integration

The emergence of large language models has created both opportunities and challenges for engineering workflows. While AI assistants demonstrate remarkable capabilities in code generation, analysis, and documentation, integrating them effectively with existing tools and data sources has remained fragmented and proprietary.

The Model Context Protocol (MCP), introduced by Anthropic in late 2024, addresses this challenge by providing an open standard for connecting AI systems with the tools engineers use daily.

The Translation Problem

Large language models operate in the realm of natural language—they understand intent, context, and nuance. But the systems we need them to interact with speak in structured API calls with precise parameters, authentication tokens, and data formats.

Consider asking an AI assistant: “What were our billable hours on the Anderson Controls project last month?”

The AI understands what you want. But to answer, it needs to:

Authenticate with your time tracking system
Query the correct API endpoint with proper parameters
Filter by project name and date range
Aggregate the results
Format them meaningfully

Without a translation layer, every integration requires custom code that bridges natural language understanding to specific API mechanics. MCP provides that bridge as a standardized protocol.

How MCP Works: The Translation Layer

MCP defines a client-server architecture where MCP Servers act as translation layers between AI systems and external services:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   AI Assistant  │────▶│   MCP Server    │────▶│  External API   │
│ (Natural Lang.) │     │ (Translation)   │     │ (Structured)    │
└─────────────────┘     └─────────────────┘     └─────────────────┘
        │                       │
        │  "Get revenue for     │  POST /api/reports/profit-loss
        │   Q2 2025"            │  { start: "2025-04-01",
        │                       │    end: "2025-06-30" }
        └───────────────────────┘

The MCP server exposes a catalog of tools—discrete functions the AI can invoke. Each tool includes a schema that precisely describes:

Name and description: What the tool does in plain language
Input parameters: Required and optional arguments with types
Output structure: What data the tool returns and in what format

When the AI needs information, it examines available tool schemas, selects the appropriate tool, constructs valid parameters, and interprets the structured response—all while maintaining natural conversation with the user.

Tool Schema Example

Here’s how a tool might be defined in an MCP server:

{
  "name": "get_profit_loss",
  "description": "Generate a Profit and Loss report for any date range",
  "inputSchema": {
    "type": "object",
    "properties": {
      "start_date": {
        "type": "string",
        "description": "Start date (YYYY-MM-DD)"
      },
      "end_date": {
        "type": "string",
        "description": "End date (YYYY-MM-DD)"
      },
      "accounting_method": {
        "type": "string",
        "enum": ["Cash", "Accrual"],
        "description": "Accounting method for the report"
      }
    },
    "required": ["start_date", "end_date"]
  }
}

The AI reads this schema and understands exactly how to call the tool. When a user asks about “last quarter’s financials,” the AI translates that to specific date parameters and invokes the tool correctly.

Protocol Origins and Design

Anthropic released the Model Context Protocol as an open standard in November 2024, publishing both the specification and reference implementations. The design reflects several key principles:

Simplicity: MCP uses JSON-RPC 2.0 as its message format—a well-understood standard that’s easy to implement across languages.

Separation of concerns: AI applications (hosts) don’t need to know implementation details of external services. MCP servers encapsulate that complexity.

Discoverability: Servers expose their capabilities through standardized methods, allowing AI systems to understand what tools are available at runtime.

Security boundaries: Each MCP server runs with its own permissions and authentication, preventing AI systems from having direct access to credentials.

The protocol supports three types of capabilities:

Tools: Functions the AI can call to perform actions or retrieve data
Resources: Data sources the AI can read (files, database records, API responses)
Prompts: Pre-defined interaction templates for specific workflows

Transport: STDIO vs SSE

MCP supports multiple transport mechanisms, and choosing the right one depends on your deployment architecture.

STDIO Transport (Local)

The default transport uses standard input/output streams. The MCP host spawns the server as a subprocess and communicates via stdin/stdout:

┌──────────────┐  stdin   ┌──────────────┐
│   MCP Host   │─────────▶│  MCP Server  │
│  (Claude)    │◀─────────│  (subprocess)│
└──────────────┘  stdout  └──────────────┘

Best for:

Local development
Desktop AI applications
Single-user scenarios
Servers that need filesystem access

Advantages:

Simple process management
No network configuration
Server inherits user permissions
Low latency

SSE Transport (Remote/Streaming)

For non-local deployments, MCP supports Server-Sent Events (SSE) over HTTP:

┌──────────────┐  HTTP POST  ┌──────────────┐
│   MCP Host   │────────────▶│  MCP Server  │
│  (Cloud)     │◀────────────│  (Remote)    │
└──────────────┘     SSE     └──────────────┘

Best for:

Cloud-hosted AI applications
Multi-user environments
Servers behind firewalls
Enterprise deployments

Considerations:

Requires HTTP endpoint exposure
Authentication must be handled explicitly
Streaming responses over SSE for real-time feedback
Firewall and proxy configuration needed

Streamable HTTP (Emerging)

The specification also describes Streamable HTTP transport for scenarios requiring bidirectional streaming without SSE limitations. This is particularly relevant for long-running operations where the server needs to push updates.

Practical Applications

Financial Integration

We’ve developed MCP integrations that connect AI assistants directly to QuickBooks, enabling natural language queries:

“What was our revenue from embedded systems projects last quarter?”

The MCP server translates this to QuickBooks API calls, handles OAuth authentication, processes the response, and returns structured data the AI can interpret and present.

Workflow Automation

Integration with n8n workflow automation allows AI assistants to trigger complex multi-step processes:

“Generate an invoice for the Anderson Controls project and send the standard payment reminder sequence.”

The AI orchestrates multiple tool calls through MCP, each translated to specific workflow triggers.

Semantic Code Search

For large codebases, MCP servers provide semantic search capabilities. Rather than keyword matching, the AI can query for concepts:

“Find the authentication middleware that handles JWT validation”

The server translates semantic queries into vector searches and returns relevant code locations.

Implementation Considerations

Building reliable MCP servers requires attention to several engineering concerns:

Schema design: Well-designed tool schemas make the AI more effective. Descriptions should be clear about what the tool does and when to use it. Parameter descriptions should explain expected formats and constraints.

Error handling: AI systems need informative error responses to recover gracefully. Return structured errors that explain what went wrong and how to correct it.

Rate limiting: AI assistants can be enthusiastic about exploring data. Implement sensible limits to prevent runaway API costs.

Idempotency: Design tools so repeated calls with the same parameters produce consistent results. AI systems may retry operations.

Logging and observability: Track tool invocations for debugging and audit purposes. Understanding how the AI uses your tools helps improve schema design.

Getting Started

For engineering teams interested in MCP integration:

Evaluate the ecosystem: Check the MCP servers repository for existing integrations
Identify high-value tools: What data sources and actions would benefit most from AI access?
Start with STDIO: Build and test locally before considering remote deployment
Design schemas carefully: Good descriptions and parameter documentation improve AI accuracy
Test with realistic prompts: Verify the AI understands when and how to use your tools

Looking Forward

The Model Context Protocol represents a fundamental shift in how AI systems integrate with engineering workflows. By standardizing the translation layer between natural language and structured APIs, MCP enables AI assistants to become genuine participants in technical work rather than isolated tools.

For engineering consultancies, this means AI systems that understand project context, access relevant data across multiple systems, and contribute meaningfully to analysis and documentation—all through a consistent, maintainable integration standard.

Kassebaum Engineering develops custom MCP integrations for engineering and technical consulting applications. Contact us to discuss how AI integration could enhance your workflows.