MCP Personal Tools Server
The MCP Personal Tools Server is a Node.js-based API that enables user management and note-taking through three core functionalities:
Fetch user details: Retrieve user profiles from a JSON database using the
user-detailsresourceCreate users: Add new users to the database with the
create-usertool, specifying parameters like name, email, address, phone, and passwordAdd notes: Append text as new lines to a local notes file using the
add-notetool
Provides a note-taking tool that enables appending timestamped text entries to a local notes file stored in the user's Documents directory.
Serves as the runtime environment for the MCP server, required to run the personal tools server.
Used for package management and running server commands for the MCP personal tools server.
Used as the programming language for implementing the MCP server and custom tools.
Provides schema validation for defining tool parameters and ensuring proper data typing in the MCP server.
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 Personal Tools Serveradd a note to remember to call the dentist tomorrow"
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 Demo Server
This project is a demonstration server for the Model Context Protocol (MCP). It provides a set of resources and tools to interact with a simple user database.
Architecture
mcp/
├───.gitignore
├───package-lock.json
├───package.json
├───tsconfig.json
├───.git/...
├───build/
│ └───data/...
└───src/
├───server.ts
└───data/
└───users.jsonThe server is built with Node.js and TypeScript, using the @modelcontextprotocol/sdk. It communicates over standard I/O using a StdioServerTransport.
The server exposes the following:
Resources:
user-details: Fetches user profiles from a JSON file.
Tools:
create-user: Creates a new user in the JSON database.add-note: Adds a note to a local file in the user's documents directory.
Related MCP server: Agent Construct
Installation
Clone the repository.
Install the dependencies:
npm installBuild the server:
npm run server:build
Usage
To start the server, run:
npm startFor development, you can use:
npm run server:devThis will start the server with tsx for automatic recompilation.
Available Scripts
npm start: Starts the production server.npm run server:dev: Starts the development server.npm run server:build: Compiles the TypeScript code.npm run server:build:watch: Compiles the TypeScript code in watch mode.npm run server:inspect: Inspects the server using the MCP Inspector.
Resources
user-details
Description: Get a user's details from the database.
URI:
users://{userId}/profileMIME Type:
application/json
Tools
create-user
Description: Create a new user in the database.
Parameters:
name(string)email(string)address(string)phone(string)password(string)
add-note
Description: Adds a new line to the notes file.
Parameters:
text(string): The text to add to the notes file.
Available Tools
2 toolsadd-noteB
Ajoute une nouvelle ligne au fichier de notes
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Le texte à ajouter au fichier de notes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds minimal behavioral context beyond what annotations provide. Annotations already indicate this is a write operation (readOnlyHint: false), non-destructive, non-idempotent, and open-world. The description confirms it adds content but doesn't disclose important behavioral details like file location, format, permissions needed, or error conditions. No contradiction with annotations exists.
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, clear sentence that efficiently communicates the core purpose. There's no wasted language or unnecessary elaboration. It's appropriately sized for a simple tool with one parameter and good annotation coverage.
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?
For a simple write operation with good annotation coverage and a fully documented single parameter, the description is minimally adequate. However, without an output schema, the description doesn't explain what happens after adding the note (success confirmation, error handling, or return values). The annotations help but don't fully compensate for missing behavioral details in the description.
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?
With 100% schema description coverage, the input schema already fully documents the single 'text' parameter. The description doesn't add any additional meaning about parameters beyond what's in the schema. It mentions adding a line to a notes file, which aligns with the parameter purpose, but provides no extra semantic context about parameter usage or constraints.
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 action ('Ajoute' - adds) and resource ('une nouvelle ligne au fichier de notes' - a new line to the notes file). It specifies what gets added (a line) and where (to the notes file), which is specific and actionable. However, it doesn't explicitly distinguish this from the sibling 'create-user' tool, which is a different operation entirely.
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 prerequisites, constraints, or appropriate contexts for adding notes. There's no indication of when this tool should be preferred over other note-related operations (though none are listed as siblings beyond 'create-user').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create-userB
Create a new user in the database
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| Yes | |||
| address | Yes | ||
| phone | Yes | ||
| password | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide key behavioral hints: readOnlyHint=false (write operation), openWorldHint=true (can create new entities), idempotentHint=false (not repeatable), destructiveHint=false (safe). The description adds no additional behavioral context beyond confirming it's a creation operation, which aligns with annotations but doesn't elaborate on permissions, side effects, or error handling.
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, direct sentence with no wasted words. It is appropriately sized and front-loaded, efficiently conveying the core purpose without unnecessary elaboration.
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?
For a write operation with 5 required parameters, 0% schema coverage, and no output schema, the description is inadequate. It lacks parameter explanations, usage context, and behavioral details beyond basic creation, failing to provide the completeness needed for effective tool invocation.
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?
Schema description coverage is 0%, so parameters are undocumented in the schema. The description provides no information about what the parameters mean, their constraints, or how they interact. It fails to compensate for the lack of schema documentation, leaving semantics unclear.
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 verb ('Create') and resource ('new user in the database'), making the purpose immediately understandable. However, it does not differentiate from the sibling tool 'add-note', which appears unrelated but could potentially overlap in some contexts without explicit 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 alternatives, prerequisites, or exclusions. It simply states what the tool does without context for selection, leaving the agent to infer usage based on the tool name alone.
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.
2 tool updates
- First observed
add-note - First observed
create-user
TDQS
The two tools have completely distinct purposes: one handles file-based note-taking (add-note), while the other manages database users (create-user). There is no overlap or ambiguity between these functions, making it easy for an agent to select the correct tool.
The naming is inconsistent: add-note uses a verb-object pattern with a hyphen, while create-user uses a verb-object pattern with a hyphen but differs in verb choice (add vs. create). Although both use hyphens, the verb inconsistency and lack of a clear naming convention (e.g., all using the same verb style) reduce predictability.
With only 2 tools, the server feels severely under-scoped for a 'Personal Tools Server' that implies a broader utility set. This minimal count suggests incomplete coverage of personal tooling needs, such as missing operations for notes (e.g., read, delete) or users (e.g., get, update).
The tool surface has significant gaps. For notes, there is only an 'add' operation without read, update, or delete capabilities. For users, only 'create' is provided, lacking get, update, delete, or list functions. This incomplete coverage will likely cause agent failures when trying to perform common 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
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Google Keep-style notes app with an MCP server for AI agents to read/write notes.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Related MCP Servers
- FlicenseBqualityDmaintenanceA simple server for saving, listing, and searching notes persisted to a local JSON file. It enables users to manage their personal notes using natural language via the Model Context Protocol.3-
- AlicenseNot gradedqualityDmaintenanceModel Context Protocol server that standardizes tool discovery, execution, and context management for AI applications.MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for AI agents to read, write, and organize notes in a local-first, human-in-the-loop note-taking app.62MIT
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol server for managing text notes, with resources (note:// URIs), tools (create_note), and prompts (summarize_notes).-
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/Myk3rinos/MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server