What can you do with this server?

This MCP stdio server gives Claude Code five structured development tools for testing, type-checking, and building projects. * run_e2e_tests: Run Playwright E2E tests, optionally auto-starting the dev server and filtering by test pattern; returns per-test pass/fail status, duration, and error messages. * execute_sql_as_role: Execute SQL as a Postgres role with JWT claims inside a rollback transaction to verify Supabase RLS policies; returns rows without mutating data. * typecheck: Run tsc --noEmit on a project or specific files; returns structured TypeScript errors with file, line, column, code, and message. * npm_run: Run any npm script with extra args/env; parses Vitest/Jest output into structured per-file test results. * nextjs_build: Run a Next.js production build; returns structured errors and a list of generated pages with render types and sizes.

Which integrations are available for this server?

Parses Jest test output into structured results, including per-file pass/fail status and test counts. Runs Next.js production builds and parses output to return structured build errors and a list of pages with their sizes and types. Runs SQL queries as a specified Postgres role with JWT claims, enabling testing of database access control and RLS rules. Executes SQL as a specified Postgres role with JWT claims to verify Supabase Row Level Security policies, without mutating data. Parses Vitest test output into structured results, including per-file pass/fail status and test counts.

How do I use dev-tools?

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., "@dev-tools Run the e2e tests and show me failures" 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.

de en es ja ko ru zh

dev-tools

by briancox730

Overview Schema Related Servers Score Discussions

TypeScript

Local

dev-tools-mcp

License: MIT

An MCP (Model Context Protocol) stdio server that gives Claude Code - or any MCP client - five structured development tools:

#	Tool	What it does
1	`run_e2e_tests`	Runs Playwright tests, starts the dev server, returns pass/fail per test
2	`execute_sql_as_role`	Executes SQL as a Postgres role with JWT claims - verifies Supabase RLS
3	`typecheck`	Runs `tsc --noEmit`, returns structured errors (file, line, code, message)
4	`npm_run`	Runs any npm script, parses Vitest/Jest output into structured results
5	`nextjs_build`	Runs `next build`, returns structured errors + page list with sizes

Prerequisites

Node.js ≥ 18
Claude Code installed
For the RLS tool: psql on your PATH and a running Supabase/Postgres instance

Related MCP server: MCP Quality Hub

Quick start

# 1. Clone the repo
git clone https://github.com/briancox730/dev-tools-mcp.git
cd dev-tools-mcp

# 2. Install dependencies
npm install

# 3. Build
npm run build

# 4. Register with Claude Code (local scope - this project only)
claude mcp add --transport stdio dev-tools -- node /absolute/path/to/dev-tools-mcp/build/index.js

# OR register globally (available in all projects)
claude mcp add --transport stdio --scope user dev-tools -- node /absolute/path/to/dev-tools-mcp/build/index.js

Alternative: edit `.claude.json` directly

Add this to the mcpServers key in ~/.claude.json (global) or .claude.json in your project root:

{
  "mcpServers": {
    "dev-tools": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/dev-tools-mcp/build/index.js"]
    }
  }
}

Then restart Claude Code.

Verify it's working

Inside Claude Code, run /mcp - you should see dev-tools: connected with 5 tools listed.

Tool details

1. `run_e2e_tests` - Playwright E2E runner

Runs Playwright with the JSON reporter and parses results into structured output.

Inputs:

project_dir (required) - absolute path to your project
test_pattern - glob or file path to filter, e.g. "tests/auth.spec.ts"
headed - run in headed mode (default: false)
start_server - use Playwright's webServer config (default: true)
timeout_seconds - kill after this many seconds (default: 120)

What you get back:

{
  "success": true,
  "summary": { "passed": 8, "failed": 1, "skipped": 0, "total": 9 },
  "tests": [
    { "name": "Auth > should redirect unauthenticated users", "status": "passed", "duration_ms": 1200 },
    { "name": "Auth > should show dashboard after login", "status": "failed", "duration_ms": 3400, "error": "Expected element to be visible..." }
  ]
}

Tip: Make sure your playwright.config.ts has a webServer section so Playwright auto-starts your dev server:

export default defineConfig({
  webServer: {
    command: 'npm run dev',
    port: 3000,
    reuseExistingServer: !process.env.CI,
  },
});

2. `execute_sql_as_role` - Supabase RLS tester

Executes SQL as a specific Postgres role with JWT claims, then rolls back. Never mutates data.

