# gin-vue-admin: A Gin and Vue 3 Admin Scaffold With a Code Generator and an MCP Server

> gin-vue-admin is an Apache-2.0 full-stack admin base platform pairing a Gin backend with a Vue 3 frontend. Its distinguishing feature is a code generator that produces CRUD modules, now wired to an MCP service for AI editors.

**flipped-aurora/gin-vue-admin** — 🚀Vite+Vue3+Gin拥有AI辅助的基础开发平台，企业级业务AI+开发解决方案，内置mcp辅助服务，内置skills管理，支持TS和JS混用。它集成了JWT鉴权、权限管理、动态路由、显隐可控组件、分页封装、多点登录拦截、资源权限、上传下载、代码生成器、表单生成器和可配置的导入导出等开发必备功能。

- Repository: https://github.com/flipped-aurora/gin-vue-admin
- Website: http://demo.gin-vue-admin.com/
- Stars: 25,052 · Forks: 7,117
- Language: Go
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/flipped-aurora-gin-vue-admin

## The problem gin-vue-admin solves, and who it is aimed at

Most Go admin projects start from the same chore list: JWT middleware, role and API permission tables, dynamic menus that differ per role, pagination helpers, file upload, and a CRUD module you will write by hand for every table. gin-vue-admin packages that list as a starting point. The README describes it as a full-stack, front-end/back-end separated base platform built on Vue and Gin that integrates JWT authentication, dynamic routing, dynamic menus, Casbin authorization, a form generator and a code generator, with the stated goal of letting you spend more time on business logic.

The audience is narrow and stated: the README says the project requires some Golang and Vue foundation, and recommends Goland as the IDE. This is not a no-code tool. It is a scaffold for developers who already know both stacks and want the permission model and the CRUD plumbing pre-built. The repository description also mentions TS and JS mixed usage on the frontend, so a Vue 3 codebase that is not fully migrated to TypeScript is acceptable here.

One thing worth noting about scope: the README frames the project as aimed at quickly building small and medium projects. That framing matters later, when you weigh the permission model against lighter alternatives.

## How the Gin, Casbin, Redis and Vue layers fit together

The architecture is a conventional separated stack, and the README names each component. The backend is Gin for RESTful APIs, with GORM over MySQL or MariaDB 5.7+ using InnoDB as the storage layer. Authorization is split in two: JWT handles authentication, and Casbin handles permission decisions. Redis is used to record the JWT tokens of currently active users, which is what makes the multi-point login restriction possible: the README states Redis plus the corresponding configuration limits concurrent login state. Configuration is YAML, read through viper with fsnotify watching for changes, and logging uses zap.

Dynamic menus and dynamic routes are the mechanism that ties roles to what a user sees. The README lists menu management as configuring dynamic menus per role, API management as controlling which endpoints a role may call, and role management as the object that receives both API and menu permissions. Casbin is the enforcement point for the API side; the menu configuration drives the frontend. That split is the part to understand before extending it, because a new endpoint is only reachable once it exists in the API permission table and the role has been granted it.

File upload is backed by Qiniu, Aliyun or Tencent Cloud object storage according to the README, and chunked upload for large files is included as an example. Swagger generates the API documentation, served at http://localhost:8888/swagger/index.html once the Go service is running.

## Installing gin-vue-admin and generating your first CRUD module

The README gives explicit version floors: Node above v18.16.0 and Go at least v1.22. Clone the repository and work inside the server directory. The README warns specifically not to open the repository root in your editor, but the server directory.

```bash
git clone https://github.com/flipped-aurora/gin-vue-admin.git
cd server
go generate
go run .
```

go generate resolves the Go dependencies, and go run . starts the backend. The frontend is a separate process in the web directory.

```bash
cd web
npm install
npm run serve
```

After npm run serve, the Vue dev server comes up against the backend you started. If you want the Swagger UI, install the generator and run it from server, which updates docs.go, swagger.json and swagger.yaml under the docs folder.

```bash
cd server
swag init
```

The Makefile offers a containerized path instead of local toolchains. The build targets run inside golang:1.22 and node:20 images, and build-local assembles a build directory containing web/dist, the server binary and server/resource. If you use VSCode, the repository ships gin-vue-admin.code-workspace with three virtual folders (backend, frontend, root) and three run tasks, including Both (Backend & Frontend) to start both sides at once. The workspace also exposes go.gopath and go.goroot settings for machines with multiple Go versions.

The reason to pick this project over a blank Gin skeleton is the code generator, which the README describes as producing the backend logic and simple CRUD. The README's own summary of the flow is: create the base template, let AI generate the structure, generate the code, assign permissions, and the basic CRUD is done. Note the permission step. Generated code that is never granted in the API permission table will return permission errors, not 404s.

## The AI-facing parts: MCP service, skills management and the Claw ecosystem

The repository description lists an MCP auxiliary service and skills management as built-in features, and the topics include mcp, skills and vibecoding. The README links a video titled as an MCP highly adapted to AI editors, positioned as the path to generating base code in a minute. The repository root confirms this is not a marketing afterthought: there are .claude, .codex, .cursor and .trae directories plus AGENT.MD, which is where editor-specific agent configuration lives.

