# Go Micro

> An open-source Go framework for building microservices that AI agents can use, with MCP integration, service generation from prompts, and agent orchestration.

Go Micro is an open-source Go framework for building microservices designed to be orchestrated by AI agents. Originally created in 2015, the project has evolved to v5 and now centers on AI-native microservice development, where every service endpoint is automatically exposed as an AI-callable tool via the Model Context Protocol (MCP). The repository reports over 22,000 GitHub stars and is licensed under Apache 2.0.

## What It Is

Go Micro is a production-ready microservices framework for Go that bridges traditional distributed systems patterns with modern AI agent workflows. Developers write services as ordinary Go structs with methods; the framework handles registration, discovery, RPC communication, and pub/sub events. The key differentiator in v5 is that every endpoint automatically becomes an MCP tool, allowing LLMs to discover and call services without any additional wiring. An `micro chat` command lets an LLM orchestrate across all running services as a unified agent.

## AI-Native Architecture

The framework's AI layer sits on top of its core distributed systems primitives:

- **MCP gateway**: Every service endpoint is exposed as an AI tool at `http://localhost:8080/mcp/tools` automatically.
- **Agent orchestration**: `micro chat` connects to a configured LLM provider and lets it discover services from the registry and call them as tools.
- **Service generation**: `micro run --prompt "..."` sends a plain-English description to an LLM, which designs the architecture, generates Go handlers with real business logic, compiles them, and starts the services.
- **Mid-conversation generation**: When the agent needs a capability that doesn't exist, it can generate a new service on the fly during a chat session.
- **Seven LLM providers**: Anthropic (claude-sonnet-4), OpenAI (gpt-4o), Google Gemini, Groq, Mistral, Together AI, and Atlas Cloud are supported with a unified interface.

## Core Framework Capabilities

Beneath the AI layer, Go Micro provides a full microservices toolkit:

- **Service discovery**: mDNS by default, with Consul and etcd as alternatives.
- **RPC and streaming**: gRPC transport with load balancing and streaming support.
- **Pub/sub messaging**: NATS, RabbitMQ, and HTTP broker built in.
- **Typed data model**: CRUD and query layer with SQLite, Postgres, and in-memory backends.
- **Hot reload**: `micro run` watches files and rebuilds on change.
- **Templates**: `micro new --template crud/pubsub/api` scaffolds common patterns.
- **Deployment**: `micro deploy user@server` pushes via SSH and systemd with no Docker required.
- **Pluggable interfaces**: All abstractions are Go interfaces, so any component can be swapped without changing service code.

## Developer Workflow

The typical workflow starts with either `micro new` to scaffold a service from a template or `micro run --prompt` to generate one from a description. Running `micro run` starts a local environment with a dashboard at `http://localhost:8080`, a REST/gRPC API gateway, an agent playground, and MCP tool endpoints. `micro chat` then connects an LLM to the running services. For production, `micro deploy` handles SSH-based deployment with systemd process management. Generated code can be edited by hand at any time; re-running preserves manual changes.

## Update: v5.25.0

The latest release is v5.25.0, published on June 3, 2026, with the repository last pushed on June 4, 2026. The v5 line represents a significant evolution from earlier versions, adding the full AI/MCP layer on top of the established microservices core. The project lists Anthropic and Atlas Cloud as sponsors on the homepage and in the README.

## Features
- MCP gateway exposing every endpoint as an AI tool
- Service generation from plain-English prompts via micro run --prompt
- Agent orchestration with micro chat across all running services
- Support for 7 LLM providers: Anthropic, OpenAI, Gemini, Groq, Mistral, Together AI, Atlas Cloud
- Service discovery via mDNS, Consul, or etcd
- RPC client/server with gRPC transport, load balancing, and streaming
- Pub/sub messaging with NATS, RabbitMQ, and HTTP broker
- Typed data model with CRUD and queries (SQLite, Postgres, memory)
- Hot reload with micro run
- Service scaffolding with micro new --template
- One-command SSH+systemd deployment with micro deploy
- Pluggable architecture via Go interfaces
- REST and gRPC API gateway
- Multi-service project support with micro.mu config
- Mid-conversation service generation by AI agent

## Integrations
Anthropic Claude, OpenAI GPT-4o, Google Gemini, Groq, Mistral, Together AI, Atlas Cloud, gRPC, NATS, RabbitMQ, Consul, etcd, PostgreSQL, SQLite, Model Context Protocol (MCP), systemd, SSH

## Platforms
WEB, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
v5.25.0

## Links
- Website: https://go-micro.dev/
- Documentation: https://go-micro.dev/docs/
- Repository: https://github.com/micro/go-micro
- EveryDev.ai: https://www.everydev.ai/tools/go-micro