Let’s MCP: The Missing Protocol Between AI and Your App

AI tools have become incredibly powerful, but integrating them into real-world applications often feels like a nightmare of glue code. You end up copying and pasting prompts, hacking together APIs, and hoping nothing breaks when things update. Why? Because large language models (LLMs) don’t know your app—and there’s no standard way for them to understand it or interact with it reliably.

That’s exactly what the Model Context Protocol (MCP) is designed to solve.

MCP is an open protocol that bridges your application and an LLM by exposing structured, machine-readable context and providing tools. It doesn’t just let AI generate code—it enables it to interact with your backend, your data, and your users, all within strict boundaries and under your supervision.

Let’s dive into what MCP is, what it makes possible, and how you can start using it in your web development workflow today.

What Is MCP?

MCP defines how AI interfaces with your app— in a way that’s safe, consistent, and fully under your control.

It introduces four foundational concepts:

– Resources – Structured, factual data (like OpenAPI specs, schemas, or Markdown docs) that the model can use to reason about your app.
– Prompts – Reusable natural-language instructions based on  your Resources.
– Tools – Executable actions models can suggest, executed only under explicit user approval or predefined developer rules..
– Sampling options – Controls for model creativity and generation style, such as temperature (randomness), stop sequences (where the model stops generating), or formatting preferences.

Most importantly, MCP is a protocol, not an SDK or vendor lock-in. It defines a standard interface between any LLM host application (like an editor or browser) and one or more MCP servers (local or remote), which provide the capabilities listed above.

Why MCP Matters for Developers

1. Structured AI Collaboration 
   You no longer need complex prompt engineering. MCP lets you expose only the parts of your application that matter: APIs, database schemas, and business logic. The model now operates with accurate, structured, and up-to-date context.
2. Human-In-The-Loop Safety 
   MCP doesn’t let models run tools autonomously. Every action requires explicit user approval. This aligns with real-world dev workflows: AI can suggest, but you stay in control.
3. Reusable, Extensible, and Auditable 
   Resources, Prompts, and Tools can be versioned, organized, and reused across environments. This makes AI integration part of your codebase, not a mysterious add-on.

Real-World Use Cases

MCP is already enabling workflows like:

– Inbox triage: Reading, summarizing, and drafting replies with access to prior conversations.
– Database querying: Converting natural language into SQL using your actual schema as a Resource.
– Checkout flows: AI agents equipped with rate-limited tools  to guide users through pricing and subscription logic.
– Learning environments: AI that understands your curriculum and track your progress.
– API development: Automatically generating handlers or Postman tests from an OpenAPI document.
– Developer onboarding: AI assistants that can install, build, and troubleshoot your repo based on real CI configs, permissions docs, and setup guides.

A Simple MCP Example (Using the TypeScript SDK)

1. Install the SDK
   “`
   npm install @mcp/typescript-sdk
   “`
2. Create an MCP Server
   “`ts
   // mcp-server.ts
   import { MCPServer } from “@mcp/typescript-sdk”;
   import swaggerDoc from “./swagger.json”;

const server = new MCPServer({
  name: “api-helper”,
  version: “1.0.0”,
  instructions: “Helps explore and interact with an OpenAPI backend”,
});

server.resource({
  name: “OpenAPI_Backend”,
  format: “openapi”,
  data: swaggerDoc,
});

server.tool({
  name: “list-api-endpoints”,
  description: “Lists all available API routes”,
  run: async () => {
    const paths = Object.keys(swaggerDoc.paths || {});
    return {
      type: “text”,
      content: `Available endpoints:\n\n${paths.join(“\n”)}`,
    };
  },
});

server.listen({ port: 3333 });
console.log(“✅ MCP server running on http://localhost:3333”);
“`
MCP isn’t about replacing developers-it’s about enabling real collaboration between humans and AI. It provides a common language to describe your app to a model—and a safe, structured mechanism to let it help you.

Instead of pasting prompts into black boxes, MCP lets you build auditable, modular,  and scalable AI experiences using the tools and standards you already know.

If you’ve ever dreamed of giving AI real access to your code, backend, or workflows—without sacrificing control—this is how you do it.

Let’s MCP.

More resources

1. Read the MCP spec: https://modelcontextprotocol.io/introduction
2. Explore the TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk
   

Bibliography

– Model Context Protocol. (n.d.). Introduction to MCP. Retrieved June 13, 2025, from https://modelcontextprotocol.io/introduction 

– Model Context Protocol. (n.d.). @mcp/typescript-sdk (v0.4.0) [GitHub repository]. GitHub. Retrieved June 13, 2025, from https://github.com/modelcontextprotocol/typescript-sdk 

– Epic AI Pro. (n.d.). Letting AI interface with your app with MCPs – talk by Kent C. Dodds [Video]. EpicAI. Retrieved June 13, 2025, from https://www.epicai.pro/letting-ai-interface-with-your-app-with-mcps-talk 

– Epic AI Pro. (2025, May 19). MCP Workshop 2025-05-19 [Workshop session]. Retrieved June 13, 2025, from https://www.epicai.pro/mcp-workshop-2025-05-19

Written by:

Mauricio Peraza
Engineering Lead
Country: Costa Rica