Inputs:

connection_string (required) - e.g. "postgresql://postgres:postgres@localhost:54322/postgres"
sql (required) - the query to run
role - Postgres role (default: "authenticated")
user_id - UUID set as auth.uid()
claims - additional JWT claims, e.g. { "app_role": "parent" }

Example prompt for Claude Code:

"Run SELECT * FROM children as an authenticated parent user with id abc-123 and confirm they can only see their own children."

What you get back:

{
  "success": true,
  "role": "authenticated",
  "user_id": "abc-123",
  "query": "SELECT * FROM children",
  "rows": [["id-1", "abc-123", "Alice"], ["id-2", "abc-123", "Bob"]],
  "row_count": 2
}

3. `typecheck` - TypeScript checker

Runs tsc --noEmit and parses the output into structured errors.

Inputs:

project_dir (required)
tsconfig - relative path to tsconfig (default: "tsconfig.json")
files - check only specific files

What you get back:

{
  "success": false,
  "error_count": 2,
  "errors": [
    { "file": "src/utils.ts", "line": 42, "column": 5, "code": "TS2345", "message": "Argument of type 'string' is not assignable..." },
    { "file": "src/api.ts", "line": 18, "column": 12, "code": "TS2339", "message": "Property 'foo' does not exist on type..." }
  ]
}

4. `npm_run` - Structured npm script runner

Runs any npm script with CI=true and FORCE_COLOR=0, then parses Vitest/Jest output.

Inputs:

project_dir (required)
script (required) - e.g. "test", "test:unit", "lint"
args - extra args passed after --
env - extra environment variables

What you get back:

{
  "success": false,
  "exit_code": 1,
  "script": "test",
  "summary": { "total_tests": 14, "passed_tests": 12, "failed_tests": 2 },
  "file_results": [
    { "file": "src/auth.test.ts", "status": "failed", "tests_failed": 2 },
    { "file": "src/utils.test.ts", "status": "passed", "tests_passed": 5 }
  ],
  "raw_stdout": "..."
}

5. `nextjs_build` - Next.js build validator

Runs next build in production mode and parses errors and page output.

Inputs:

project_dir (required)
env - extra env vars for the build
timeout_seconds - (default: 180)

What you get back:

{
  "success": true,
  "error_count": 0,
  "errors": [],
  "pages": [
    { "path": "/", "size_kb": 5.42, "type": "static" },
    { "path": "/dashboard", "size_kb": 12.1, "type": "dynamic" },
    { "path": "/api/auth", "size_kb": 0, "type": "ssr" }
  ],
  "build_duration_ms": 24500
}

Development

# Watch mode
npm run watch

# Run the unit tests (Vitest)
npm test

# Test interactively with the MCP Inspector
npm run inspect

Tests

The output parsers are the trickiest, most regression-prone part of the codebase. They turn free-form Vitest/Jest/tsc/next build console output into structured JSON. Those pure functions are unit-tested with Vitest under test/; run them with npm test. CI (see .github/workflows/ci.yml) runs npm ci, the TypeScript build, and the test suite on Node 20 and 22 for every push and pull request.

Customization ideas

Add a lint tool that parses ESLint JSON output
Add a prisma_migrate tool for structured migration status
Add a docker_compose tool to manage test containers
Wire the RLS tool to Supabase CLI (supabase db test) instead of raw psql

License

Available Tools

5 tools

execute_sql_as_roleTest Supabase RLS policiesA

Executes a SQL query as a specific Postgres role with JWT claims set, so you can verify RLS policies. Runs inside a ROLLBACK transaction — never mutates data.

ParametersJSON Schema

Name	Required	Description	Default
`sql`	Yes	The SQL query to execute
`role`	No	Postgres role to SET ROLE to, e.g. 'authenticated', 'anon', 'service_role'	authenticated
`claims`	No	Additional JWT claims to set, e.g. { "role": "parent" }. Merged into request.jwt.claims.
`user_id`	No	UUID to set as request.jwt.claims sub (auth.uid()). Required for RLS policies that check auth.uid().
`timeout_seconds`	No
`connection_string`	Yes	Postgres connection string, e.g. postgresql://postgres:password@localhost:54322/postgres

TDQS

A4/5.0

Behavior4/5

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

