MCP Night 2.0 Demo Recap: XMCP Framework - The Fastest Way to Build MCP Servers

This post is part of our MCP Night 2.0 demo recap series, highlighting the innovative presentations from our August 7th event at the Regency Ballroom in San Francisco.

At MCP Night 2.0, developers showcased innovative tools and frameworks that are pushing the Model Context Protocol ecosystem forward.

Among the standout presentations was Valentina Bearzotti from Basement Studio, who demonstrated XMCP—a framework that might just be the fastest way to create and deploy MCP servers.

Meet the Builder

Valentina Bearzotti is a software developer at Basement Studio in Argentina and co-author of XMCP. Her presentation showcased how XMCP addresses one of the biggest challenges facing MCP adoption: lowering the barrier to entry for developers who want to build tools on top of the MCP ecosystem.

The XMCP Approach

XMCP is a SaaS framework designed with one clear goal in mind: streamlining MCP server development. Rather than forcing developers to handle complex setup and configuration, XMCP takes a declarative, file-system-based approach that makes building MCP servers feel natural and intuitive.

File-System-Based Routing

The core innovation of XMCP is its declarative file system routing. In Valentina's demo, she showed how all tools are simply files that live in a tools directory and get automatically injected into the MCP server. This eliminates the need for manual setup and configuration—developers can focus on building tools rather than wiring infrastructure.

During the live demo, Valentina created a new tool called "greet" with just a few lines of code. The development server automatically detected the new file and restarted, showcasing the framework's hot-reload capabilities that keep the development experience smooth and responsive.

Simple Tool Syntax

XMCP tools follow a clean, minimal syntax with just three key elements:

1. Handler function (required) - The core logic that returns your tool's response
2. Schema export (optional) - Defines parameters and validation for your tool
3. Metadata export (optional) - Provides hints to LLMs for better tool detection

This approach makes tools easy to understand and quick to implement. Here's what a complete XMCP tool looks like:

// src/tools/greet.ts

import { z } from "zod";
import { type InferSchema } from "xmcp";

// Define the schema for tool parameters
export const schema = {
  name: z.string().describe("The name of the user to greet"),
};

// Define tool metadata
export const metadata = {
  name: "greet",
  description: "Greet the user",
  annotations: {
    title: "Greet the user",
    readOnlyHint: true,
    destructiveHint: false,
    idempotentHint: true,
  },
};

// Tool implementation
export default async function greet({ name }: InferSchema<typeof schema>) {
  const result = `Hello, ${name}!`;

  return {
    content: [{ type: "text", text: result }],
  };
}

‍‍
In her demo, Valentina showed how this same pattern scales from simple greetings to more complex tools, with the framework handling all the MCP protocol details automatically.

Middleware Support

The framework includes built-in support for middleware, including authentication middleware that XMCP provides natively. Valentina demonstrated adding API key authentication to a tool by simply importing the built-in middleware and using utility functions to extract headers from requests.

What makes this particularly powerful is XMCP's support for middleware chaining—developers can combine multiple middleware functions to create sophisticated request processing pipelines.

Flexible Server Configuration

XMCP offers extensive configuration options without overwhelming developers. The framework allows customization of:

• Transport types (HTTP, stdio, etc.)
• Port and hosting settings for Docker deployments
• CORS configuration
• Custom web server configurations

Valentina showed an example from their internal image compression tool, which uses stdio transport and extends the web configuration to include Sharp as an external dependency for image processing.

Deployment Made Simple

One of XMCP's most impressive features is its deployment story. The framework supports deployment to any platform that can run stateless servers, and developers can publish to npm when using stdio transport.

But the real magic happens with XMCP's native Vercel integration. In her live demo, Valentina deployed an MCP server to production with just a few commands:

1. Run vercel prod in the terminal
2. Copy the deployment URL once building is complete
3. Add the URL to Cursor's MCP settings with any required headers
4. Toggle the server on

Within seconds, the locally developed MCP server was live and accessible in production. This seamless deployment experience removes one of the biggest friction points in MCP development.

Flexibility for Existing Projects

XMCP isn't just for greenfield projects. The framework can be integrated into existing Express.js or Next.js applications, allowing developers to take advantage of XMCP's routing and tool features while leveraging their existing infrastructure and patterns.

For teams that want to add MCP capabilities to an existing codebase, they can simply run npx xmcp and be ready to go.

Why XMCP Matters

XMCP represents a important step forward for MCP adoption. By providing a framework that prioritizes developer experience and removes common setup headaches, it makes building MCP servers accessible to a much broader audience.

The combination of file-system-based routing, simple tool syntax, powerful middleware support, and one-command deployment creates a developer experience that feels modern and productive. For teams looking to experiment with MCP or build production-ready servers quickly, XMCP offers a compelling path forward.

Getting Started

Developers interested in trying XMCP can get started at xmcp.dev, where they'll find documentation, examples, and everything needed to begin building MCP servers with this promising framework.

Watch Valentina's full XMCP demo from MCP Night 2.0 on YouTube. Interested in learning more about MCP implementations? Check out our comprehensive MCP Night 2.0 event recap and explore other demo recaps in this series.