Add basic-server-* examples for Vue, Svelte, Preact, and Solid (#141)

* Add basic-server-vue example

Demonstrates MCP App SDK usage with Vue 3, providing framework
parity alongside the existing React and vanilla JS examples.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add basic-server-svelte example

Demonstrates MCP App SDK usage with Svelte, providing parity
with the existing basic-server-react and basic-server-vue examples.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add basic-server-preact example

Demonstrates MCP App SDK usage with Preact, providing another
lightweight framework option alongside the existing React, Vue,
and Svelte examples.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add basic-server-solid example

Demonstrates MCP App SDK usage with Solid.js, providing another
reactive framework option alongside the existing React, Vue,
Svelte, and Preact examples.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Add framework GitHub links to README

Link each framework name to its official GitHub repo in basic examples
list.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Jonathan Hefner 2026-01-08 12:44:36 -06:00 • committed by GitHub
commit 8acec0eaad
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 3115 additions and 963 deletions

View file

@ -0,0 +1,188 @@
<script setup lang="ts">
import { ref, onMounted } from "vue";
import { App, type McpUiHostContext } from "@modelcontextprotocol/ext-apps";
import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
const log = {
info: console.log.bind(console, "[APP]"),
warn: console.warn.bind(console, "[APP]"),
error: console.error.bind(console, "[APP]"),
};
function extractTime(result: CallToolResult): string {
const { text } = result.content?.find((c) => c.type === "text")!;
return text;
}
const app = ref<App | null>(null);
const hostContext = ref<McpUiHostContext | undefined>();
const serverTime = ref("Loading...");
const messageText = ref("This is message text.");
const logText = ref("This is log text.");
const linkUrl = ref("https://modelcontextprotocol.io/");
onMounted(async () => {
const instance = new App({ name: "Get Time App", version: "1.0.0" });
instance.ontoolinput = (params) => {
log.info("Received tool call input:", params);
};
instance.ontoolresult = (result) => {
log.info("Received tool call result:", result);
serverTime.value = extractTime(result);
};
instance.onerror = log.error;
instance.onhostcontextchanged = (params) => {
hostContext.value = { ...hostContext.value, ...params };
};
await instance.connect();
app.value = instance;
hostContext.value = instance.getHostContext();
});
async function handleGetTime() {
if (!app.value) return;
try {
log.info("Calling get-time tool...");
const result = await app.value.callServerTool({ name: "get-time", arguments: {} });
log.info("get-time result:", result);
serverTime.value = extractTime(result);
} catch (e) {
log.error(e);
serverTime.value = "[ERROR]";
}
}
async function handleSendMessage() {
if (!app.value) return;
const signal = AbortSignal.timeout(5000);
try {
log.info("Sending message text to Host:", messageText.value);
const { isError } = await app.value.sendMessage(
{ role: "user", content: [{ type: "text", text: messageText.value }] },
{ signal },
);
log.info("Message", isError ? "rejected" : "accepted");
} catch (e) {
log.error("Message send error:", signal.aborted ? "timed out" : e);
}
}
async function handleSendLog() {
if (!app.value) return;
log.info("Sending log text to Host:", logText.value);
await app.value.sendLog({ level: "info", data: logText.value });
}
async function handleOpenLink() {
if (!app.value) return;
log.info("Sending open link request to Host:", linkUrl.value);
const { isError } = await app.value.openLink({ url: linkUrl.value });
log.info("Open link request", isError ? "rejected" : "accepted");
}
</script>
<template>
<main
class="main"
:style="hostContext?.safeAreaInsets && {
paddingTop: hostContext.safeAreaInsets.top + 'px',
paddingRight: hostContext.safeAreaInsets.right + 'px',
paddingBottom: hostContext.safeAreaInsets.bottom + 'px',
paddingLeft: hostContext.safeAreaInsets.left + 'px',
}"
>
<p class="notice">Watch activity in the DevTools console!</p>
<div class="action">
<p><strong>Server Time:</strong> <code id="server-time">{{ serverTime }}</code></p>
<button @click="handleGetTime">Get Server Time</button>
</div>
<div class="action">
<textarea v-model="messageText"></textarea>
<button @click="handleSendMessage">Send Message</button>
</div>
<div class="action">
<input type="text" v-model="logText">
<button @click="handleSendLog">Send Log</button>
</div>
<div class="action">
<input type="url" v-model="linkUrl">
<button @click="handleOpenLink">Open Link</button>
</div>
</main>
</template>
<style scoped>
.main {
--color-primary: #2563eb;
--color-primary-hover: #1d4ed8;
--color-notice-bg: #eff6ff;
width: 100%;
max-width: 425px;
box-sizing: border-box;
> * {
margin-top: 0;
margin-bottom: 0;
}
> * + * {
margin-top: 1.5rem;
}
}
.action {
> * {
margin-top: 0;
margin-bottom: 0;
width: 100%;
}
> * + * {
margin-top: 0.5rem;
}
textarea,
input {
font-family: inherit;
font-size: inherit;
}
button {
padding: 0.5rem 1rem;
border: none;
border-radius: 6px;
color: white;
font-weight: bold;
background-color: var(--color-primary);
cursor: pointer;
&:hover,
&:focus-visible {
background-color: var(--color-primary-hover);
}
}
}
.notice {
padding: 0.5rem 0.75rem;
color: var(--color-primary);
text-align: center;
font-style: italic;
background-color: var(--color-notice-bg);
&::before {
content: "ℹ️ ";
font-style: normal;
}
}
</style>

