Overview on Go Micro

Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

Go Micro has three core abstractions:

Abstraction	What	Constructor
Service	Capability — endpoints, data, business logic	`micro.NewService("task")`
Agent	Intelligence — manages services with an LLM	`micro.NewAgent("task-mgr")`
Flow	Orchestration — event-driven LLM triggers	`micro.NewFlow("onboard")`

Prerequisites

Go 1.24+ for development. The curl install below gives you the micro binary without Go, but micro run compiles your services, so you’ll want Go installed to build them.
An LLM provider key (Anthropic, OpenAI, Gemini, …) only for the AI features — micro run --prompt, micro chat, and agents. Plain services need no key. Set it before running, e.g. export ANTHROPIC_API_KEY=sk-ant-....

Before your first provider-backed agent run, check the local path with:

AI Integration

Mon, 01 Jan 0001 00:00:00 +0000

Go Micro is an AI-native microservices framework. Every service you build is automatically accessible to AI agents, and every service can call AI models. This page explains how the pieces fit together.

The Stack

Your Services → write Go handlers, register with the framework
 ↓
Registry → automatic service discovery (mDNS, Consul, etcd)
 ↓
Gateways → micro api (HTTP→RPC) / micro mcp (MCP tools)
 ↓
ai.Tools → discovers services + executes RPCs programmatically
 ↓
ai.Model → calls LLMs (Anthropic, OpenAI, Gemini, Atlas Cloud, ...)
 ↓
agent / flow / micro chat → agent-managed, event-driven, or interactive orchestration

Every layer is optional. You can use go-micro without AI. You can use the ai package without MCP. But when you stack them, you get services that AI agents can discover and orchestrate automatically.

MCP & AI Agents

Mon, 01 Jan 0001 00:00:00 +0000

Model Context Protocol (MCP)

Go Micro provides built-in support for the Model Context Protocol (MCP), enabling AI agents like Claude to discover and interact with your microservices as tools.

Overview

MCP gateway automatically exposes your microservices as AI-accessible tools through:

Deploying Go Micro Services

Mon, 01 Jan 0001 00:00:00 +0000

This guide covers deploying go-micro services to a Linux server using systemd.

Overview

go-micro provides a clear workflow from development to production:

Stage	Command	Purpose
Develop	`micro run`	Local dev with hot reload and API gateway
Build	`micro build`	Compile production binaries for any target OS
Deploy	`micro deploy`	Push binaries to a remote Linux server via SSH + systemd
Dashboard	`micro server`	Optional production web UI with JWT auth and user management

Each command has a distinct role — they don’t overlap:

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

An overview of the Go Micro architecture.

Overview

Go Micro abstracts away the details of distributed systems. Here are the main features.

Authentication - Auth is built in as a first class citizen. Authentication and authorization enable secure zero trust networking by providing every service an identity and certificates. This additionally includes rule based access control.

Configuration

Mon, 01 Jan 0001 00:00:00 +0000

Go Micro follows a progressive configuration model so you can start with zero setup and layer in complexity only when needed.

Levels of Configuration

Zero Config (Defaults)
- mDNS registry, HTTP transport, in-memory broker/store
Environment Variables
- Override core components without code changes
Code Options
- Fine-grained control via functional options
External Sources (Future / Plugins)
- Configuration loaded from files, vaults, or remote services

Core Environment Variables

Component	Variable	Example	Purpose
Registry	`MICRO_REGISTRY`	`MICRO_REGISTRY=consul`	Select registry implementation
Registry Address	`MICRO_REGISTRY_ADDRESS`	`MICRO_REGISTRY_ADDRESS=127.0.0.1:8500`	Point to registry service
Broker	`MICRO_BROKER`	`MICRO_BROKER=nats`	Select broker implementation
Broker Address	`MICRO_BROKER_ADDRESS`	`MICRO_BROKER_ADDRESS=nats://localhost:4222`	Broker endpoint
Transport	`MICRO_TRANSPORT`	`MICRO_TRANSPORT=nats`	Select transport implementation
Transport Address	`MICRO_TRANSPORT_ADDRESS`	`MICRO_TRANSPORT_ADDRESS=nats://localhost:4222`	Transport endpoint
Store	`MICRO_STORE`	`MICRO_STORE=postgres`	Select store implementation
Store Database	`MICRO_STORE_DATABASE`	`MICRO_STORE_DATABASE=app`	Logical database name
Store Table	`MICRO_STORE_TABLE`	`MICRO_STORE_TABLE=records`	Default table/collection
Store Address	`MICRO_STORE_ADDRESS`	`MICRO_STORE_ADDRESS=postgres://user:pass@localhost:5432/app?sslmode=disable`	Connection string
Server Address	`MICRO_SERVER_ADDRESS`	`MICRO_SERVER_ADDRESS=:8080`	Bind address for RPC server

Example: Switching Components via Env Vars

# Use NATS for broker and transport, Consul for registry
export MICRO_BROKER=nats
export MICRO_TRANSPORT=nats
export MICRO_REGISTRY=consul
export MICRO_REGISTRY_ADDRESS=127.0.0.1:8500

# Run your service
go run main.go

No code changes required. The framework internally wires the selected implementations.

Observability

Mon, 01 Jan 0001 00:00:00 +0000

Observability in Go Micro spans logs, metrics, and traces. The goal is rapid insight into service behavior with minimal configuration.

Core Principles

Structured Logs – Machine-parsable, leveled output
Metrics – Quantitative trends (counters, gauges, histograms)
Traces – Request flows across service boundaries
Correlation – IDs flowing through all three signals

Logging

The default logger can be replaced. Use env vars to adjust level:

Hosting Go Micro Services

Mon, 01 Jan 0001 00:00:00 +0000

Go Micro services are compiled Go binaries that communicate via RPC and event-driven messaging. Hosting them requires infrastructure that supports service discovery, inter-service communication, persistent storage, and configuration management. Because go-micro uses a pluggable architecture, the hosting environment can range from a single VPS to a fully orchestrated cluster.

Current Hosting Options

Single VPS or Bare Metal

The simplest approach. Deploy compiled binaries to a Linux server and manage them with systemd. This is the model described in the Deployment Guide.

Performance Considerations

Mon, 01 Jan 0001 00:00:00 +0000

go-micro is designed for developer productivity and ease of use while maintaining good performance for most use cases. This document explains the performance characteristics and trade-offs.

Reflection Usage

go-micro uses Go’s reflection package to enable its core feature: registering any Go struct as a service handler without code generation or boilerplate.

Why Reflection?

// Simple handler registration - no proto files, no code generation
type GreeterService struct{}

func (g *GreeterService) SayHello(ctx context.Context, req *Request, rsp *Response) error {
 rsp.Message = "Hello " + req.Name
 return nil
}

server.Handle(server.NewHandler(&GreeterService{}))

This simplicity is only possible with reflection. Alternative approaches (like gRPC or psrpc) require: