MCP serverSafeBuilding web & mobile appsSome setup

nunu

This tool offers an Agent Skill for coding agents like Claude Code to scaffold and implement tested features in Go applications, including MCP servers.

A CLI tool for building Go applications.

2.6k stars209License: MITUpdated 2 months ago0 opens

Preview

▍

What you can do with it

Generate the basic structure for a new Go web application using an AI coding agent.
Have an AI agent implement new handlers, services, or repositories following Nunu's architecture.
Quickly set up and test a new MCP server as part of a Go project with agent assistance.

Safety check

Safe

No risky patterns found in the files we scanned.

Automated scan of the repo files. Always review code you run.

From the README

Nunu — A CLI tool for building Go applications.

Nunu is a scaffolding tool for building Go applications. Its name comes from a game character in League of Legends, a little boy riding on the shoulders of a Yeti. Just like Nunu, this project stands on the shoulders of giants, as it is built upon a combination of popular libraries from the Go ecosystem. This combination allows you to quickly build efficient and reliable applications.

🚀Tips: This project is very complete, so updates will not be very frequent, welcome to use.

Documentation

AI-assisted Development

Nunu Skills provides build-with-nunu, an Agent Skill that helps coding agents such as Codex and Claude Code understand Nunu project layouts and implement complete, tested features across handlers, services, repositories, routers, Wire dependency injection, jobs, tasks, and MCP servers.

Install it in your project with:

npx skills add go-nunu/nunu-skills --skill build-with-nunu

See the Nunu Skills repository for supported layouts, agent-specific installation options, and example prompts.

Features

Gin: https://github.com/gin-gonic/gin
Gorm: https://github.com/go-gorm/gorm
Wire: https://github.com/google/wire
Viper: https://github.com/spf13/viper
Zap: https://github.com/uber-go/zap
Golang-jwt: https://github.com/golang-jwt/jwt
Go-redis: https://github.com/go-redis/redis
Testify: https://github.com/stretchr/testify
Sonyflake: https://github.com/sony/sonyflake
Gocron: https://github.com/go-co-op/gocron
Go-sqlmock: https://github.com/DATA-DOG/go-sqlmock
Gomock: https://github.com/golang/mock
Swaggo: https://github.com/swaggo/swag
Casbin: https://github.com/casbin/casbin
Pitaya: https://github.com/topfreegames/pitaya
MCP-GO: https://github.com/mark3labs/mcp-go
More...

Key Features

Low Learning Curve and Customization: Nunu encapsulates popular libraries that Gophers are familiar with, allowing you to easily customize the application to meet specific requirements.
High Performance and Scalability: Nunu aims to be high-performance and scalable. It uses the latest technologies and best practices to ensure that your application can handle high traffic and large amounts of data.
Security and Reliability: Nunu uses stable and reliable third-party libraries to ensure the security and reliability of your application.
Modular and Extensible: Nunu is designed to be modular and extensible. You can easily add new features and functionality by using third-party libraries or writing your own modules.
Complete Documentation and Testing: Nunu has comprehensive documentation and testing. It provides extensive documentation and examples to help you get started quickly. It also includes a test suite to ensure that your application works as expected.

Concise Layered Architecture

Nunu adopts a classic layered architecture. In order to achieve modularity and decoupling, it uses the dependency injection framework Wire.

Nunu CLI

Directory Structure

.
├── api
│   └── v1
├── cmd
│   ├── migration
│   ├── server
│   │   ├── wire
│   │   │   ├── wire.go
│   │   │   └── wire_gen.go
│   │   └── main.go
│   └── task
├── config
├── deploy
├── docs
├── internal
│   ├── handler
│   ├── middleware
│   ├── model
│   ├── repository
│   ├── server
│   └── service
├── pkg
├── scripts
├── test
│   ├── mocks
│   └── server
├── web
├── Makefile
├── go.mod
└── go.sum

The project architecture follows a typical layered structure, consisting of the following modules:

cmd: This module contains the entry points of the application, which perform different operations based on different commands, such as starting the server or executing database migrations. Each sub-module has a main.go file as the entry file, as well as wire.go and wire_gen.go files for dependency injection.
config: This module contains the configuration files for the application, providing different configurations for different environments, such as development and production.
deploy: This module is used for deploying the application and includes deployment scripts and configuration files.
internal: This module is the core module of the application and contains the implementation of various business logic.
- handler: This sub-module contains the handlers for handling HTTP requests, responsible for receiving requests and invoking the corresponding services for processing.
- job: This sub-module contains the logic for background tasks.
- model: This sub-module contains the definition of data models.
- repository: This sub-module contains the implementation of the data access layer, responsible for interacting with the database.
- server: This sub-module contains the implementation of the HTTP server.
- service: This sub-module contains the implementation of the business logic, responsible for handling specific business operations.
pkg: This module contains some common utilities and functions.
scripts: This module contains some script files used for project build, test, and deployment operations.
storage: Thi

View source on GitHub