How to Build MCP Servers with Deno

An MCP server implements the Model Context Protocol, a streaming protocol for AI agent tools. It handles requests like tool discovery, execution, and state management.

Fastio runs a remote MCP server at https://mcp.fast.io/mcp with a consolidated toolset for file storage and collaboration. Building your own lets you expose custom tools securely.

Key features include:

• Streamable HTTP at /mcp
• SSE fallback at /sse
• Session state for auth tokens
• Dynamic resource listing for files

Deno fits perfectly. It runs TypeScript natively and bundles to a single executable binary. Permissions like --deny-net protect against malicious agents.

Helpful references: Fastio Workspaces, Fastio Collaboration, and Fastio AI.

• How to Build MCP Servers with .NET: A C# Developer's GuideBuilding MCP servers in .NET allows enterprise developers to expose existing business logic and data layers to AI...
• How to Build Stateful MCP Servers for Long-Running AgentsMost Model Context Protocol (MCP) servers are stateless, causing agents to forget everything between sessions. This...
• How to Build MCP Servers with Python: Best PracticesThe Model Context Protocol (MCP) gives AI agents a standard way to connect to external data and tools. This guide walks...
• How to Build a Fastio MCP Client in SwiftBuilding a Fastio MCP client in Swift requires establishing an SSE or HTTP connection to the Fastio MCP server to...
• How to Build a Fastio MCP Client in GolangGuide to building fastio mcp client golang: A Fastio MCP client in Golang uses Go's native concurrency model to...
• How to Build Agent Swarms with MCP ServersMulti-agent swarms are transforming how engineering teams automate complex workflows. However, orchestrating multiple...

More on this subject: MCP and Model Context Protocol (195 guides)

Deno emphasizes security for untrusted code, ideal for agent tools.

Advantages:

• Built-in TypeScript support, no config needed
• Permission flags (--allow-net, --deny-all) for fine-grained control
• Bundles to single binary with deno compile
• Fast runtime with V8 isolates
• Native HTTP server APIs

Compared to Node.js, Deno avoids npm vulnerabilities and package.json hell.

Ready for Agentic Workspaces?

Build custom MCP tools or connect to Fastio's hosted MCP server with a consolidated toolset. Perfect for Deno developers building agent workflows.

Explore Fastio MCP

Install Deno 2.0+:

curl -fsSL https://deno.land/install.sh | sh

Verify:

deno --version

Create project:

mkdir mcp-server-deno
cd mcp-server-deno
deno init

Fresh provides file-based routing and islands for agent UIs.

Add Fresh:

deno add @fresh/core @preact/signals-react fresh

main.ts:

import manifest from "./fresh.gen.ts";

import { start } from "@fresh/server";
import { type Plugin } from "$fresh/server.ts";

const plugins: Plugin[] = [];

await start(manifest, { plugins });

routes/api/mcp.ts for MCP endpoint.

Create /api/mcp POST handler for streamable calls.

Example handler:

import { HandlerContext } from "$fresh/server.ts";

export const handler = {
  async POST(req: Request, ctx: HandlerContext) {
    const sessionId = ctx.state.sessionId || crypto.randomUUID();
    // Parse MCP request
    const body = await req.json();
    const { tool, action, params } = body;

// Route to tool action
    let result;
    if (tool === "storage") {
      result = await handleStorage(action, params, sessionId);
    } // etc

// Stream response
    const stream = new ReadableStream({
      start(controller) {
        controller.enqueue(JSON.stringify({ result }));
        controller.close();
      }
    });

return new Response(stream, {
      headers: { "Content-Type": "application/json-stream" }
    });
  }
};

Add session state with Deno KV for persistence.

Deno permissions protect against untrusted agents.

Run with:

deno run --allow-net --allow-env --deny-all main.ts

Explicitly allow only needed perms.

In code, validate agent requests:

if (!isTrustedAgent(req.headers.get("User-Agent"))) {
  return new Response("Unauthorized", { status: 401 });
}

Use Deno's secure defaults: no file access unless allowed.

For production, add rate limiting and auth tokens per agent.

Bundle and deploy.

deno.json:

{
  "compilerOptions": {
    "lib": ["deno.unstable"]
  },
  "tasks": {
    "deploy": "deno task start"
  },
  "deploy": "./main.ts"
}

Deploy:

deployctl deploy --project=my-mcp

Flags: --allow-net for HTTP, Deno Deploy handles scaling.

Test with curl:

curl -X POST http://localhost:8000/api/mcp \\
  -H "Content-Type: application/json" \\
  -d '{"tool":"storage","action":"list"}'

works alongside agents using MCP clients.

Define clear tool contracts and fallback behavior so agents fail safely when dependencies are unavailable. This improves reliability in production workflows.