Treat this as the newest and least settled part of the project. The README does not document the MCP tool surface, the transport, or how the server is configured beyond pointing at the video, and it does not describe what skills management actually stores or how skills are versioned. If you are evaluating gin-vue-admin for the AI features specifically, the documentation available in the README is thinner than for the permission and generator features, and you should read the aiDoc directory and the linked video before assuming a workflow. The separate GvaClaw plugin is listed under the Claw ecosystem support heading and lives on the plugin marketplace, not in this repository.

## Where gin-vue-admin is the wrong choice

The clearest limitation is stated by the project itself: the README says you can complete everything through the tutorials and documentation, therefore free technical service is no longer provided, and directs users to paid support. If your team needs an upstream maintainer to answer integration questions on a timeline, this is a paid relationship, not a community one. That is a legitimate model, but it should be a decision input rather than a surprise three weeks in.

The second constraint is the version floor. Go 1.22 and Node above 18.16.0 are hard requirements in the README, and the Makefile builds against golang:1.22 and node:20. Teams pinned to older toolchains will be doing an upgrade before they write any business code.

The third is the permission model itself. Casbin plus Redis-backed token tracking plus dynamic menus is a lot of machinery for a small internal tool with two user types. If you only need one admin role, you are carrying a database table for API permissions and a Redis dependency for multi-point login control you may never enable. A lighter Gin skeleton with a single role check would be less to maintain.

Finally, the documentation is primarily Chinese. The README links an English translation, but the online documentation, initialization guide, plugin marketplace and teaching videos are at Chinese-language properties. If nobody on the team reads Chinese, budget time for that gap.

## Comparing gin-vue-admin with Go-admin and Vue admin templates

The closest comparison in the search data is go-admin-team/go-admin, and the difference is in where each puts its weight. go-admin is also a Go admin scaffold, but gin-vue-admin's distinguishing feature is the generator plus the AI-editor integration: the README's headline is generating front-end and back-end base code quickly, with MCP positioned as the interface an AI editor uses to drive that generation. If your workflow is writing CRUD by hand and you just want routing and auth, the generator is dead weight and the comparison tilts the other way.

On the frontend, Vue-pure-admin and Vue-Vben-admin are Vue admin templates without a prescribed Go backend. They are the right comparison if your backend is already settled and you only need the Vue layer. gin-vue-admin couples both halves, which is the point: the dynamic menus, the API permission table and the generated CRUD are designed against each other, and you cannot lift the Vue side out without also taking the Casbin and menu configuration model.

The honest framing is that gin-vue-admin is an opinionated whole. Its value is the coupling between generator, permissions and menus. If you intend to replace any one of those three, you are paying the cost of the coupling without the benefit.

## Maintenance, licensing and the cost of upgrading

The repository is not archived, and the last push was on 2026-09-09, which is recent. Releases follow a stable train: v2.9.2-stable on 2026-07-17, v2.9.2 on 2026-05-26, and v2.9.1 on 2026-03-27. The cadence suggests roughly a minor release every one to two months, with a stable tag following the release tag. Plan upgrades against the stable tags rather than the intermediate ones.

The upgrade cost is dominated by the generated code. Anything the code generator produced for you lives in your repository, so a framework upgrade does not rewrite it, but it also does not fix it. If a release changes the shape of the permission tables or the menu structures the generator targets, regenerating means reconciling your edited output against the new template. The README does not document a migration path between versions, and it does not document rollback, so treat your own version pin as the rollback mechanism.

Licensing is Apache-2.0, and the README states that use, modification and distribution must follow the LICENSE in the repository and retain the applicable notices the licence requires. There is a separate paid licensed edition with its own demo site and commercial support; the README directs users there for licensed features or official commercial support. Apache-2.0 covers the open source repository, not the licensed edition. This is not legal advice, and if you are redistributing a modified version, read the LICENSE file and your own counsel's guidance rather than this article.

## Conclusion

Adopt gin-vue-admin if you are building an internal admin console on Gin and Vue 3 and want Casbin RBAC, dynamic menus and a code generator rather than a blank repository. Do not adopt it if you want a maintained-by-committee framework with free support: the README states plainly that it no longer offers free technical service and points to paid support instead. Before committing, verify three things yourself: that your Go and Node versions satisfy the README's stated floors, that the generated CRUD output matches your own model conventions, and that the code generator and MCP integration are the parts you actually intend to use, because they are the reason to pick this over a hand-rolled Gin skeleton.

## FAQ

### What is gin-vue-admin?

It is a full-stack, front-end/back-end separated admin base platform built on Vue and Gin, according to the README. It bundles JWT authentication, Casbin authorization, dynamic routing and menus, a form generator and a code generator, with the stated aim of letting developers focus on business logic.

### How do I install and run gin-vue-admin locally?

The README requires Node above v18.16.0 and Go at least v1.22. Clone the repository, then run go generate and go run . inside the server directory, and npm install followed by npm run serve inside the web directory.

### Does gin-vue-admin provide free technical support?

No. The README states that because everything can be completed through the tutorials and documentation, the project no longer provides free technical service, and it links to a paid support page for those who need it.

## Sources

- [flipped-aurora/gin-vue-admin on GitHub](https://github.com/flipped-aurora/gin-vue-admin)
- [License: Apache-2.0](https://github.com/flipped-aurora/gin-vue-admin/blob/main/LICENSE)
- [Project website](http://demo.gin-vue-admin.com/)
- [README](https://github.com/flipped-aurora/gin-vue-admin/blob/main/README.md)
- [Releases](https://github.com/flipped-aurora/gin-vue-admin/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/flipped-aurora-gin-vue-admin