Hono MCP

https://honohub.dev/docs/hono-mcp
Admin
Hono MCP is a library that enables easy deployment of Model Context Protocol servers on Hono,...
Tokens:1,411
Snippets:16
Trust Score:5.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install @hono/mcp

Source: https://honohub.dev/docs/hono-mcp

Commands to install the package using various package managers.

```shell
npm install @hono/mcp
```

```shell
pnpm add @hono/mcp
```

```shell
yarn install @hono/mcp
```

```shell
bun add @hono/mcp
```

--------------------------------

### Create a Hono MCP Server

Source: https://honohub.dev/docs/hono-mcp

Example of setting up a Hono application to serve an MCP server at the /mcp endpoint using StreamableHTTPTransport.

```typescript
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StreamableHTTPTransport } from '@hono/mcp'
import { Hono } from 'hono'

const app = new Hono()

// Your MCP server implementation
const mcpServer = new McpServer({
  name: 'my-mcp-server',
  version: '1.0.0',
})

app.all('/mcp', async (c) => {
  const transport = new StreamableHTTPTransport()
  await mcpServer.connect(transport)
  return transport.handleRequest(c)
})

export default app
```

--------------------------------

### Setup MCP Auth with 3rd Party Provider

Source: https://honohub.dev/docs/hono-mcp/auth/3rd-party

Initializes the Hono application with the simpleMcpAuthRouter using an issuer domain and resource server URL.

```typescript
import { Hono } from 'hono'
import { simpleMcpAuthRouter } from '@hono/mcp'

const app = new Hono()

app.route(
  '/',
  simpleMcpAuthRouter({
    issuer: '[auth provider domain]',
    resourceServerUrl: new URL('http://localhost:3000/mcp'),
  })
)

// ...
// Logic to connect with the transport
```

--------------------------------

### Create a stateless MCP server with Hono

Source: https://honohub.dev/docs/hono-mcp/stateless

Initializes an MCP server using StreamableHTTPTransport to handle requests without maintaining persistent state.

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPTransport } from "@hono/mcp";
import { Hono } from "hono";

const app = new Hono();
const mcpServer = new McpServer({
	name: "my-mcp-server",
	version: "1.0.0",
});

const transport = new StreamableHTTPTransport();

app.all("/mcp", async (c) => {
    if (!mcpServer.isConnected()) {
        // Connecting the MCP server to the transport
        await mcpServer.connect(transport);
    }

    return transport.handleRequest(c);
});

export default app;
```

--------------------------------

### Create a Stateful MCP Server with Hono

Source: https://honohub.dev/docs/hono-mcp/stateful

Uses StreamableHTTPTransport with a custom sessionIdGenerator to link MCP sessions to authenticated users.

```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPTransport } from "@hono/mcp";
import { Hono } from "hono";
import { useAuth } from "@/middleware";

const app = new Hono().use(useAuth());

function createMCPServer(user: User) {
	const mcpServer = new McpServer({
		name: "my-mcp-server",
		version: "1.0.0",
	});

	// ...
    // Add your stateful tools/prompts/resources here
	// ...

	return mcpServer;
}

app.all("/mcp", async (c) => {
	const user = c.get("user");
	const transport = new StreamableHTTPTransport({
		sessionIdGenerator: () => user.id,
	});

	const mcpServer = createMCPServer(user);
	mcpServer.connect(transport);

	return transport.handleRequest(c);
});

export default app;
```

--------------------------------

### Implement Token Authentication in Hono MCP

Source: https://honohub.dev/docs/hono-mcp/auth/token

Uses a custom middleware to validate the Authorization header before processing MCP requests.

```typescript
import { Hono } from "hono";
import { McpServer } from "@hono/mcp";

const app = new Hono();
const mcpServer = new McpServer({
  name: "my-mcp-server",
  version: "1.0.0",
});

// Middleware to verify the token
app.use(async (c, next) => {
  const token = c.req.header("Authorization")?.split(" ")[1];
  if (!token) {
    return c.json({ error: "Unauthorized" }, 401);
  }

  // ...
  // Verify the token
  // ...

  await next();
});

// Route to handle MCP requests
app.all("/mcp", async (c) => {
  const transport = new StreamableHTTPTransport();
  await mcpServer.connect(transport);
  return transport.handleRequest(c);
});

export default app;
```
Tokens:
Raw