No annotations exist, so the description must disclose behavior. It explicitly states the tool runs inside a ROLLBACK transaction and never mutates data—a critical safety guarantee. It also mentions setting JWT claims. It does not cover error handling or timeout behavior, but the core safety trait is transparently disclosed.

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 sentences with no fluff: the first states what and why, the second highlights the safety behavior. The purpose is front-loaded, making it easy for an agent to quickly grasp the tool's value.

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 the tool's complexity (role switching, nested claims) and no output schema, the description covers purpose and safety well. It does not mention return values (e.g., query results) or prerequisites like a running database, but these are implied. Slightly more context on expected output would make it fully complete.

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 83%, so most parameters are already documented. The description adds no extra parameter meaning beyond the schema. The uncovered parameter (timeout_seconds) is not mentioned, but with high schema coverage, the baseline of 3 is appropriate.

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 verb (Executes), the resource (SQL query), and the purpose (verify RLS policies). It adds specificity with role and JWT claims, and the purpose distinguishes it from unrelated sibling tools like run_e2e_tests or typecheck.

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 usage is implied: 'so you can verify RLS policies' indicates when to use. The ROLLBACK safety note suggests it's safe for testing. However, it does not explicitly state when not to use it or mention alternatives, though siblings are irrelevant. The guidance is clear but not exhaustive.

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

nextjs_buildValidate Next.js buildB

Runs next build and returns structured errors (TypeScript, module, page-level) plus a list of generated pages with their render types and sizes.

ParametersJSON Schema

Name	Required	Description
`env`	No	Extra env vars for the build, e.g. { NEXT_PUBLIC_API_URL: '...' }
`project_dir`	Yes	Absolute path to the Next.js project root
`timeout_seconds`	No

TDQS

B3.3/5.0

Behavior2/5

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

Annotations are completely absent, so the description must disclose behavioral traits. It mentions running a build and returning errors, but omits side effects like the creation/modification of build artifacts (e.g., .next directory), potential long execution time (timeout parameter exists), and that a failed build may still return partial output. The description does not fully cover the tool's impact or failure modes.

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?

A single, concise sentence that front-loads the core command and lists key outputs with no filler. Efficiently communicates essential information.

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?

The description provides some return-value detail (structured error types and page list) but lacks full context: no output schema, no mention of side effects, environment requirements, or how to interpret the results. It gives a reasonable overview but is incomplete for a tool that runs a full build without annotations.

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 covers 67% of parameters (env and project_dir have descriptions; timeout_seconds does not). The description adds no extra parameter context beyond what the schema provides, though the missing timeout parameter is self-explanatory. Since coverage is moderate but the description adds no value, a score of 3 is appropriate—adequate but not insightful.

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 action ('Runs next build') and the specific outcomes (structured errors and generated pages list). It distinguishes itself from siblings like typecheck and npm_run by being Next.js-specific and producing build validation output. No ambiguity.

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?

There is no guidance on when to use this tool versus alternatives (e.g., typecheck, npm_run). It does not state prerequisites, like that a Next.js project must exist, or when it should be preferred over other validation tools. The agent is left to infer usage from the name and output description.

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

npm_runRun npm script with structured outputA

Runs any npm script (test, lint, etc.) and parses Vitest/Jest output into structured pass/fail results per file. Falls back to raw output for non-test scripts.

ParametersJSON Schema

Name	Required	Description
`env`	No	Extra environment variables
`args`	No	Extra args passed after --, e.g. ['--coverage', '--verbose']
`script`	Yes	npm script name to run, e.g. 'test', 'lint', 'test:unit'
`project_dir`	Yes	Absolute path to the project root
`timeout_seconds`	No

TDQS

A4.2/5.0

Behavior4/5

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 explicitly discloses that Vitest/Jest output is parsed into structured per-file results and falls back to raw output for non-test scripts, which shapes agent expectations. It omits side effects like dependency installation or exit-code behavior, but the core behavior is adequately revealed.

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 sentences, front-loaded with the core purpose and output behavior, with zero redundancy. Every word earns its place.

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 no output schema, the description's explanation of structured output and raw fallback provides sufficient context for invocation. It could elaborate on error handling or exit codes, but the essential information for calling the tool correctly is present, and sibling tools are clearly separated by their purposes.

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 80% (4/5 parameters have descriptions), so the schema already documents the parameters well. The description adds no additional meaning beyond the schema, meeting the baseline for high coverage without compensating for any gaps.

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 states a specific verb (runs) and resource (npm script) and explicitly differentiates from siblings like run_e2e_tests and typecheck by focusing on arbitrary npm scripts. The mention of parsing test output adds specificity, making it unmistakable which tool to use for unit tests.

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

