The AI ecosystem is evolving quickly, and Anthropic releasing the Mannequin Context Protocol on November twenty fifth, 2024 has actually formed how LLM’s join with information. No extra constructing {custom} integrations for each information supply: MCP offers one protocol to attach all of them. However right here’s the problem: constructing MCP servers from scratch may be advanced.
TL;DR: What’s MCP?
Consider MCP like a USB-C port for AI functions. Simply as USB-C offers a standardized technique to join units to varied peripherals, MCP offers a standardized technique to join AI fashions to completely different information sources, instruments, and companies. It’s an open protocol that allows AI functions to securely and effectively entry exterior context – whether or not that’s your organization’s database, file methods, APIs, or {custom} enterprise logic.
Supply: https://modelcontextprotocol.io/docs/getting-started/intro
In observe, this implies you’ll be able to hook LLMs into the stuff you already work with on daily basis. To call just a few examples, you may question databases to visualise traits, pull and resolve points from GitHub, fetch or replace content material to a CMS, and so forth. Past growth, the identical applies to broader workflows: buyer assist brokers can search for and resolve tickets, enterprise search can fetch and skim content material scattered throughout wikis and docs, operations can monitor infrastructure or management units.
However there’s extra to it, and that’s while you actually unlock the facility of MCP. It’s not nearly single duties, however rethinking total workflows. Immediately, we’re shaping our technique to work together with merchandise and even our personal computer systems: as an alternative of adapting ourselves to the restrictions of software program, we will form the expertise round our personal wants.
That’s the place xmcp is available in: a TypeScript framework designed with DX in thoughts, for builders who wish to construct and ship MCP servers with out the standard friction. It removes the complexity and will get you up and operating in a matter of minutes.
Just a little backstory
xmcp was born out of necessity at Basement Studio, the place we would have liked to construct inner instruments for our growth processes. As we dove deeper into the protocol, we shortly found how fragmented the tooling panorama was and the way a lot time we had been spending on setup, configuration, and deployment reasonably than truly constructing the instruments our crew wanted.
That’s once we determined to consolidate every part we’d discovered right into a framework. The philosophy was easy: builders shouldn’t should grow to be specialists simply to construct AI instruments. The main target needs to be on creating useful performance, not wrestling with boilerplate code and all kinds of complexities.
Key options & capabilities
xmcp shines in its simplicity. With only one command, you’ll be able to scaffold an entire MCP server:
npx create-xmcp-app@newestThe framework robotically discovers and registers instruments. No further setup wanted.
All you want is instruments/
xmcp abstracts the unique software syntax from the TypeScript SDK and follows a SOC precept, following a easy three-exports construction:
- Implementation: The precise software logic.
- Schema: Outline enter parameters utilizing Zod schemas with computerized validation
- Metadata: Specify software identification and conduct hints for AI fashions
// src/instruments/greet.ts
import { z } from "zod";
import { kind InferSchema } from "xmcp";
// Outline the schema for software parameters
export const schema = {
title: z.string().describe("The title of the consumer to greet"),
};
// Outline software metadata
export const metadata = {
title: "greet",
description: "Greet the consumer",
annotations: {
title: "Greet the consumer",
readOnlyHint: true,
destructiveHint: false,
idempotentHint: true,
},
};
// Device implementation
export default async perform greet({ title }: InferSchema) {
return `Good day, ${title}!`;
} Transport Choices
- HTTP: Good for server deployments, enabling instruments that fetch information from databases or exterior APIs
- STDIO: Perfect for native operations, permitting LLMs to carry out duties straight in your machine
You may tweak the configuration to your wants by modifying the xmcp.config.ts file within the root listing. Among the many choices yow will discover the transport kind, CORS setup, experimental options, instruments listing, and even the webpack config. Be taught extra about this file right here.
const config: XmcpConfig = {
http: {
port: 3000,
// The endpoint the place the MCP server will likely be out there
endpoint: "/my-custom-endpoint",
bodySizeLimit: 10 * 1024 * 1024,
cors: {
origin: "*",
strategies: ["GET", "POST"],
allowedHeaders: ["Content-Type"],
credentials: true,
exposedHeaders: ["Content-Type"],
maxAge: 600,
},
},
webpack: (config) => {
// Add uncooked loader for photos to get them as base64
config.module?.guidelines?.push(jpe?g);
return config;
},
};
Constructed-in Middleware & Authentication
For HTTP servers, xmcp offers native options so as to add Authentication (JWT, API Key, OAuth). You may all the time leverage your utility by including {custom} middlewares, which might even be an array.
import { kind Middleware } from 'xmcp';
const middleware: Middleware = async (req, res, subsequent) => {
// Customized processing
subsequent();
};
export default middleware;
Integrations
Whilst you can bootstrap an utility from scratch, xmcp may also work on high of your present Subsequent.js or Specific undertaking. To get began, run the next command:
npx init-xmcp@newestin your initialized utility, and you’re good to go! You’ll discover a instruments listing with the identical discovery capabilities. For those who’re utilizing Subsequent.js the handler is about up robotically. For those who’re utilizing Specific, you’ll should configure it manually.
From zero to prod
Let’s see this in motion by constructing and deploying an MCP server. We’ll create a Linear integration that fetches points out of your backlog and calculates completion charges, excellent for producing undertaking analytics and visualizations.
For this walkthrough, we’ll use Cursor as our MCP consumer to work together with the server.
Establishing the undertaking
The quickest technique to get began is by deploying the xmcp template straight from Vercel. This robotically initializes the undertaking and creates an HTTP server deployment in a single click on.
Different setup: For those who favor a unique platform or transport technique, scaffold regionally with npx create-xmcp-app@newest
As soon as deployed, you’ll see this undertaking construction:
Constructing our foremost software
Our software will settle for three parameters: crew title, begin date, and finish date. It’ll then calculate the completion fee for points inside that timeframe.
Head to the instruments listing, create a file referred to as get-completion-rate.ts and export the three foremost parts that assemble the syntax:
import { z } from "zod";
import { kind InferSchema, kind ToolMetadata } from "xmcp";
export const schema = {
crew: z
.string()
.min(1, "Staff title is required")
.describe("The crew to get completion fee for"),
startDate: z
.string()
.min(1, "Begin date is required")
.describe("Begin date for the evaluation interval (YYYY-MM-DD)"),
endDate: z
.string()
.min(1, "Finish date is required")
.describe("Finish date for the evaluation interval (YYYY-MM-DD)"),
};
export const metadata: ToolMetadata = {
title: "get-completion-rate",
description: "Get completion fee analytics for a particular crew over a date vary",
};
export default async perform getCompletionRate({
crew,
startDate,
endDate,
}: InferSchema) {
// software implementation we'll cowl within the subsequent step
}; Our fundamental construction is about. We now have so as to add the consumer performance to really talk with Linear and get the info we’d like.
We’ll be utilizing Linear’s private API Key, so we’ll have to instantiate the consumer utilizing @linear/sdk . We’ll give attention to the software implementation now:
export default async perform getCompletionRate({
crew,
startDate,
endDate,
}: InferSchema) {
const linear = new LinearClient({
apiKey: // our api key
});
}; As an alternative of hardcoding API keys, we’ll use the native headers utilities to just accept the Linear API key securely from every request:
export default async perform getCompletionRate({
crew,
startDate,
endDate,
}: InferSchema) {
// API Key from headers
const apiKey = headers()["linear-api-key"] as string;
if (!apiKey) {
return "No linear-api-key header supplied";
}
const linear = new LinearClient({
apiKey: apiKey,
});
// remainder of the implementation
} This method permits a number of customers to attach with their very own credentials. Your MCP configuration will seem like:
"xmcp-local": {
"url": "http://127.0.0.1:3001/mcp",
"headers": {
"linear-api-key": "your api key"
}
}Transferring ahead with the implementation, that is what our full software file will seem like:
import { z } from "zod";
import { kind InferSchema, kind ToolMetadata } from "xmcp";
import { headers } from "xmcp/dist/runtime/headers";
import { LinearClient } from "@linear/sdk";
export const schema = {
crew: z
.string()
.min(1, "Staff title is required")
.describe("The crew to get completion fee for"),
startDate: z
.string()
.min(1, "Begin date is required")
.describe("Begin date for the evaluation interval (YYYY-MM-DD)"),
endDate: z
.string()
.min(1, "Finish date is required")
.describe("Finish date for the evaluation interval (YYYY-MM-DD)"),
};
export const metadata: ToolMetadata = {
title: "get-completion-rate",
description: "Get completion fee analytics for a particular crew over a date vary",
};
export default async perform getCompletionRate({
crew,
startDate,
endDate,
}: InferSchema) {
// API Key from headers
const apiKey = headers()["linear-api-key"] as string;
if (!apiKey) {
return "No linear-api-key header supplied";
}
const linear = new LinearClient({
apiKey: apiKey,
});
// Get the crew by title
const groups = await linear.groups();
const targetTeam = groups.nodes.discover(t => t.title.toLowerCase().contains(crew.toLowerCase()));
if (!targetTeam) {
return `Staff "${crew}" not discovered`
}
// Get points created within the date vary for the crew
const createdIssues = await linear.points({
filter: {
crew: { id: { eq: targetTeam.id } },
createdAt: {
gte: startDate,
lte: endDate,
},
},
});
// Get points accomplished within the date vary for the crew (for reporting functions)
const completedIssues = await linear.points({
filter: {
crew: { id: { eq: targetTeam.id } },
completedAt: {
gte: startDate,
lte: endDate,
},
},
});
// Calculate completion fee: proportion of created points that had been accomplished
const totalCreated = createdIssues.nodes.size;
const createdAndCompleted = createdIssues.nodes.filter(concern =>
concern.completedAt !== undefined &&
concern.completedAt >= new Date(startDate) &&
concern.completedAt <= new Date(endDate)
).size;
const completionRate = totalCreated > 0 ? (createdAndCompleted / totalCreated * 100).toFixed(1) : "0.0";
// Construction information for the response
const analytics = {
crew: targetTeam.title,
interval: `${startDate} to ${endDate}`,
totalCreated,
totalCompletedFromCreated: createdAndCompleted,
completionRate: `${completionRate}%`,
createdIssues: createdIssues.nodes.map(concern => ({
title: concern.title,
createdAt: concern.createdAt,
precedence: concern.precedence,
accomplished: concern.completedAt !== null,
completedAt: concern.completedAt,
})),
allCompletedInPeriod: completedIssues.nodes.map(concern => ({
title: concern.title,
completedAt: concern.completedAt,
precedence: concern.precedence,
})),
};
return JSON.stringify(analytics, null, 2);
} Let’s try it out!
Begin your growth server by operating pnpm dev (or the package deal supervisor you’ve arrange)
The server will robotically restart everytime you make modifications to your instruments, supplying you with prompt suggestions throughout growth. Then, head to Cursor Settings → Instruments & Integrations and toggle the server on. It’s best to see it’s discovering one software file, which is our solely file within the listing.
Let’s now use the software by querying to “Get the completion fee of the xmcp undertaking between August 1st 2025 and August twentieth 2025”.
Let’s strive utilizing this software in a extra complete approach: we wish to perceive the undertaking’s completion fee in three separate months, June, July and August, and visualize the tendency. So we are going to ask Cursor to retrieve the data for these months, and generate an inclination chart and a month-to-month concern overview:
As soon as we’re proud of the implementation, we’ll push our modifications and deploy a brand new model of our server.
Professional tip: use Vercel’s department deployments to check new instruments safely earlier than merging to manufacturing.
Subsequent steps
Good! We’ve constructed the muse, however there’s a lot extra you are able to do with it.
- Increase your MCP toolkit with an entire workflow automation. Take this MCP server as a place to begin and add instruments that generate weekly dash experiences and robotically save them to Notion, or construct integrations that join a number of undertaking administration platforms.
- Leverage the applying by including authentication. You should use the OAuth native supplier so as to add Linear’s authentication as an alternative of utilizing API Keys, or use the Higher Auth integration to deal with {custom} authentication paths that suit your group’s safety necessities.
- For manufacturing workloads, chances are you’ll want so as to add {custom} middlewares, like fee limiting, request logging, and error monitoring. This may be simply arrange by making a
middleware.tsfile within the supply listing. You may study extra about middlewares right here.
Ultimate ideas
The perfect a part of what you’ve constructed right here is that xmcp dealt with all of the protocol complexity for you. You didn’t should study the intricacies of the Mannequin Context Protocol specification or work out transport layers: you simply centered on fixing your precise enterprise drawback. That’s precisely the way it needs to be.
Trying forward, xmcp’s roadmap contains full MCP specification compliance, bringing assist for sources, prompts and elicitation. Extra importantly, the framework is evolving to bridge the hole between prototype and manufacturing, with enterprise-grade options for authentication, monitoring, and scalability.
For those who want to study extra in regards to the framework, go to xmcp.dev, learn the documentation and take a look at the examples!
