# Drive JHipster with your AI agent: introducing jhipster-mcp (v0.0.4)

> Source: <https://dev.to/avdev4j/building-a-jhipster-mcp-server-let-ai-agents-scaffold-and-evolve-your-architecture-487e>
> Published: 2026-05-26 23:08:35+00:00

TL;DR—`jhipster-mcp`

is an open-source[Model Context Protocol]server that lets an AI agent generate and evolve[JHipster]applications for you. You describe what you want in plain language; the agent writes JDL and drives the JHipster CLI. It's on npm — point your MCP host at it with one line.v0.0.4 is the first public release.📦 npm:

[https://www.npmjs.com/package/jhipster-mcp]

🧑💻 GitHub:[https://github.com/avdev4j/jhipster-mcp]

JHipster has always been about *speed*: scaffold a production-grade Spring Boot + modern frontend app in minutes, model your domain with **JDL** (JHipster Domain Language), and let the generator write the boilerplate.

AI coding agents are great at *intent*: you tell them what you want, they figure out the steps.

`jhipster-mcp`

connects the two. It exposes JHipster as a set of **MCP tools** an agent can call. So instead of remembering JDL syntax and CLI flags, you say:

"Create a JHipster monolith in`/tmp/shop`

with PostgreSQL and an Angular frontend, plus a`Product`

entity (name, price) and a`Category`

with a one-to-many to products. Paginate everything."

…and the agent composes valid JDL, runs the generator, and streams the result back.

If you use **Claude Code**, **Claude Desktop**, **Cursor**, or any MCP-compatible host, you can plug it in today.

The server ships **9 tools**, JDL-first:

| Tool | What it does |
|---|---|
`create_app_from_jdl` |
Scaffold a brand-new app from a full JDL block. |
`import_jdl` |
Apply JDL (entities, relationships, options) to an existing project. |
`add_entity` |
Add one entity with fields, validations, and per-entity options. |
`add_relationship` |
Add a typed relationship between two entities. |
`set_option` |
Toggle JDL options (`paginate` , `dto` , `service` , `search` , …). |
`validate_jdl` |
Check JDL for errors without modifying anything. |
`generate_ci_cd` |
Scaffold a CI/CD pipeline (GitHub, GitLab, Jenkins, …). |
`info` |
Inspect project versions, config, and entities. |
`run_jhipster` |
Escape hatch — run an allowlisted subcommand safely. |

It also exposes a **JDL grammar cheat-sheet** as an MCP resource, so the agent writes valid JDL on the first try.

This first release focuses on making **every tool call trustworthy and legible** to the agent:

Full app generation can take 30–90 seconds. Instead of looking frozen, the server streams the generator's output as MCP **progress notifications** in real time.

You can validate JDL or preview a change without touching your project.

There's a fun gotcha here: JHipster's own `--dry-run`

flag only *prints conflicts* — **it still writes files** (I confirmed this against the real CLI). So a flag-based "preview" would silently modify your project. `jhipster-mcp`

instead does a **real preview**: it generates in a throwaway temp directory (copying your project's `.yo-rc.json`

and `.jhipster/`

for context), parses what *would* be produced, and discards everything. Your project is never modified.

Every tool returns machine-readable JSON alongside the human-readable text, so the agent reasons on data instead of scraping logs:

```
{
  "command": "jhipster jdl changes.jdl --force --skip-git",
  "exitCode": 0,
  "success": true,
  "dryRun": false,
  "entities": ["Customer", "Order"],
  "filesChanged": [{ "action": "create", "path": "src/main/java/..." }],
  "warnings": []
}
```

`shell: false`

and an argument allowlist — no command injection.`--force --skip-git`

and `CI=true`

; never hangs on a prompt.`workingDirectory`

; the server won't act outside it.Under the hood it's **TypeScript** on the official **MCP SDK**, with 70 tests and CI on Node 22/24.

```
  npm install -g generator-jhipster
  jhipster --version
```

**Claude Code:**

```
claude mcp add jhipster -- npx -y jhipster-mcp
```

**Claude Desktop / Cursor / others** — add to your MCP config:

```
{
  "mcpServers": {
    "jhipster": {
      "command": "npx",
      "args": ["-y", "jhipster-mcp"]
    }
  }
}
```

No clone, no build — `npx`

fetches and caches the package for you.

"In`/Users/me/projects/shop`

, add a`Customer`

entity with firstName (required, 2–50 chars), lastName, and email, then a one-to-many from Customer to Order."

The agent reads the JDL grammar, builds the snippet, and applies it — streaming progress as it goes.

Want to look before you leap? Ask it to **preview** first:

"Show me what adding a`Tag`

entity would change — don't write anything yet."

…and it runs the same tool with `dryRun: true`

.

This release completes the "Tier 1" experience work (progress, validation/dry-run, structured output). On the roadmap:

`.yo-rc.json`

, the entity list, and exported JDL directly.

```
npx -y jhipster-mcp@0.0.4
```

⭐ Star it, break it, and tell me what's missing: [https://github.com/avdev4j/jhipster-mcp](https://github.com/avdev4j/jhipster-mcp)

Built with ❤️ for the JHipster community.

*#jhipster #ai #mcp #java #springboot #opensource*