Add 36 Local Developer Utilities to Cursor with an MCP Plugin

If you repeatedly leave Cursor to generate a UUID, decode a JWT, calculate a CIDR range, or format JSON, the problem is not the individual command. The problem is the missing tool boundary inside your coding workflow.

The DevUtils MCP Plugin packages a local MCP server for Cursor and Claude Code. It exposes 36 small developer utilities for hashing, encoding, JSON, JWTs, UUIDs, text, and network calculations. The plugin does not require an API key, and its configuration starts the server with npx on your own machine.

This tutorial shows the smallest useful path: install the plugin, inspect the configuration, enable the MCP server, and verify the result with a few safe requests.

TL;DR

Install DevUtils MCP from Cursor's Customize page, enable the devutils server, then ask your agent to generate a UUID or validate JSON. The plugin wrapper is public and MIT licensed. The underlying devutils-mcp-server is currently version 1.1.0 on npm and requires Node.js 18 or newer.

Prerequisites

You need:

• Cursor with plugin and MCP support.
• Node.js 18 or newer available as node and npx in your PATH.
• Permission to download the public npm package the first time the server starts.

The plugin repository itself is public and MIT licensed. The repository's current plugin manifests declare version 1.0.7. The server is a separate package, so keep those two versions distinct.

Install the plugin in Cursor

Cursor documents plugins as bundles that can include MCP servers, rules, skills, agents, commands, and hooks. Its current installation flow is:

1. Open Cursor's Customize page.
2. Find the plugin in the marketplace or use the community plugin flow.
3. Search for DevUtils MCP.
4. Choose Install and select the scope you want.
5. Enable the devutils MCP server in the installed plugin.

The Cursor plugin documentation describes the marketplace and installation flow. If the plugin is not listed in your account yet, the repository README documents the direct Add from GitHub route with paladini/devutils-cursor-plugin.

After installation, reload Cursor if the MCP server does not appear immediately. Then open the MCP section in Customize and confirm that devutils is enabled.

Understand the one-file configuration

The repository's current mcp.json contains this exact server definition:

{
  "mcpServers": {
    "devutils": {
      "command": "npx",
      "args": ["-y", "devutils-mcp-server"]
    }
  }
}

There are two useful details here. First, npx -y can install the named package when it is not already available locally. Second, the server is a stdio process. Cursor starts it and communicates with it through the MCP protocol; you do not need to expose an HTTP port or copy an API key into a configuration file.

The MCP server repository is the primary source for the tool catalog and server implementation. The plugin is a distribution wrapper that makes the configuration discoverable from Cursor and Claude Code.

Try the minimal workflow

Once the server is enabled, ask your agent for a small operation whose input is not sensitive. For example:

Generate a UUID v4 with the DevUtils MCP server.

Then try a deterministic transformation:

Pretty-print this JSON and validate it with DevUtils:
{"project":"demo","enabled":true}

You can also ask for a calculation:

Calculate the network details for 10.0.0.0/24 with DevUtils.

The expected result is an agent response backed by a named DevUtils tool. The exact UUID value changes on every generation. For the JSON request, you should see formatted JSON and a valid result. For the CIDR request, expect the network address, broadcast address, host range, and host count.

The server also exposes tools for SHA hashing, Base64 and hexadecimal conversion, JWT decoding, date and timestamp conversion, regex checks, text statistics, URL encoding, and other small operations. The available-tools section in the server README is the authoritative catalog, so check it before writing prompts that depend on a particular name.

Verify the process without Cursor

The plugin is optional. Any MCP client that accepts a stdio server can use the same package directly:

npx -y devutils-mcp-server

This command is a long-running server process, not a traditional command that prints a result and exits. A successful startup keeps the process attached to stdio. Stop it with Ctrl+C when testing manually.

In my validation of the current package, npm view devutils-mcp-server version license engines returned version 1.1.0, MIT licensing, and the Node.js engine requirement >=18. Starting the package with npx -y devutils-mcp-server --help reached the server and reported DevUtils MCP Server running on stdio; because it is a server, the process needed to be stopped after startup. That verifies launch, not every individual tool.

Why this setup works

The plugin separates distribution from execution. The repository contributes manifests, the MCP configuration, documentation, and privacy and security policies. The npm package contributes the executable server and tool handlers. Cursor only needs to understand the MCP entry in mcp.json.

That separation also keeps the example portable. Claude Code can install the plugin with its marketplace command, while another MCP client can run the npm package directly. The configuration remains a small, reviewable JSON file rather than a collection of copied shell commands.

Failure modes and boundaries

If the server does not appear in Cursor, check the plugin scope, reload Cursor, and confirm that npx resolves in the environment used by the editor. If startup fails, run node --version and npx --version in a terminal, then check whether npm can reach the registry.

If a request fails, verify the tool exists in the current server README. The plugin repository says 36 utilities, but the server package is independently versioned and can change. Do not assume a tool name from an old prompt or screenshot.

Local execution is not the same as a security guarantee. Inputs are processed by the local server according to the implementation, but npx still downloads a package from npm on first use. Review the package, lock down your normal npm trust controls, and avoid sending production secrets, private tokens, or customer data to any tool until you have reviewed its source and behavior. JWT decoding is not JWT verification, and hashing does not make a sensitive value safe to disclose.

The plugin does not provide a cloud API, authentication layer, or remote dashboard. It also does not replace a secrets manager, a security scanner, or a full network diagnostic system. Its value is narrow: convenient, repeatable local utilities inside an agent workflow.

FAQ

Does it need an API key?

No API key is required by the plugin or the documented server configuration.

Does it work outside Cursor?

Yes. The plugin README documents direct server usage for other MCP clients, including Claude Code, VS Code, Windsurf, and Docker references.

Does local mean no network activity?

No. The tool operations run in the local server process, but npx may download devutils-mcp-server from npm when it is first run.

Can it verify a JWT signature?

The documented JWT utility decodes and validates token structure and expiration-related information. Treat decoding as inspection, not cryptographic signature verification.

Takeaway

A useful MCP integration does not need to be a large platform. A public manifest, a one-file stdio configuration, and small deterministic tools are enough to remove repetitive context switching from an agent workflow. Install DevUtils when those utilities belong inside your local development loop, and keep the server's version, source, and input boundaries visible to the team.

What small local utility would save you the most context switching inside your coding agent: JSON validation, token inspection, hashing, or something else?

AI assistance disclosure: This tutorial was researched and drafted with AI assistance. Repository files, package metadata, documented commands, and the startup behavior described here were checked against the current public sources before publication.