How do I use mcp-blanko?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-blanko use hello-world to greet John" 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.

mcp-blanko

by KI4JLU

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

mcp-blanko

A template for building your own MCP (Model Context Protocol) server in TypeScript.

Includes placeholder tools, dual transport support (stdio + SSE), and a simple pattern for adding your own tools.

Quick Start

npm install
npm run build
npm start

Related MCP server: TypeScript MCP Server Boilerplate

Project Structure

src/
├── index.ts          # Entry point — transport selection
├── server.ts         # Server setup & tool registration
└── tools/
    ├── hello-world.ts      # Simple greeting tool
    ├── complex-input.ts    # Rich input schema with error handling
    ├── async-operation.ts  # Simulated long-running task
    ├── external-api.ts     # Placeholder for API integration
    └── file-operation.ts   # Local file read/write

Adding Your Own Tool

Create a new file in src/tools/:

import { z } from "zod";
import type { ToolDefinition } from "../server.js";

export const myTool: ToolDefinition = {
  name: "my_tool",
  description: "What this tool does",
  inputSchema: z.object({
    param: z.string().describe("Description of param"),
  }),
  handler: async ({ param }) => {
    return {
      content: [{ type: "text", text: `Result: ${param}` }],
    };
  },
};

import { myTool } from "./tools/my-tool.js";

const tools: ToolDefinition[] = [
  // ... existing tools
  myTool,
];

Build and run:

npm run build && npm start

Transport Modes

stdio (default)

npm start
# or
npm run start:stdio

SSE (HTTP)

npm run start:sse
# or
MCP_PORT=3001 node dist/index.js --transport=sse

The SSE endpoint will be available at http://localhost:3001/sse.

Configuration

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "mcp-blanko": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-blanko/dist/index.js"]
    }
  }
}

Claude Code

claude mcp add mcp-blanko node /absolute/path/to/mcp-blanko/dist/index.js

Docker Deployment

Build and run with Docker Compose:

docker compose up -d

The SSE endpoint will be available at http://localhost:3001/sse. Put a reverse proxy (e.g., nginx, Caddy, Traefik) in front for HTTPS.

Or build and run manually:

docker build -t mcp-blanko .
docker run -d -p 3001:3001 mcp-blanko

Environment Variables

Variable	Default	Description
`MCP_TRANSPORT`	`stdio`	Transport mode: `stdio` or `sse`
`MCP_PORT`	`3001`	HTTP port for SSE transport
`MCP_FILES_DIR`	`cwd`	Base directory for the file operation tool

License

MIT

Available Tools

5 tools

fetch_dataD

Placeholder for a tool that calls an external API. Replace the handler with your own API logic.

ParametersJSON Schema

Name	Required	Description	Default
`method`	No	HTTP method	GET
`endpoint`	Yes	API endpoint path (e.g., /users/123)

TDQS

D1.6/5.0

Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses no behavioral traits. As a placeholder, it doesn't mention side effects, authentication needs, or other important behaviors. No annotations exist to compensate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short but lacks substance. It is concise only because it is a placeholder, not because it efficiently conveys useful information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is insufficient for real use. It provides no details about return values, error handling, or any context beyond being a template. The tool is not operational as defined.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema coverage is 100%, the description adds no meaning beyond the schema's parameter descriptions. It doesn't explain how parameters affect the API call.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description is vague, stating it's a placeholder for an API call. It doesn't specify what resource or action it performs, nor does it distinguish from sibling tools like manage_file or process_order.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines1/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. The description fails to provide any context about appropriate usage scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

hello_worldA

A simple greeting tool. Takes a name and returns a personalized greeting.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes	The name to greet

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions returning a personalized greeting but does not specify the format or any side effects. For such a simple tool, this is minimally adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the purpose, no unnecessary words, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one parameter, no annotations, no output schema), the description is mostly complete but lacks detail on the return format (e.g., 'Hello, {name}!'). This is a minor gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with one parameter described. The description merely restates that it takes a name, adding no new meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it is a greeting tool that takes a name and returns a personalized greeting, which is a specific verb+resource pattern and distinguishes it from siblings like fetch_data or process_order.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use or not use this tool versus alternatives. It is implied by the simple greeting context, but the description lacks any conditional or comparative language.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

long_running_taskC

Demonstrates an async tool that simulates a long-running operation (e.g., data processing, report generation).

ParametersJSON Schema

Name	Required	Description	Default
`taskName`	Yes	Name of the task to run
`durationMs`	No	Simulated duration in milliseconds (100-5000)

TDQS

C2.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It only mentions 'async' and 'simulates', but does not disclose idempotency, result format, error behavior, or side effects, leaving critical gaps for an agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with no redundancy. It front-loads the key concept of being async and long-running. However, it could be slightly more structured to include usage hints.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, no annotations, and the need for an agent to understand invocation context, the description fails to explain return values, errors, or expected behavior, making it incomplete for reliable tool selection.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with 'taskName' and 'durationMs' documented. The description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states it simulates a long-running operation with examples (data processing, report generation), but does not clearly differentiate from siblings like 'process_order' or 'fetch_data', which may also be long-running or async.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like 'fetch_data', 'process_order', or 'manage_file'. The agent is left to infer its purpose without comparative context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_fileA