Usage Guidelines4/5

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

The description clearly implies the tool is for running any npm script, particularly tests, and distinguishes it from e2e, typecheck, and build tools. However, it does not explicitly name alternatives or state when not to use this tool, leaving exclusions to inference rather than explicit guidance.

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

run_e2e_testsRun Playwright E2E testsA

Spins up the dev server (if configured in playwright.config), runs Playwright tests, and returns structured pass/fail results per test with error messages.

ParametersJSON Schema

Name	Required	Description
`headed`	No	Run in headed mode (useful for debugging)
`project_dir`	Yes	Absolute path to the project root
`start_server`	No	Whether to let Playwright use the webServer config in playwright.config to start the dev server automatically
`test_pattern`	No	Glob or file path to filter tests, e.g. 'tests/auth.spec.ts'
`timeout_seconds`	No	Max seconds before the run is killed

TDQS

A4/5.0

Behavior3/5

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

With no annotations, the description must carry behavioral disclosure. It transparently states that it starts a dev server if configured and returns structured results, which is the core behavior. However, it does not disclose potential side effects such as file modifications, server teardown, or environmental requirements like locally installed Playwright, leaving some transparency gaps.

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 a single, well-structured sentence that front-loads the main action and then details the conditional server startup and output format. There is no redundancy or unnecessary detail.

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?

For a test runner with five parameters, the description covers the overall flow and return format sufficiently. The schema handles parameter details, and the description clarifies the conditional server startup. It lacks some environmental prerequisites, but overall it is adequate for an agent to call it correctly.

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?

Because the input schema already provides descriptions for all five parameters, the baseline is 3. The description adds a little context by linking the dev server startup to the Playwright config, but it does not add new parameter-specific semantics beyond what the schema provides.

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 explicitly states the tool runs Playwright tests and returns structured pass/fail results, with a clear verb and resource. It also mentions spinning up a dev server, which helps distinguish it from siblings like typecheck or npm_run.

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

Usage Guidelines4/5

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

The description implies its usage by identifying Playwright E2E testing as the core function. However, it does not explicitly name alternatives or specify when not to use it, leaving some room for interpretation. The context is clear enough that an agent would know to use it for running E2E tests.

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

typecheckRun TypeScript type checkerA

Runs tsc --noEmit and returns structured errors with file, line, column, error code, and message.

ParametersJSON Schema

Name	Required	Description	Default
`files`	No	Specific files to check (overrides tsconfig includes)
`tsconfig`	No	Path to tsconfig file relative to project_dir	tsconfig.json
`project_dir`	Yes	Absolute path to the project root (must contain tsconfig.json)
`timeout_seconds`	No

TDQS

A3.5/5.0

Behavior3/5

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

With no annotations, the description carries the full behavioral burden. It discloses the read-only nature of tsc --noEmit implicitly and describes the return format, which is valuable given no output schema. However, it omits timeout behavior, exit-code/error-handling semantics, and the side-effect-free guarantee explicitly — gaps that annotations would otherwise cover.

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?

A single, front-loaded sentence that packs the action, the exact command, and the output structure with zero filler. Every word earns its place.

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?

The tool has 4 parameters, no annotations, and no output schema, so the description must compensate. It compensates well for the missing output schema by spelling out error fields, but it leaves gaps: timeout_seconds is undocumented in both schema and description, the files/tsconfig interplay is unaddressed, and failure behavior is unstated. Adequate but not complete.

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 75%, so the schema already documents files, tsconfig, and project_dir. The description adds the 'tsc --noEmit' context, which clarifies how tsconfig and project_dir are consumed, but it doesn't explain timeout_seconds (the one undocumented parameter) or the files-overrides-tsconfig behavior. Value added is marginal over 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 names a specific verb ('Runs'), a specific resource ('tsc --noEmit'), and states the output shape (structured errors with file, line, column, error code, and message). This clearly distinguishes it from siblings like run_e2e_tests, npm_run, and nextjs_build, which target different workflows.

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?

The description provides no when-to-use or when-not-to-use guidance, and never mentions sibling tools. Context is only implied by the tool's name and the 'tsc --noEmit' detail; an agent receives no explicit direction on choosing it over the build/test siblings.

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.

5 tool updatesv0.1.0Aug 25, 2026
- First observedexecute_sql_as_role
- First observednextjs_build
- First observednpm_run
- First observedrun_e2e_tests
- First observedtypecheck

