Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mCP 2.0 create a counter and increment it twice"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A minimal JavaScript demo of three MCP 2026-07-28 patterns with SDK v2:
Stateless MCP vs a stateful app
Multi round-trip requests
Caching
Requires Node.js 20 or newer.
npm install
npm run demoThe command starts a server on an available local port, exercises each scenario, prints the results, and shuts the server down. The deletion example uses an in-memory virtual file set and never touches files on disk.
npm testTo leave the server running for another MCP client:
npm run serverThe endpoint is http://127.0.0.1:3000/mcp. Set PORT to override the port.
Related MCP server: MCP RC Long-Running Task Prototype
MCP 2026-07-28 has no protocol-level HTTP sessions. src/server.js
creates a fresh McpServer for each request:
function createDemoServer(demoFiles) {
const server = new McpServer({ name: "mcp-demo", version: "0.1.0" }, { cacheHints });
registerStateTools(server);
registerConfirmTool(server, demoFiles);
return server;
}
const mcpHandler = createMcpHandler(() => createDemoServer(demoFiles), {
legacy: "reject",
onerror: (error) => console.error("MCP error:", error),
});State stored on that instance disappears when the request ends. Application
state lives outside McpServer in src/state.js and is selected
with an explicit handle:
const countersById = new Map();
export function registerStateTools(server) {
const serverInstance = ++nextServerInstance;
let ephemeral = 0; // dies with this request's McpServer
server.registerTool(
"increment-ephemeral",
{
description: "Increment state held only by this per-request server instance.",
outputSchema: z.object({ value: z.number(), serverInstance: z.number() }),
},
async () => ok({ value: ++ephemeral, serverInstance }),
);
server.registerTool(
"create-counter",
{
description: "Create application state and return its explicit handle.",
outputSchema: z.object({ counterId: z.uuid(), value: z.number() }),
},
async () => {
const counterId = randomUUID();
countersById.set(counterId, 0);
return ok({ counterId, value: 0 });
},
);
}The client carries counterId between otherwise independent calls. Calling
increment-ephemeral twice returns 1 from two different server instances;
calling increment-counter with the same handle returns 1, then 2.
The in-memory Map is only a stand-in. A production server should use a
shared store, bind handles to the authenticated principal, and enforce
authorization on every lookup.
A tool that needs more input returns input_required. The client gathers the
answer and retries the original request with inputResponses. From
src/confirm.js:
const confirmation = acceptedContent(
ctx.mcpReq.inputResponses,
"confirm",
confirmationSchema,
);
if (confirmation === undefined) {
return inputRequired({
inputRequests: {
confirm: inputRequired.elicit({
message: `Delete ${files.length} virtual file${files.length === 1 ? "" : "s"}?`,
requestedSchema: confirmationSchema,
}),
},
});
}The demo client in src/demo.js answers those elicitations and
retries automatically:
client.setRequestHandler("elicitation/create", async (request) => {
const confirm = confirmationAnswers.shift();
elicitationRequests.push({ message: request.params.message, confirm });
return { action: "accept", content: { confirm } };
});Confirmation is user experience, not authorization. The server must still authenticate the caller and independently enforce permission to delete files.
List results carry a freshness lifetime and sharing policy. src/server.js
marks the tool catalog as reusable for five minutes:
const cacheHints = {
"tools/list": { ttlMs: 300_000, cacheScope: "public" },
};
const server = new McpServer({ name: "mcp-demo", version: "0.1.0" }, { cacheHints });The client in src/demo.js uses fresh entries automatically:
await client.listTools();
await client.listTools();
await client.listTools(undefined, { cacheMode: "refresh" });The first call is a network request, the second is a cache hit, and
cacheMode: "refresh" forces a new request.
public allows clients and shared intermediaries to reuse the result across users.
private restricts reuse to the requesting authorization context.
A TTL is a freshness estimate. List-change notifications can invalidate cached catalogs before their TTL expires.
src/server.js Per-request McpServer factory, HTTP, cacheHints
src/state.js Ephemeral instance state vs app counters
src/confirm.js Multi round-trip delete confirmation
src/demo.js Client walkthrough of the three scenarios
src/result.js Tiny ok()/fail() helpers
test/demo.test.js One test per talking pointThe MCP packages are pinned to 2.0.0.
This server cannot be deployed
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
Agentic rails for complex workflows with receipts, fees, and MCP tool access.
Stateless agentic tools over MCP: concept extraction, long-context, knowledge graph, planning.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
