Checks if Docker is installed and the daemon is running.
Compares keys in .env files against .env.example to ensure required environment variables are present.
Checks if Git is installed and user.name/user.email are configured.
Checks if the current Node.js version matches the project requirements from .nvmrc or package.json engines.
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., "@onboard-mcp run the doctor on my project, it needs ports 3000 and 5432"
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.
Your dev environment, fixed by asking your AI assistant.
An MCP (Model Context Protocol) server that checks the things that silently break local development: wrong Node version, Docker not running, missing git config, missing .env keys, busy ports. Ask your AI assistant "is my environment ready?" and get a pass/fail report with the exact fix for everything that's broken.
Every developer has lost an afternoon to "it works on my machine": the app fails because Node is one major version off, or the port is taken by a zombie process, or .env.local is missing a key that was added last sprint. On my team, environment setup issues cost every new developer days.
This server turns that debugging into one question in your AI chat:
You: run the doctor on my project, it needs ports 3000 and 5432
Assistant:
[PASS] node-version: Node v20.11.0 satisfies the project requirement (20). [FAIL] docker: Docker is installed but the daemon is not running. Fix: Start Docker Desktop, or on Linux run "sudo systemctl start docker". [PASS] git-config: Git is installed and user.name / user.email are configured. [FAIL] env-files: .env.local is missing 1 key(s) from .env.example: REDIS_URL. Fix: Add the missing keys to .env.local. Ask a teammate or your secrets manager for the values. [PASS] ports: All required ports are free: 3000, 5432. 2 failing, 0 warning(s). Fixes listed above.
Related MCP server: DevBoost MCP Server
Tool | What it checks |
| Runs everything below and returns one report |
| Current Node vs |
| Docker CLI installed and daemon running |
| git installed, |
|
|
| Whether the TCP ports your project needs are free |
Node.js 18 or newer — required for every client, since the server runs via npx onboard-mcp. Check with node --version; install from nodejs.org if needed.
That's the only universal dependency. npx fetches the published package automatically — no clone or build required. The Claude Code steps below additionally need the claude CLI (npm install -g @anthropic-ai/claude-code); other clients do not.
Requires the Claude Code CLI. Install it first if you don't have it:
npm install -g @anthropic-ai/claude-codeThen register the server:
claude mcp add --scope user onboard -- npx -y onboard-mcp(--scope user makes it available in every project; omit it to register for the current project only.) Verify with claude mcp get onboard.
Or clone and build locally:
git clone https://github.com/developerpankajdixit/onboard-mcp.git
cd onboard-mcp && npm install && npm run build
claude mcp add onboard -- node /absolute/path/to/onboard-mcp/dist/index.jsAdd to .vscode/mcp.json in your project:
{
"servers": {
"onboard": {
"command": "npx",
"args": ["-y", "onboard-mcp"]
}
}
}Settings → MCP → Add new global MCP server, or add to .cursor/mcp.json:
{
"mcpServers": {
"onboard": {
"command": "npx",
"args": ["-y", "onboard-mcp"]
}
}
}Add to claude_desktop_config.json:
{
"mcpServers": {
"onboard": {
"command": "npx",
"args": ["-y", "onboard-mcp"]
}
}
}Then ask: "Run the doctor on /path/to/my/project, it needs ports 3000 and 5432."
Any other MCP-compatible client works the same way: point it at npx -y onboard-mcp over stdio.
Fixes, not just failures. Every failing check returns the exact command to fix it, so the assistant can offer to run it.
Secrets never leave your machine. The env check compares key names only. Values are never included in any tool response.
Pure check functions. Every check is a plain async function with injectable dependencies, tested without mocking the MCP layer (23 unit tests, CI on Linux and macOS across Node 18/20/22).
npm install
npm test # vitest
npm run build # tsc
npm run dev # run the server from sourcefix_* counterpart tools that apply the suggested fixes after confirmation
Configurable check list via an onboard.config.json in the project root
Database connectivity checks (Postgres, Redis) behind a flag
MIT. Built by Pankaj Dixit, based on an internal MCP onboarding tool that cut new-developer setup from 2 weeks to under 30 minutes.
Check whether Docker is installed and the daemon is running.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It transparently discloses that the tool checks both installation and daemon status, which is the core behavior. No side effects or additional context needed for such a simple check.
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?
A single, front-loaded sentence that communicates the purpose without any filler. Every word contributes to understanding.
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?
The description explains what the tool checks but does not clarify what it returns (e.g., boolean, message, exit code). Since there is no output schema, this gap reduces completeness for an agent deciding whether to use or interpret results.
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?
No parameters exist, so baseline is 4. Description adds no parameter information, which is appropriate as there are none to describe.
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 explicitly states the tool checks Docker installation and daemon status. It uses a specific verb-resource combination ('check Docker') and clearly differentiates from sibling tools like check_node_version or check_git_config.
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 implies usage for verifying Docker readiness but provides no explicit guidance on when to use this tool versus alternatives (e.g., check_ports). No context on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compare .env/.env.local against .env.example and report missing keys (keys only, values are never read into the response).
| Name | Required | Description | Default |
|---|---|---|---|
| projectDir | No | Absolute path to the project directory to check |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that only keys are compared and values are never read, providing privacy assurance and a clear behavioral trait beyond the schema.
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?
Single sentence efficiently conveys purpose, scope, and key behavioral detail with no wasted words.
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 one-parameter tool with no output schema or annotations, the description fully covers what the tool does and its constraints.
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 100% for the single parameter; the tool description does not add new semantics beyond the schema.
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?
Clearly states the tool compares .env/.env.local against .env.example and reports missing keys, distinguishing it from sibling environment check 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?
Implied usage through purpose clarity; no explicit when-to-use or when-not-to-use instructions compared to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether git is installed and user.name / user.email are configured.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description accurately describes the check's scope. However, it does not disclose what happens if git is missing or how results are returned (e.g., boolean exit code).
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?
Single sentence with no waste, front-loaded verb and object.
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 zero parameters and no annotations, the description is sufficient for a simple check. Could mention return format, but not critical.
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?
No parameters exist, so the baseline is 4. The description adds no parameter info, which is fine since schema already covers it.
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 it checks git installation and user.name/user.email configuration, distinguishing it from sibling tools like check_docker or check_node_version.
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 context implies usage for verifying git setup, but there is no explicit guidance on when not to use it or comparison to alternatives, though siblings are distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether the current Node.js version matches the project's .nvmrc or package.json engines requirement.
| Name | Required | Description | Default |
|---|---|---|---|
| projectDir | No | Absolute path to the project directory to check |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must bear full responsibility. It only mentions 'check' without clarifying safety (read-only), failure modes (missing files), or side effects, leaving uncertainty for an AI agent.
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?
A single sentence of 20 words with no redundancy. All words earn their place, and the purpose is front-loaded.
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 tool with no output schema and no annotations, the description omits critical details: what the tool returns (e.g., true/false, error message) and how it handles missing .nvmrc or engines fields. This is insufficient for complete agent understanding.
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 single parameter 'projectDir' has a clear description in the schema and is contextually linked by the tool description to the project's requirement files. With 100% schema coverage, the description adds little beyond that.
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 'check' and the specific resource: whether the current Node.js version matches .nvmrc or package.json engines. It distinguishes well from sibling tools like check_env_files or check_ports.
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?
Usage is implied by the name and description (check Node version compatibility), but there is no explicit guidance on when to use vs alternatives, nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether the given TCP ports are free on localhost.
| Name | Required | Description | Default |
|---|---|---|---|
| ports | Yes | Ports the project needs, e.g. [3000, 5432] |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are missing, so description carries full burden. It does not disclose how 'free' is determined, timeout behavior, or what the output format is. Only the basic condition is mentioned.
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?
One clear sentence with no wasted words. Front-loaded and to the point.
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?
The tool has no output schema, so the description should explain return values. It does not. Additionally, it lacks details about the exact behavior of the check (e.g., what constitutes 'free'). For a simple tool, it is insufficiently complete.
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 covers the single parameter 'ports' with a description and constraints. Schema description coverage is 100%, so baseline is 3. Description adds no additional meaning beyond the schema.
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?
Description clearly states the tool checks if given TCP ports are free on localhost. The verb 'Check' and resource 'TCP ports' are specific, and it distinguishes from sibling tools like check_env_files or check_docker.
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?
No guidance on when to use this tool versus alternatives. The description only states what it does, without specifying when it's appropriate or providing exclusion criteria. Usage is implied by the name and purpose, but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run every environment check (Node version, Docker, git config, env files, ports) and return a full report with fixes.
| Name | Required | Description | Default |
|---|---|---|---|
| ports | No | Ports the project needs, e.g. [3000, 5432] | |
| projectDir | No | Absolute path to the project directory to check |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behaviors. It mentions 'fixes' but does not clarify if the tool actually applies fixes or only suggests them, which could be destructive. No mention of permissions, side effects, or output format.
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 sentence with no unnecessary words. It efficiently conveys the tool's scope, though the phrase 'with fixes' could be clarified.
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 complexity of running multiple checks and no output schema, the description is somewhat complete but lacks details about return format, whether modifications are applied, and prerequisites like a valid project directory.
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?
Both parameters have clear descriptions in the schema (100% coverage). The description adds no further detail beyond summarizing the tool's purpose, meeting the baseline expectation.
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 it runs all environment checks (Node version, Docker, git config, env files, ports) and returns a report with fixes, distinguishing it from sibling tools that only check individual aspects.
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 implies a comprehensive check but does not explicitly guide when to use this tool versus the individual sibling tools, such as check_ports or check_node_version.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0check_dockercheck_env_filescheck_git_configcheck_node_versioncheck_portsdoctorEach tool has a clearly distinct purpose: env file comparison, port checking, node version, Docker, git config, and a comprehensive doctor. No ambiguity between tools.
Five tools follow the 'check_' prefix pattern, but 'doctor' breaks the pattern. This is a minor inconsistency overall.
6 tools is well-scoped for an environment onboarding server, covering essential checks without being excessive or too sparse.
Covers key environment checks like Node version, Docker, git config, env files, and ports. Minor gaps like package manager or OS checks, but sufficient for basic onboarding.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Stop your agent before it runs rm -rf /etc or emails your .env. Deterministic preflight checks.
Scan and fix a domain's email deliverability (SPF, DKIM, DMARC, MTA-STS, BIMI, DNS blocklists).
Lints + auto-fixes how AI coding agents discover any new product. 24 rules, 6 tools, score 0-100.
Generate SBOMs, scan vulnerabilities, and analyze dependencies from local projects or Git repos.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/developerpankajdixit/onboard-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