Install Server

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

TDQS

A3.7/5.0

Disambiguation4/5

每个工具针对开发流程的不同方面: 端到端测试, SQL角色执行, 类型检查, 运行脚本, 构建。npm_run可以运行任意脚本, 包括测试, 但run_e2e_tests专门用于Playwright, 因此边界相对清晰。少数可能重叠, 但描述有帮助。

Naming Consistency3/5

命名模式部分一致: 有些工具使用动词开头(run_e2e_tests, execute_sql_as_role), 而其他使用名词开头(npm_run, nextjs_build)或单词(typecheck)。虽然每个名称都具描述性, 但顺序和风格并不统一。

Tool Count5/5

5个工具的数量非常适合开发工具服务器。每个工具都服务于核心开发任务, 没有冗余或过度精简, 范围恰当。

Completeness4/5

工具集覆盖了主要开发步骤: 测试, 类型检查, 构建, 运行脚本以及SQL安全验证。npm_run可以运行lint或单元测试等其他任务, 因此没有明显缺口, 但可能缺少如专门的格式或代码质量检查工具, 不过可通配。

Maintenance

ActivityMaintained

ResponsivenessNo issues

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

chromedevtoolsmcp-mcp
com.clauxel.chromedevtoolsmcp
A paid remote MCP for AI agent browser DevTools MCP, built to return verdicts, receipts, usage logs,
Browser Automation Developer Tools Agent Orchestration
2
daemoonOAuth
io.github.jaylee7777
One PAT, any MCP agent: Vercel, GitHub, Cloudflare, Supabase, GCP — unified dev infra gateway.
Cloud Platforms Developer Tools CI/CD & DevOps
3
Frenchie A
io.github.Lab94
OCR, transcription, file extraction, and image generation for AI agents via MCP.
AI & Machine Learning Image & Video Processing Speech Processing
72
Air Pipe B
io.airpipe
Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.
Developer Tools CI/CD & DevOps App Automation
191

Related MCP Servers

Build MCP Server
Developer Tools CI/CD & DevOps Code Execution
TeodorTrotea
F
license
B
quality
D
maintenance
Enables AI assistants to manage development workflows by running build commands, executing tests, analyzing package.json files, installing dependencies, and performing code linting. Supports multiple package managers (npm, yarn, pnpm) and provides detailed error reporting for development operations.
Updated a year ago (2025-08-14 07:36 UTC)
5
-
MCP Quality Hub
Developer Tools Testing & QA Tools
HalbonLabs
-
license
Not graded
quality
Not graded
maintenance
Provides comprehensive code quality tools including linting, security scanning, TypeScript checking, and testing through a single MCP server. Integrates multiple quality analysis tools like Biome, ESLint, and Playwright for streamlined development workflows.
Updated a year ago (2025-08-30 01:34 UTC)
-
Autonomous QA Engineer MCP
Testing & QA Tools Autonomous Agents
GolffyCoding
F
license
Not graded
quality
B
maintenance
Provides MCP tools that give LLM agents a full QA engineer workflow: scanning projects, generating deterministic test suites, executing them across browser/API/mobile, diagnosing failures, and proposing fixes that require human approval.
Updated 23 days ago (2026-08-14 07:09 UTC)
-
groundtruth-mcp
Testing & QA Tools CI/CD & DevOps Developer Tools
ZhenGtai123
A
license
Not graded
quality
A
maintenance
Enables coding agents to run project-specific checks, replays, simulations, and queries as MCP tools, providing ground-truth feedback on config edits instead of guessing.
Updated 20 days ago (2026-08-17 14:56 UTC)
1
MIT

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/briancox730/dev-tools-mcp'

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

dev-tools-mcp

Prerequisites

Quick start

Alternative: edit .claude.json directly

Verify it's working

Tool details

1. run_e2e_tests - Playwright E2E runner

2. execute_sql_as_role - Supabase RLS tester

3. typecheck - TypeScript checker

4. npm_run - Structured npm script runner

5. nextjs_build - Next.js build validator

Development

Tests

Customization ideas

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

Alternative: edit `.claude.json` directly

1. `run_e2e_tests` - Playwright E2E runner

2. `execute_sql_as_role` - Supabase RLS tester

3. `typecheck` - TypeScript checker

4. `npm_run` - Structured npm script runner

5. `nextjs_build` - Next.js build validator