View file

@ -0,0 +1,12 @@
* {
box-sizing: border-box;
}
html, body {
font-family: system-ui, -apple-system, sans-serif;
font-size: 1rem;
}
code {
font-size: 1em;
}

View file

@ -0,0 +1,5 @@
import { createApp } from "vue";
import App from "./App.vue";
import "./global.css";
createApp(App).mount("#app");

View file

@ -0,0 +1,110 @@
/**
* Shared utilities for running MCP servers with various transports.
*/
import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import cors from "cors";
import type { Request, Response } from "express";
/**
* Starts an MCP server using the appropriate transport based on command-line arguments.
*
* If `--stdio` is passed, uses stdio transport. Otherwise, uses Streamable HTTP transport.
*
* @param createServer - Factory function that creates a new McpServer instance.
*/
export async function startServer(
createServer: () => McpServer,
): Promise<void> {
try {
if (process.argv.includes("--stdio")) {
await startStdioServer(createServer);
} else {
await startStreamableHttpServer(createServer);
}
} catch (e) {
console.error(e);
process.exit(1);
}
}
/**
* Starts an MCP server with stdio transport.
*
* @param createServer - Factory function that creates a new McpServer instance.
*/
export async function startStdioServer(
createServer: () => McpServer,
): Promise<void> {
await createServer().connect(new StdioServerTransport());
}
/**
* Starts an MCP server with Streamable HTTP transport in stateless mode.
*
* Each request creates a fresh server and transport instance, which are
* closed when the response ends (no session tracking).
*
* The server listens on the port specified by the PORT environment variable,
* defaulting to 3001 if not set.
*
* @param createServer - Factory function that creates a new McpServer instance per request.
*/
export async function startStreamableHttpServer(
createServer: () => McpServer,
): Promise<void> {
const port = parseInt(process.env.PORT ?? "3001", 10);
// Express app - bind to all interfaces for development/testing
const expressApp = createMcpExpressApp({ host: "0.0.0.0" });
expressApp.use(cors());
expressApp.all("/mcp", async (req: Request, res: Response) => {
// Create fresh server and transport for each request (stateless mode)
const server = createServer();
const transport = new StreamableHTTPServerTransport({
sessionIdGenerator: undefined,
});
// Clean up when response ends
res.on("close", () => {
transport.close().catch(() => {});
server.close().catch(() => {});
});
try {
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
} catch (error) {
console.error("MCP error:", error);
if (!res.headersSent) {
res.status(500).json({
jsonrpc: "2.0",
error: { code: -32603, message: "Internal server error" },
id: null,
});
}
}
});
const { promise, resolve, reject } = Promise.withResolvers<void>();
const httpServer = expressApp.listen(port, (err?: Error) => {
if (err) return reject(err);
console.log(`Server listening on http://localhost:${port}/mcp`);
resolve();
});
const shutdown = () => {
console.log("\nShutting down...");
httpServer.close(() => process.exit(0));
};
process.on("SIGINT", shutdown);
process.on("SIGTERM", shutdown);
return promise;
}