mcp-flyin
Provides tools for basic JavaScript operations including echo functionality, arithmetic calculations, and system information retrieval
Enables access to Node.js system information and provides a framework for running server-side JavaScript tools through an MCP interface
Allows access to package configuration through resource retrieval, enabling inspection of npm dependencies and project metadata
Click on "Install 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-flyincalculate 15 plus 7"
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.
My JavaScript MCP Server
A Model Context Protocol (MCP) server built with JavaScript that provides basic tools and resources.
Features
Tools
echo: Echo back any message
calculate: Perform basic arithmetic operations (add, subtract, multiply, divide)
get_system_info: Get basic system information
Resources
package.json: Access to the server's package configuration
Related MCP server: @profullstack/mcp-server
Installation
Make sure you have Node.js installed
Install dependencies:
npm install
Usage
Running the Server
npm startDevelopment Mode
npm run devTesting with MCP Inspector
You can test your server using the MCP Inspector:
npx @modelcontextprotocol/inspector node server.jsConfiguration
This server runs on stdio transport, which means it communicates through standard input/output. This is the most common way to run MCP servers.
Example Usage
Once connected to an MCP client, you can:
Echo a message:
Tool:
echoParameters:
{"message": "Hello, World!"}
Perform calculations:
Tool:
calculateParameters:
{"operation": "add", "a": 5, "b": 3}
Get system information:
Tool:
get_system_infoParameters:
{}
Read resources:
Resource:
file://package.json
Extending the Server
To add new tools or resources:
Add tool definitions to the
ListToolsRequestSchemahandlerAdd tool logic to the
CallToolRequestSchemahandlerAdd resource definitions to the
ListResourcesRequestSchemahandlerAdd resource reading logic to the
ReadResourceRequestSchemahandler
Error Handling
The server includes proper error handling for:
Division by zero in calculations
Unknown tools and resources
File reading errors
Graceful shutdown on SIGINT
Available Tools
3 toolscalculateC
Perform basic arithmetic calculations
| Name | Required | Description | Default |
|---|---|---|---|
| operation | Yes | The arithmetic operation to perform | |
| a | Yes | First number | |
| b | Yes | Second number |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs calculations but doesn't mention any behavioral traits like error handling (e.g., division by zero), performance limits, or output format. This is a significant gap for a tool with potential side effects, scoring a 2 for inadequate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence ('Perform basic arithmetic calculations') that is front-loaded and wastes no words. It directly conveys the core purpose without unnecessary elaboration, earning a 5 for optimal conciseness and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (basic arithmetic with three parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error cases, or behavioral constraints, leaving gaps that could hinder an agent's correct invocation. This scores a 2 for insufficient contextual detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all three parameters (operation, a, b) with enums and descriptions. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for adequate but not enhanced parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Perform basic arithmetic calculations' clearly states the tool's function with a specific verb ('perform') and resource ('calculations'), distinguishing it from siblings like 'echo' and 'get_system_info'. However, it doesn't specify the exact operations (add, subtract, etc.) or differentiate from potential alternative calculation tools, keeping it at a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions, such as when to use it over other calculation methods or tools. This leaves the agent without usage direction, scoring a 2 for minimal guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
echoB
Echo back the input message
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | Message to echo back |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'echoes back' the input, implying a read-only or non-destructive operation, but it doesn't disclose any behavioral traits such as side effects, error handling, or output format. This leaves gaps in understanding how the tool behaves beyond its basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded with 'Echo back the input message', a single sentence that directly conveys the tool's purpose without any wasted words. It's appropriately sized for a simple tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 minimally complete. It states what the tool does but lacks details on usage guidelines, behavioral traits, or output, which could be helpful for an AI agent. However, for such a basic tool, it's adequate but leaves room for improvement in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'message' documented as 'Message to echo back'. The description adds no additional meaning beyond this, as it only repeats the concept of echoing back a message without providing extra context or semantics. This meets the baseline of 3 since the schema adequately covers the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function as 'Echo back the input message', which specifies the verb ('echo back') and resource ('input message'). It's not tautological with the name 'echo' since it adds 'back the input message', but it doesn't differentiate from siblings like 'calculate' or 'get_system_info', which are unrelated tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any specific contexts, prerequisites, or exclusions, and with siblings like 'calculate' and 'get_system_info', there's no indication of when 'echo' is the appropriate choice over those tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_system_infoC
Get basic system information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. 'Get basic system information' implies a read operation but provides no details about what information is returned, format, permissions required, rate limits, or error conditions. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - a single four-word phrase that directly states the tool's purpose. There's zero wasted language, and the information is front-loaded appropriately. This is an excellent example of efficient communication.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a tool that presumably returns system information, the description is insufficient. 'Basic system information' is vague - it doesn't indicate what information is included (CPU, memory, OS, etc.) or the return format. The agent needs more context to understand what to expect from this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters with 100% schema description coverage. The description appropriately doesn't discuss parameters since none exist. This matches the baseline expectation for parameterless tools, though it doesn't add any value beyond what the schema already indicates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get basic system information' clearly states the verb ('Get') and resource ('basic system information'), providing a general purpose. However, it doesn't differentiate from sibling tools like 'calculate' or 'echo' - it's clear what it does but not how it differs from alternatives. The purpose is understandable but lacks sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the sibling tools 'calculate' or 'echo'. There's no mention of appropriate contexts, prerequisites, or alternatives. The agent receives no help in choosing between available tools on this server.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
3 tool updates
- First observed
calculate - First observed
echo - First observed
get_system_info
TDQS
Each tool has a clearly distinct purpose with no overlap: calculate handles arithmetic, echo returns input, and get_system_info retrieves system data. An agent can easily differentiate between these three unrelated functions.
The naming is mostly consistent with a verb-based pattern (calculate, echo, get_system_info), though 'echo' is less descriptive than the others. There are no mixed conventions, making the set readable and predictable.
With only 3 tools, the server feels thin for a general utility purpose like 'mcp-flyin', which might imply broader functionality. While each tool is distinct, the count is borderline low for typical server scopes.
The toolset is severely incomplete for a utility server, lacking common operations like file handling, data transformation, or network requests. It covers only basic arithmetic, echoing, and system info, leaving significant gaps for agent workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
A simple MCP server built with FastMCP and python
Related MCP Servers
- AlicenseCqualityDmaintenanceA simple server implementing the Model Context Protocol (MCP) that echoes messages back, designed for testing MCP clients.12MIT
- AlicenseNot gradedqualityBmaintenanceA generic, modular server for implementing the Model Context Protocol (MCP).8145ISC
- FlicenseNot gradedqualityDmaintenanceA simple MCP server implementation that demonstrates streaming capabilities with tools for greetings and notifications, accessible through an interactive command-line client.1-
- AlicenseNot gradedqualityDmaintenanceAn implementation of the Model Context Protocol (MCP) server that enables multiple clients to connect simultaneously and handles basic context management and messaging with an extendable architecture.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/balajidommeti/MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server