Demonstrates reading and writing local files. Operates within a configurable base directory.

ParametersJSON Schema

Name	Required	Description
`action`	Yes	Whether to read or write
`content`	No	Content to write (required for write action)
`filePath`	Yes	Relative file path within the working directory

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries full behavioral disclosure. It mentions the base directory constraint but omits important details like error handling, overwrite behavior, or file creation permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences with no redundancy. Critical information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a simple tool with 3 fully documented parameters and no output schema, the description covers the core function and key constraint. Minor gap in error behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the description adds value by clarifying relative paths via 'base directory' but does not exceed the schema's explanations.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool reads and writes local files and specifies a key constraint (configurable base directory). It distinguishes from sibling tools like fetch_data or process_order by focusing on file operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for file read/write but provides no explicit guidance on when to use this tool versus siblings, nor any conditions for avoidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

process_orderD

Demonstrates a tool with a rich input schema: nested objects, enums, optional fields, and error handling.

ParametersJSON Schema

Name	Required	Description	Default
`items`	Yes	List of items to order
`notes`	No	Optional order notes
`customer`	Yes
`priority`	No	Order priority level	normal

TDQS

D1.5/5.0

Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, and the description discloses no behavioral traits. It does not mention side effects (e.g., order creation), authorization needs, rate limits, or error behavior, despite the description claiming 'error handling' exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is not concise because it wastes space on meta-description rather than tool purpose. It is under-specified and does not earn its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (nested objects, enums, no output schema), the description is completely inadequate. It fails to explain what the tool returns, how errors are handled, or any behavior beyond the raw parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds no meaning beyond the input schema. While 3 of 4 parameters have schema descriptions, the missing 'customer' parameter description is not compensated. The meta-commentary does not clarify parameter usage or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose1/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description is a meta-commentary about the input schema, not the tool's actual purpose. It says 'Demonstrates a tool with a rich input schema' without indicating what the tool does (e.g., creates an order). This is misleading and fails to convey the core function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool vs alternatives like 'fetch_data' or 'manage_file'. The description lacks any context about typical use cases or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.7/5.0

Disambiguation4/5

Each tool has a distinct purpose (API call, greeting, async task, file management, order processing), so there is little risk of confusion. However, 'fetch_data' is vaguely named and could overlap with 'long_running_task' in concept.

Naming Consistency5/5

All tool names use lowercase with underscores, following a consistent pattern. The names are descriptive and predictable.

Tool Count4/5

With 5 tools, the count is reasonable for a small demonstration server. It is slightly below the typical 3-15 range for a focused domain, but acceptable for a placeholder set.

Completeness2/5

The tools are unrelated demonstrations covering disparate domains (API, greeting, file I/O, order processing). There is no coherent domain, so coverage is severely incomplete for any real-world use case.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

smithery-ai-cookbook-ts-smithery-cli
ai.smithery
A simple Typescript MCP server built using the official MCP Typescript SDK and smithery/cli. This…
Developer Tools
213
slhad-aha-mcp
ai.smithery
A TypeScript MCP server for Home Assistant, enabling programmatic management of entities, automati…
Home Automation & IoT App Automation
2
anirbanbasu-pymcpOAuth
ai.smithery
Primarily to be used as a template repository for developing MCP servers with FastMCP in Python, P…
Developer Tools
28
devbrother2024-typescript-mcp-server-boilerplateOAuth
ai.smithery
Kickstart development with a customizable TypeScript template featuring sample tools for greeting,…
Developer Tools Code Execution Coding Agents
22

Related MCP Servers

MCP Template
Developer Tools
VitorKaeZ
A
license
Not graded
quality
B
maintenance
A production-ready Model Context Protocol server template in TypeScript that enables building MCP servers with dynamic tool registration, dual transport (stdio + HTTP), and pluggable authentication.
Updated 3 days ago (2026-09-01 11:12 UTC)
15
MIT
TypeScript MCP Server
Developer Tools
devbrother2024
F
license
Not graded
quality
D
maintenance
Provides a starting template for building MCP servers with TypeScript, including examples of tools and resources to accelerate development.
Updated 7 months ago (2026-02-12 07:49 UTC)
MCP Starter Kit
Developer Tools
iamdipanshusingh
A
license
Not graded
quality
D
maintenance
A minimal TypeScript MCP server template with example tool, Zod validation, stdio transport, and dotenv setup.
Updated 6 months ago (2026-03-07 18:47 UTC)
37
MIT
mcp-blanko
Developer Tools
StenSeegel
F
license
C
quality
D
maintenance
A TypeScript template for building MCP servers with placeholder tools and dual transport support (stdio + SSE).
Updated 2 months ago (2026-06-29 07:14 UTC)
5

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/KI4JLU/mcp-template'

If you have feedback or need assistance with the MCP directory API, please join our Discord server