Go Micro

Adr 001 Plugin Architecture

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

Status

Accepted

Context

Microservices frameworks need to support multiple infrastructure backends (registries, brokers, transports, stores). Different teams have different preferences and existing infrastructure.

Hard-coding specific implementations:

Limits framework adoption
Forces migration of existing infrastructure
Prevents innovation and experimentation

Decision

Go Micro uses a pluggable architecture where:

Core interfaces define contracts (Registry, Broker, Transport, Store, etc.)
Multiple implementations live in the same repository under interface directories
Plugins are imported directly and passed via options
Default implementations work without any infrastructure

Structure

go-micro/
├── registry/ # Interface definition
│ ├── registry.go
│ ├── mdns.go # Default implementation
│ ├── consul/ # Plugin
│ ├── etcd/ # Plugin
│ └── nats/ # Plugin
├── broker/
├── transport/
└── store/

Consequences

Positive

No version hell: Plugins versioned with core framework
Discovery: Users browse available plugins in same repo
Consistency: All plugins follow same patterns
Testing: Plugins tested together
Zero config: Default implementations require no setup

Negative

Repo size: More code in one repository
Plugin maintenance: Core team responsible for plugin quality
Breaking changes: Harder to evolve individual plugins independently

Neutral

Plugins can be extracted to separate repos if they grow complex
Community can contribute plugins via PR
Plugin-specific issues easier to triage

Alternatives Considered

Separate Plugin Repositories

Used by go-kit and other frameworks. Rejected because:

Adr 004 Mdns Default Registry

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

Status

Accepted

Context

Service discovery is critical for microservices. Common approaches:

Central registry (Consul, Etcd) - Requires infrastructure
DNS-based (Kubernetes DNS) - Platform-specific
Static configuration - Doesn’t scale
Multicast DNS (mDNS) - Zero-config, local network

For local development and getting started, requiring infrastructure setup is a barrier. Production deployments typically have existing service discovery infrastructure.

Decision

Use mDNS as the default registry for service discovery.

Adr 009 Progressive Configuration

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

Status

Accepted

Context

Microservices frameworks face a paradox:

Beginners want “Hello World” to work immediately
Production needs sophisticated configuration

Too simple: Framework is toy, not production-ready Too complex: High barrier to entry, discourages adoption

Decision

Implement progressive configuration where:

Zero config works for development
Environment variables provide simple overrides
Code-based options enable fine-grained control
Defaults are production-aware but not production-ready

Levels of Configuration

Level 1: Zero Config (Development)

svc := micro.NewService("hello")
svc.Run()

Uses defaults:

Adr 010 Unified Gateway

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

Status: Accepted Date: 2026-02-11 Authors: Go Micro Team

Context

Previously, the go-micro CLI had two separate gateway implementations:

micro run gateway (cmd/micro/run/gateway/) - Simple HTTP-to-RPC proxy for development
micro server gateway (cmd/micro/server/) - Production gateway with authentication, web UI, and API documentation

This duplication created several problems:

Code maintenance: Gateway logic (HTTP-to-RPC translation, service discovery, health checks) was implemented twice
Feature parity: Improvements to one gateway didn’t automatically benefit the other
Complexity: New features (like MCP integration) would need to be implemented twice
Testing burden: Each gateway required separate testing

Decision

We unified the gateway implementation by:

Client Server

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

The client is used to make requests to other services.
The server handles incoming requests.

Both client and server are pluggable and support middleware wrappers for additional functionality.

Example Usage

Here’s how to define a simple handler and register it with a Go Micro server:

package main

import (
 "context"
 "go-micro.dev/v6"
 "log"
)

type Greeter struct{}

func (g *Greeter) Hello(ctx context.Context, req *struct{}, rsp *struct{Msg string}) error {
 rsp.Msg = "Hello, world!"
 return nil
}

func main() {
 service := micro.NewService("greeter",
 )
 service.Init()
 micro.RegisterHandler(service.Server(), new(Greeter))
 if err := service.Run(); err != nil {
 log.Fatal(err)
 }
}

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:

Registry

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

Features

Service registration and deregistration
Service lookup
Watch for changes

Implementations

Go Micro supports multiple registry backends, including:

MDNS (default)
Consul
Etcd
NATS

You can configure the registry when initializing your service.

Plugins Location

Registry plugins live in this repository under go-micro.dev/v6/registry/<plugin> (e.g., consul, etcd, nats). Import the desired package and pass it via micro.Registry(...).

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.

Broker

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

Features

Publish messages to topics
Subscribe to topics
Multiple broker implementations

Implementations

Supported brokers include:

HTTP (default)
NATS (go-micro.dev/v6/broker/nats)
RabbitMQ (go-micro.dev/v6/broker/rabbitmq)
Memory (go-micro.dev/v6/broker/memory)

Plugins are scoped under go-micro.dev/v6/broker/<plugin>.

Configure the broker in code or via environment variables.

Example Usage

Here’s how to use the broker in your Go Micro service:

Contributing

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

This is a rendered copy of the repository CONTRIBUTING.md for convenient access via the documentation site.

Overview

Go Micro welcomes contributions of all kinds: code, documentation, examples, and plugins.

Quick Start

git clone --depth 1 https://github.com/micro/go-micro.git
cd go-micro
go mod download
go test ./...

Process

Fork and create a feature branch
Make focused changes with tests
Run linting and full test suite
Open a PR describing motivation and approach

Commit Format

Use conventional commits:

Transport

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

Features

Pluggable transport implementations
Secure and efficient communication

Implementations

Supported transports include:

HTTP (default)
NATS (go-micro.dev/v6/transport/nats)
gRPC (go-micro.dev/v6/transport/grpc)
Memory (go-micro.dev/v6/transport/memory)

Important: Transport vs Native gRPC

The gRPC transport uses gRPC as an underlying communication protocol, similar to how NATS or RabbitMQ might be used. It does not provide native gRPC compatibility with tools like grpcurl or standard gRPC clients generated by protoc.

Roadmap

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

Go Micro is a framework for building agents and services in Go. An agent is a distributed system — it discovers services, calls them, holds state, and recovers from failure — so building an agent is building a service. The roadmap has two jobs: make agentic development excellent, and make the developer experience around it excellent. Nothing else.

Where we are (v6)

The foundation is in place:

Services — register, discover, RPC, events; every endpoint is automatically an MCP tool.
Agents — a model with memory and tools that manages services, with plan, delegate, and guardrails (MaxSteps, LoopLimit, ApproveTool) built in, plus tool-execution middleware (WrapTool) and run metadata.
Flows — durable, event-driven workflows: ordered steps that checkpoint and resume after a crash.
Interop — the MCP gateway (services as tools) and the A2A gateway (agents as agents, both directions, including A2A streaming, push notifications, and multi-turn continuation), both generated from the registry; x402 for paid tools.
Secure by default — TLS verification on, state scoped per component.

Principles

These constrain everything below:

Store

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

Features

Key-value storage
Multiple backend support

Implementations

Supported stores include:

Memory (default)
File (go-micro.dev/v6/store/file)
MySQL (go-micro.dev/v6/store/mysql)
Postgres (go-micro.dev/v6/store/postgres)
NATS JetStream KV (go-micro.dev/v6/store/nats-js-kv)

Plugins are scoped under go-micro.dev/v6/store/<plugin>.

Configure the store in code or via environment variables.

Example Usage

Here’s how to use the store in your Go Micro service:

package main

import (
 "go-micro.dev/v6"
 "go-micro.dev/v6/store"
 "log"
)

func main() {
 service := micro.NewService("store-example")
 service.Init()

 // Write a record
 if err := store.Write(&store.Record{Key: "foo", Value: []byte("bar")}); err != nil {
 log.Fatal(err)
 }

 // Read a record
 recs, err := store.Read("foo")
 if err != nil {
 log.Fatal(err)
 }
 log.Printf("Read value: %s", string(recs[0].Value))
}

Configure a specific store in code

Postgres:

Powered by Go Micro Badge

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

Markdown Badges

Dark Badge

[![Powered by Go Micro](https://img.shields.io/badge/Powered%20by-Go%20Micro-0366d6?style=for-the-badge&logo=go&logoColor=white)](https://go-micro.dev)

Light Badge

[![Powered by Go Micro](https://img.shields.io/badge/Powered%20by-Go%20Micro-00ADD8?style=flat&logo=go&logoColor=white)](https://go-micro.dev)

Compact Badge

[![Go Micro](https://img.shields.io/badge/Go-Micro-0366d6?style=flat-square)](https://go-micro.dev)

HTML Badges

Standard HTML Badge

<a href="https://go-micro.dev" target="_blank">
 <img src="https://img.shields.io/badge/Powered%20by-Go%20Micro-0366d6?style=for-the-badge&logo=go&logoColor=white" alt="Powered by Go Micro">
</a>

Custom SVG Badge

<a href="https://go-micro.dev" style="display:inline-block;text-decoration:none;">
 <svg width="160" height="32" xmlns="http://www.w3.org/2000/svg">
 <rect width="160" height="32" rx="6" fill="#0366d6"/>
 <text x="16" y="21" font-family="system-ui,-apple-system,sans-serif" font-size="13" font-weight="600" fill="white">
 Powered by Go Micro
 </text>
 </svg>
</a>

Usage

Add one of these badges to your README.md, documentation, or website footer to show that your project uses Go Micro.

Plugins

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

Common interfaces and locations:

Registry: go-micro.dev/v6/registry/* (e.g. consul, etcd, nats, mdns)
Broker: go-micro.dev/v6/broker/* (e.g. nats, rabbitmq, http, memory)
Transport: go-micro.dev/v6/transport/* (e.g. nats, default http)
Server: go-micro.dev/v6/server/* (e.g. grpc for native gRPC compatibility)
Client: go-micro.dev/v6/client/* (e.g. grpc for native gRPC compatibility)
Store: go-micro.dev/v6/store/* (e.g. postgres, mysql, nats-js-kv, memory)
Auth, Cache, etc. follow the same pattern under their respective directories.

Registry Examples

Consul:

import (
 "go-micro.dev/v6"
 "go-micro.dev/v6/registry/consul"
)

func main() {
 reg := consul.NewConsulRegistry()
 svc := micro.NewService("plugin-example",
 micro.Registry(reg),
 )
 svc.Init()
 svc.Run()
}

Etcd:

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:

Server (optional)

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

Micro Server (Optional)

The Micro server is an optional web dashboard and authenticated API gateway for production environments. It provides a secure entrypoint for discovering and interacting with services that are already running (e.g., managed by systemd via micro deploy).

micro server does not build, run, or watch services. It only discovers services via the registry and provides a UI/API to interact with them.

micro server vs micro run

	`micro run`	`micro server`
Purpose	Local development	Production dashboard
Builds services	Yes	No
Runs services	Yes (as child processes)	No (discovers already-running services)
Hot reload	Yes	No
Authentication	Yes (default `admin`/`micro`)	Yes (default `admin`/`micro`)
Scopes	Yes (`/auth/scopes`)	Yes (`/auth/scopes`)
Dashboard	Full gateway UI with auth, scopes, agent	Full dashboard with API explorer, logs, user/token management
When to use	Day-to-day development	Deployed environments, shared servers

For local development, use micro run instead.

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:

What's New in Go Micro: v6.6.0

Sat, 11 Jul 2026 00:00:00 +0000

Go Micro v6.6.0 is a harness reliability release. The theme is the same services → agents → workflows lifecycle, but with more of the first-agent path covered by local checks and more recovery paths made deterministic when agents resume, retry, delegate, or notify.

The first-agent path is harder to break

The README, website docs, examples, and 0→hero guide chain now have more harness coverage. The CLI and docs keep the path from install troubleshooting through micro agent demo, quickcheck, examples, the smallest first-agent, debugging, and 0→hero in one consistent order.

What's New in Go Micro: v6.3.15

Sun, 05 Jul 2026 00:00:00 +0000

Go Micro v6.3.15 is a small but useful harness release: less friction for the first agent, better streaming provider coverage, and more reliable execution when models and delegates do not behave perfectly.

Anthropic now streams

The Anthropic provider now supports Messages SSE streaming and is registered as a streaming-capable provider. That means Go Micro agents can use Anthropic in the same streaming path as the other streaming-capable providers, with request/response parser coverage and provider capability docs kept in sync.

The Loop, Shipped: Introducing micro loop

Thu, 02 Jul 2026 00:00:00 +0000

A few weeks ago we wrote How Go Micro Builds Itself: a loop of two AI agents — Codex writing scoped increments, Claude Code orchestrating and reviewing, a human setting direction — kept honest by CI. It was our own thesis, an agent operating a system, pointed at the repository that defines the thesis.

People asked the obvious question: can I run that on my repo?

Now you can. micro loop init drops the whole pipeline into any repository, and — the part that makes it real rather than aspirational — Go Micro itself now runs on it. The workflows that maintain this project are generated by the same command we’re shipping to you.

An Agent Is a Service: Where Agent Frameworks Are Going

Tue, 30 Jun 2026 00:00:00 +0000

There are now a lot of ways to build an agent. LangChain and LangGraph, LlamaIndex, CrewAI, Microsoft’s AutoGen, Google’s ADK, the model labs’ own SDKs, and — most recently in our own backyard — tRPC-Agent-Go from Tencent. They are not all solving the same problem, and the places they differ tell you a lot about where this is heading.

This is a field guide to that landscape, and an honest account of where Go Micro sits in it.

How Go Micro Builds Itself

Thu, 25 Jun 2026 00:00:00 +0000

Go Micro is an agent harness. The most honest test of that claim is to use agents to build it — so increasingly, we do. A scheduled loop of two AI agents now opens issues, writes increments, and merges its own pull requests against this repo, on a cadence, with a human setting direction rather than typing the code.

This isn’t a stunt. If a harness is good enough to operate a loop that builds itself, that’s evidence it’s good enough to operate the loop that builds your software. So we pointed the thesis at itself and wired up the loop. This post is how it actually works — including the parts that didn’t, because the failure modes are the interesting part.

Go Micro is an Agent Harness

Wed, 24 Jun 2026 00:00:00 +0000

The first wave of agent frameworks solved one problem: put a model in a loop with some tools. That’s the easy part now. The harder problem — the one that decides whether an agent makes it past a demo — is operating that loop.

Operating a loop means connecting it to real tools, scoping what it can touch, keeping state when the process restarts, routing work to specialists, recovering from provider failures, seeing what it did, and letting other agents call it. That’s harness work, and it’s most of the actual job.

Go Micro Joins OpenAI's Codex for Open Source

Tue, 23 Jun 2026 00:00:00 +0000

Go Micro has been accepted into OpenAI’s Codex for Open Source program. OpenAI is covering six months of ChatGPT Pro — and with it, access to Codex — to support the day-to-day work of maintaining the project.

What the grant is

Codex for Open Source backs maintainers directly: the constant, unglamorous work of reviewing changes, cutting releases, triaging issues, and keeping quality high. That’s most of what maintaining a framework actually is, and it’s the part that rarely gets funded. OpenAI putting Codex against it is a real, practical help.

Building a Support Agent in Go

Fri, 19 Jun 2026 00:00:00 +0000

Most agent demos are a chat box wired to one tool. Real systems aren’t that — they’re a handful of services, an agent that operates them, something that triggers the agent without a human typing, and a gate on the actions you don’t want it taking on its own. Here’s that, built end to end. The full code is in examples/support; it runs with no API key.

The scenario: a customer files a ticket. That should trigger an agent to look the customer up, set a priority, and reply — but it must not email anyone without passing an approval gate.

Agents Across Frameworks: A2A

Thu, 18 Jun 2026 00:00:00 +0000

Inside a Go Micro system, agents already talk to each other. An agent is a service with an Agent.Chat endpoint, so delegate just calls another agent over RPC. That works as long as everyone is on Go Micro. The moment an agent is built on a different framework, the conversation stops: it can’t call yours, and yours can’t call it.

A2A — the open Agent2Agent protocol — is the standard that closes that gap, and Go Micro now speaks it.

Bringing an Open Source Project Back from the Dead

Thu, 18 Jun 2026 00:00:00 +0000

I open sourced Go Micro in January 2015. Eleven years later we just tagged v6. What a crazy and surreal experience that is. the project was basically dead or sitting stale for quite some time after VC funding dried up, I shutdown the business and tried to hand off to the community. So much has happened in that time and I’ve learned a lot of lessons. Like how to be grateful for what you had when you had it.

Go Micro is Becoming a Framework for Agentic Development

Wed, 17 Jun 2026 00:00:00 +0000

When Anthropic began sponsoring Go Micro, we committed to building in the open and reporting progress as it happened. It has been three months. Each post so far covered one change; this one is about what they add up to. Go Micro is becoming a framework for agentic development, the same way it has been a framework for services for the last decade. It’s an extension of the existing framework, not a rewrite, because an agent is a distributed system and Go Micro is how you build one.

Durable Workflows

Wed, 17 Jun 2026 00:00:00 +0000

A workflow that calls real services is rarely instant and rarely side-effect-free. It reserves inventory at step one, charges a card at step two, sends a confirmation at step three. Each of those changes the world. So when the process dies between step two and step three — a deploy, an OOM, a node going away — you can’t just run it again from the top: that reserves twice and charges twice. And if the workflow was triggered by an event with no human watching, nobody noticed it died at all.

Agent Guardrails

Tue, 16 Jun 2026 00:00:00 +0000

The interesting failures of an autonomous agent aren’t dramatic. It calls the same tool with the same arguments over and over, making no progress. It takes thirty steps on a task that needed three, quietly running up cost. It performs an action that a human, or a policy, should have stood in front of. When an agent runs on its own, there’s no one watching to catch any of it.

A useful way to think about this — which came up in a community discussion recently — is to separate orchestration from execution safety. The model decides what to do; that’s orchestration. Whether a decided action is actually allowed to run is a separate concern, and it shouldn’t be tangled into the model or the services. Go Micro keeps them apart: every tool call an agent makes passes through one choke point, and that’s where the guardrails live. They apply uniformly to service calls, custom tools, and delegate, and they touch neither the model nor your services.

Integrating x402: Payments for Agents

Mon, 15 Jun 2026 00:00:00 +0000

The last post was about agents that run on their own — triggered by an event, acting without a human prompt. Follow that one step further and you reach something agents can’t do yet in most systems: pay. An autonomous agent that calls an API, rents compute, or uses another agent’s service will, sooner or later, need to settle for it — without a person reaching for a credit card. There is now a standard for exactly that, and we’re integrating it.

When the Event Is the Prompt

Mon, 15 Jun 2026 00:00:00 +0000

Almost every agent demo starts the same way: a human types a prompt, the agent responds. That framing is a habit from chat, and it hides the more useful case. The agents worth running don’t wait for you to ask. They run because something happened — a user signed up, a payment failed, a deployment finished, a metric crossed a line. In those systems there is no prompt, because there is no human in the loop. The event is the prompt.

Doubling Down on Agents

Wed, 10 Jun 2026 00:00:00 +0000

Go Micro made microservices easy by having an opinion. You called micro.New, and it composed the pieces a service needs — service discovery, RPC, pub/sub, config, storage — behind one interface, with defaults that worked out of the box. You could test an endpoint in minutes, and when you needed to, you swapped any piece: mDNS for etcd, HTTP for gRPC, in-memory for Postgres. Opinionated, batteries-included, and pluggable. That combination is why people used it.

Not Everything Should Be an Agent

Mon, 08 Jun 2026 00:00:00 +0000

The last two posts were about agents — the abstraction, and then agents that plan and delegate, directing their own work over many turns. That’s the exciting part. It’s also, honestly, the part you should reach for least often.

An agent decides its own path at runtime. That’s powerful when the task genuinely needs it, and a liability when it doesn’t — you trade predictability, latency, and cost for flexibility you may not want. Most real work has a known shape: when this event happens, do these things. For that, you don’t want a model improvising. You want a workflow.

The Evolution of Microservices

Mon, 08 Jun 2026 00:00:00 +0000

Every era of distributed systems has solved the problem the previous era created. Microservices solved the coordination cost of the monolith and created a distributed-systems problem. Containers and orchestration solved the deployment problem and created an operational one. The service mesh solved the cross-cutting problem and pushed complexity into the platform. Each step was a response to a concrete engineering constraint, not a trend.

Follow that chain to the end, and the interface the industry converged on — a named, typed, discoverable, independently deployable unit — turns out to be almost exactly the interface a language model needs to call a tool. That convergence is the technical reason agents are the next era.

Agents That Plan and Delegate

Sun, 07 Jun 2026 00:00:00 +0000

When we introduced micro.NewAgent(), an agent was already a service with an LLM inside: scoped tools, persistent memory, and a micro chat router that dispatches across agents. And in Agents for Services we made the case that intelligence should be distributed — agents coordinate “not through code… through understanding.”

This post is the next beat. An agent that only reacts, one tool call at a time, isn’t really understanding anything — it’s improvising. Two things turn reaction into intent: the agent should plan what it’s doing before it does it, and delegate what it shouldn’t be doing itself. Go Micro now gives every agent both.

Introducing micro.NewAgent()

Fri, 05 Jun 2026 00:00:00 +0000

Go Micro now has three core abstractions:

service := micro.NewService("task") // capability
agent := micro.NewAgent("task-mgr") // intelligence
flow := micro.NewFlow("onboard-user") // event-driven orchestration

Service has been the foundation since 2015. Flow added event-driven LLM orchestration. Now Agent completes the picture — an intelligent layer that manages services, with scoped tools, persistent memory, and multi-agent coordination.

What an Agent Is

A Service has endpoints and handles requests. An Agent knows how to use those endpoints intelligently. The service doesn’t know about its agent. The agent knows about its services.

Agents for Services: A New Model for Microservices

Thu, 04 Jun 2026 00:00:00 +0000

Microservices solved monolithic code. Split it into small, independent units. But we centralised the intelligence — one agent, one brain, managing everything. That’s just a different kind of monolith.

What if every service had its own agent? Not embedded in the service. Created separately, assigned to manage it. The service is the capability. The agent is the intelligence.

The Problem with One Agent

Right now, micro chat is a single agent. It discovers every service in the registry, sees every endpoint, and orchestrates across all of them. You ask it a question and it figures out which service to call.

Going All In on AI

Thu, 04 Jun 2026 00:00:00 +0000

I started Go Micro in 2015 because building microservices in Go was too hard. Too much boilerplate, too many decisions before you could test a single endpoint. The idea was simple: sane defaults, pluggable architecture, get out of the developer’s way.

Eleven years later, the framework works. Service discovery, RPC, pub/sub, config, store — all pluggable, all production-tested. 23,000 stars on GitHub. But let’s be honest: the microservices ecosystem moved on. Kubernetes won infrastructure. gRPC became the default transport. Service meshes handle the network. The problems Go Micro originally solved are mostly solved.

From Prompt to Production: AI-Generated Microservices That Actually Run

Wed, 03 Jun 2026 00:00:00 +0000

Every code generator stops at the same point: here’s some files, good luck. You get a skeleton, wire it up yourself, hope it compiles. We wanted something different.

micro run --prompt "a task management system"

That’s not scaffolding. Two services start, register, and respond to requests. An AI agent can create tasks, organize categories, and orchestrate across services immediately. And when you need a capability that doesn’t exist — shipping, payments, notifications — the agent builds it mid-conversation.

Build Your Own AI Agent CLI in 150 Lines

Sat, 30 May 2026 00:00:00 +0000

We introduced micro chat — a CLI that lets you talk to your microservices through an LLM. People asked how it works under the hood. The honest answer: it’s about 150 lines, and there’s no magic. This post walks through every piece so you can build your own — for go-micro, for your own framework, or for whatever services you have.

Tools as Services: Why Go Micro Was Always Ready for AI

Sat, 30 May 2026 00:00:00 +0000

When people see micro chat or the MCP gateway, they assume we built something new. We didn’t. We exposed something that was already there.

Go Micro has always treated services as self-describing, addressable units. Every service registers its name, endpoints, and request types with the registry. Every endpoint is callable through a standardised path. The only thing that changed is who’s calling.

The Pattern

Go Micro was built on one idea: a service should be accessible the same way regardless of how you access it.

From Chat to Flows: What If Your Services Could Orchestrate Themselves?

Fri, 29 May 2026 00:00:00 +0000

We shipped micro chat recently — an interactive terminal where you talk to your services through an LLM. You say “list all users over 30 and send each a welcome email,” and the model figures out which services to call, in what order, with what arguments.

It works. But it’s interactive and ephemeral. You type a prompt, get a result, move on. What if you could save that prompt as a flow and trigger it from an event?

micro chat: Talk to Your Services

Fri, 29 May 2026 00:00:00 +0000

We built micro chat — a CLI that lets you talk to your microservices through an LLM. It discovers every service in the registry, exposes each endpoint as a tool, and lets a model decide which RPCs to call based on what you ask.

ANTHROPIC_API_KEY=sk-ant-... micro chat --provider anthropic

> list all users
 → called users_Users_List({})
There are 3 users: Alice, Bob, and Charlie.

> send a welcome email to Alice
 → called email_Email_Send({"to":"alice@example.com","template":"welcome"})
Done, welcome email sent to Alice.

> how many orders were placed this week?
 → called orders_Orders_Count({"since":"2026-05-22"})
There were 47 orders placed this week.

No glue code. No API wrappers. No tool definitions. You write normal Go services with doc comments, and micro chat turns them into things an LLM can call.

Atlas Cloud Sponsors Go Micro: 300+ AI Models, One Integration

Thu, 28 May 2026 00:00:00 +0000

We’re excited to announce that Atlas Cloud is sponsoring Go Micro as an official AI provider partner. Atlas Cloud is now a first-class provider in the ai package, giving Go Micro users access to 300+ models across text, image, and video through a single integration.

The Sponsorship

Atlas Cloud is an enterprise AI infrastructure platform that provides a unified API for LLM, image, and video generation. They partner with OpenRouter and ComfyUI, offer SOC 2 and HIPAA compliance, and run a custom inference engine (Atlas Photon) with FP4 quantization for fast, cost-effective inference.

Your Microservices Are Already an AI Platform

Thu, 05 Mar 2026 00:00:00 +0000

Here’s the pitch: you have microservices. They already have well-defined endpoints, typed request/response schemas, and service discovery. An AI agent needs the same things — a list of tools with input schemas and descriptions. The gap between “microservice endpoint” and “AI tool” is surprisingly small.

With Go Micro + MCP, that gap is zero lines of code.

Agents Meet Microservices: A Hands-On Demo

Wed, 04 Mar 2026 00:00:00 +0000

We talk a lot about AI-native microservices. Time to show it. In this post we’ll build three services — projects, tasks, and team — and then hand them to an AI agent. The agent will create projects, assign tasks, and query team skills using nothing but natural language.

No API wrappers. No tool definitions. Just Go comments.

The Setup

The full code is at examples/agent-demo. Here’s the architecture:

flowchart TD
 User[<b>User</b> <br/>natural language] --> Agent[<b>AI Agent</b> <br/>Claude, GPT, etc.]
 Agent --> Gateway[<b>MCP Gateway</b> <i>:3000</i>]

 Gateway --> Project[<b>ProjectService</b><br/>Create / Get / List]
 Gateway --> Task[<b>TaskService</b><br/>Create / List / Update]
 Gateway --> Team[<b>TeamService</b><br/>Add / List / Get]

The MCP gateway discovers all three services automatically and exposes 9 tools. The agent sees them and knows how to call them — because we wrote good comments.

Building the AI-Native Future of Go Micro with Claude

Wed, 04 Mar 2026 00:00:00 +0000

Go Micro was recently given access to Claude Max through Anthropic’s open source sponsorship program. We wanted to share what we’ve built with it, why it matters, and where we’re headed.

The Sponsorship

Anthropic offers Claude Max access to open source projects. Go Micro applied because our MCP integration — making every microservice an AI tool — aligns directly with Anthropic’s Model Context Protocol. They agreed, and we got to work.

Developer Experience Cleanup: One Way to Do Things

Wed, 04 Mar 2026 00:00:00 +0000

Go Micro has always prioritized getting out of your way. But over time, the API accumulated multiple ways to do the same thing — micro.New(), micro.NewService(), service.New(), three different handler registration patterns. If you’re building something for AI agents or running a modular monolith, you shouldn’t have to choose between equivalent APIs.

We’ve cleaned it up. Here’s what changed and why.

One Way to Create a Service

Before, there were three ways to create a service:

The Model Package: Client, Server, and Now Data

Wed, 04 Mar 2026 00:00:00 +0000

Go Micro has always given you service.Client() to call other services and service.Server() to handle requests. But most services also need to save and query data. Until now, that meant either using the low-level store package (key-value only) or wiring up your own database layer.

Today we’re shipping the model package — a typed data model layer that completes the service trifecta: Client, Server, Model.

The Problem

The existing store package is great for simple key-value storage, but real services need more. You need to filter by fields, paginate results, count records, and use different databases in dev vs production. Most teams end up writing their own data layer or pulling in an ORM that has nothing to do with Go Micro.

Making Microservices AI-Native with MCP

Wed, 11 Feb 2026 00:00:00 +0000

We’re excited to announce MCP (Model Context Protocol) support in Go Micro v5.15.0 — making your microservices instantly accessible to AI tools like Claude.

The Vision

Imagine telling Claude: “Why is user 123’s order stuck?”

Claude responds by:

Calling your users service to check the account
Calling your orders service to inspect the order
Calling your payments service to verify the transaction
Giving you a complete diagnosis

No API wrappers. No manual integrations. Your services just work with AI.

What's New in Go Micro: v5.15.0

Wed, 11 Feb 2026 00:00:00 +0000

Making Microservices AI-Native with MCP

The Vision

Imagine telling Claude: “Why is user 123’s order stuck?”

Claude responds by:

Calling your users service to check the account
Calling your orders service to inspect the order
Calling your payments service to verify the transaction
Giving you a complete diagnosis

No API wrappers. No manual integrations. Your services just work with AI.

What is MCP?

Model Context Protocol is Anthropic’s open standard for connecting AI models to external tools. Think of it like a microservices registry, but for AI.

Introducing micro deploy

Tue, 27 Jan 2026 00:00:00 +0000

We’re excited to announce micro deploy in Go Micro v5.13.0 — a simple way to deploy your services to any Linux server.

The Problem

Go Micro has always been great for building microservices:

micro new myservice
cd myservice
micro run

But getting those services to production? That was on you. You’d need to figure out Docker, Kubernetes, or write your own deployment scripts.

What's New in Go Micro: v5.13.0

Tue, 27 Jan 2026 00:00:00 +0000

The Problem

Go Micro has always been great for building microservices:

micro new myservice
cd myservice
micro run

But getting those services to production? That was on you. You’d need to figure out Docker, Kubernetes, or write your own deployment scripts.

We tried to solve this with Micro v3 — a full platform-as-a-service. But it was too much. Too complex. Nobody wanted another platform to manage.

The Solution

The new approach is simple: systemd + SSH.

`micro loop` quickstart

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

micro loop scaffolds the autonomous improvement loop that Go Micro uses on this repository: GitHub Actions workflows for planning, building, evaluation feedback, coherence, security, and release. Use it when you want a repository to continuously turn a ranked queue into small PRs while CI remains the merge gate.

1. Initialize the loop

Run the default loop from the repository root:

micro loop init

For every role used by Go Micro itself, scaffold all workflows:

0→hero reference path

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

The 0→hero path is the maintained, no-secret reference for the Go Micro services → agents → workflows lifecycle. It ties the CLI inner loop and the runtime harness together so a contributor can prove the framework still works as one system, not as separate demos.

Use it when you want to answer: “Can I scaffold a service, run it locally, talk to an agent, inspect durable work, and reach the deployment boundary without cloud credentials?”

About Goldydocs

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

Fastest OS on the planet!

The new TechOS operating system is an open source project. It is a new project, but with grand ambitions. Please follow this space for updates!

Add MCP to Existing Services

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

Add MCP to Existing Services

You have a working go-micro service and want to make it accessible to AI agents via MCP. This guide covers the three approaches, from simplest to most flexible.

Option 1: One-Line Setup (Recommended)

Add a single option to your service constructor:

import "go-micro.dev/v6/gateway/mcp"

func main() {
 service := micro.NewService("myservice",
 mcp.WithMCP(":3001"), // Add this line
 )
 service.Init()
 // ... register handlers as before
 service.Run()
}

That’s it. Your service now exposes all registered handlers as MCP tools at http://localhost:3001/mcp/tools.

Adding an AI Provider to Go Micro

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

This guide walks you through implementing a new AI model provider for go-micro’s ai package. After following these steps your provider will be available via ai.New("yourprovider") and automatically usable by the MCP gateway, the agent playground, and any service that calls service.Model().

Overview

The ai package uses the same plugin pattern as the rest of go-micro: define an interface, register an implementation, and let users swap providers with a single import. All providers live under ai/<name>/.

Agent Guardrails

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

An autonomous agent decides its own actions at runtime, which is what makes it useful — and what makes it risky. The common failure modes are mundane: it loops, repeating the same call without making progress; it runs away, taking far more steps (and cost) than the task warrants; it takes an action that should have had a human or a policy in the way.

Go Micro separates orchestration (the model deciding what to do) from execution safety (whether a decided action is allowed to run). Every tool call an agent makes passes through one choke point, and that’s where the guardrails live — so they apply uniformly to service calls, custom tools, and delegate, without touching the model or your services.

Agent Integration Patterns

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

This guide covers common patterns for integrating AI agents with Go Micro services, from single-agent workflows to multi-agent architectures.

Pattern 1: Single Agent with Multiple Services

The simplest and most common pattern. One AI agent has access to multiple microservices as MCP tools.

User → AI Agent → MCP Gateway → [Service A, Service B, Service C]

Setup

Run multiple services and expose them all through one MCP gateway:

Agent Loops

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

Most agent work is one-shot: a prompt goes in, an answer comes out. The next step in agentic systems is the loop — run a step over and over, letting the agent keep working until the goal is met instead of stopping after one pass. One agent improves an architecture while another removes duplicated abstractions, both opening pull requests continuously; a draft is refined until it’s good enough; a build is fixed and re-run until it’s green.

Agent2Agent (A2A)

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

Go Micro speaks the Agent2Agent (A2A) protocol — the open standard for agents on different frameworks to discover and call each other over HTTP. The A2A gateway is the agent-side analogue of the MCP gateway: MCP exposes your services as tools, A2A exposes your agents as agents.

There is nothing to add to an agent. An agent already registers in the registry with type=agent metadata; the gateway discovers it, generates an Agent Card from that metadata, and translates incoming A2A tasks to the agent’s existing Agent.Chat RPC — the same call delegate and flows use.

Agents and Workflows

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

Go Micro’s AI primitives map directly onto the taxonomy in Anthropic’s Building Effective Agents. That post draws one distinction that matters:

Workflows — “LLMs and tools orchestrated through predefined code paths.” Deterministic.
Agents — “LLMs dynamically direct their own processes and tool usage.” Model-driven.

Go Micro has both, plus the harness they run inside — and expresses them as plain services and tools, with no graph DSL. That’s deliberate: the same post advises finding “the simplest solution possible” and being “cautious with frameworks… they obscure the underlying mechanics.”

AI Integration

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

AI Integration

Go Micro is an agent harness and service framework for Go. Every service you build can become an AI-callable tool, every agent runs as a service with model/memory/guardrails around it, and flows orchestrate the deterministic parts. This page explains how the services → agents → workflows lifecycle fits together.

The Stack

Services → write Go handlers, register with the framework
 ↓
Registry → automatic discovery for services, agents, and flows
 ↓
Gateways → micro api (HTTP→RPC), micro mcp (tools), micro a2a (agents)
 ↓
ai.Tools → discovers services + executes RPCs programmatically
 ↓
ai.Model → calls LLMs (Anthropic, OpenAI, Gemini, Atlas Cloud, ...)
 ↓
Agents → service-backed model loop with memory, guardrails, plan/delegate
 ↓
Flows → durable deterministic steps that can dispatch to agents

Every layer is optional. You can use Go Micro as a service framework without AI. You can use the ai package without MCP. But when you stack them, you get one runtime where services become tools, agents are reachable services, and workflows coordinate the predictable parts.

Analysis: Removing Reflection from go-micro

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

Date: 2026-02-03
Author: GitHub Copilot
Status: RECOMMENDATION - DO NOT PROCEED

Executive Summary

After comprehensive analysis of the go-micro codebase and comparison with livekit/psrpc (referenced as an example of a reflection-free approach), we recommend AGAINST removing reflection from go-micro. The architectural differences make this change infeasible without a complete redesign that would:

Break backward compatibility - Fundamentally change the API
Lose key advantages - Eliminate go-micro’s “any struct as handler” flexibility
Increase complexity - Require extensive code generation and boilerplate
Provide minimal benefit - Performance gains would be negligible for most use cases (~10-20% in specific hot paths)

Current Reflection Usage

Locations

Reflection is used extensively in:

API Gateway with Backend Services

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

A complete example showing an API gateway routing to multiple backend microservices.

Architecture

 ┌─────────────┐
 Client ───────>│ API Gateway │
 └──────┬──────┘
 │
 ┌──────────────┼──────────────┐
 │ │ │
 ┌─────▼────┐ ┌────▼─────┐ ┌────▼─────┐
 │ Users │ │ Orders │ │ Products │
 │ Service │ │ Service │ │ Service │
 └──────────┘ └──────────┘ └──────────┘
 │ │ │
 └──────────────┼──────────────┘
 │
 ┌──────▼──────┐
 │ PostgreSQL │
 └─────────────┘

Services

1. Users Service

// services/users/main.go
package main

import (
 "context"
 "database/sql"
 "go-micro.dev/v6"
 "go-micro.dev/v6/server"
 _ "github.com/lib/pq"
)

type User struct {
 ID int64 `json:"id"`
 Email string `json:"email"`
 Name string `json:"name"`
}

type UsersService struct {
 db *sql.DB
}

type GetUserRequest struct {
 ID int64 `json:"id"`
}

type GetUserResponse struct {
 User *User `json:"user"`
}

func (s *UsersService) Get(ctx context.Context, req *GetUserRequest, rsp *GetUserResponse) error {
 var u User
 err := s.db.QueryRow("SELECT id, email, name FROM users WHERE id = $1", req.ID).
 Scan(&u.ID, &u.Email, &u.Name)
 if err != nil {
 return err
 }
 rsp.User = &u
 return nil
}

func main() {
 db, err := sql.Open("postgres", "postgres://user:pass@localhost/users?sslmode=disable")
 if err != nil {
 panic(err)
 }
 defer db.Close()

 svc := micro.NewService("users",
 micro.Version("1.0.0"),
 )

 svc.Init()

 server.RegisterHandler(svc.Server(), &UsersService{db: db})

 if err := svc.Run(); err != nil {
 panic(err)
 }
}

2. Orders Service

// services/orders/main.go
package main

import (
 "context"
 "database/sql"
 "time"
 "go-micro.dev/v6"
 "go-micro.dev/v6/client"
 "go-micro.dev/v6/server"
)

type Order struct {
 ID int64 `json:"id"`
 UserID int64 `json:"user_id"`
 ProductID int64 `json:"product_id"`
 Amount float64 `json:"amount"`
 Status string `json:"status"`
 CreatedAt time.Time `json:"created_at"`
}

type OrdersService struct {
 db *sql.DB
 client client.Client
}

type CreateOrderRequest struct {
 UserID int64 `json:"user_id"`
 ProductID int64 `json:"product_id"`
 Amount float64 `json:"amount"`
}

type CreateOrderResponse struct {
 Order *Order `json:"order"`
}

func (s *OrdersService) Create(ctx context.Context, req *CreateOrderRequest, rsp *CreateOrderResponse) error {
 // Verify user exists
 userReq := s.client.NewRequest("users", "UsersService.Get", &struct{ ID int64 }{ID: req.UserID})
 userRsp := &struct{ User interface{} }{}
 if err := s.client.Call(ctx, userReq, userRsp); err != nil {
 return err
 }

 // Verify product exists
 prodReq := s.client.NewRequest("products", "ProductsService.Get", &struct{ ID int64 }{ID: req.ProductID})
 prodRsp := &struct{ Product interface{} }{}
 if err := s.client.Call(ctx, prodReq, prodRsp); err != nil {
 return err
 }

 // Create order
 var o Order
 err := s.db.QueryRow(`
 INSERT INTO orders (user_id, product_id, amount, status, created_at)
 VALUES ($1, $2, $3, $4, $5)
 RETURNING id, user_id, product_id, amount, status, created_at
 `, req.UserID, req.ProductID, req.Amount, "pending", time.Now()).
 Scan(&o.ID, &o.UserID, &o.ProductID, &o.Amount, &o.Status, &o.CreatedAt)

 if err != nil {
 return err
 }

 rsp.Order = &o
 return nil
}

func main() {
 db, err := sql.Open("postgres", "postgres://user:pass@localhost/orders?sslmode=disable")
 if err != nil {
 panic(err)
 }
 defer db.Close()

 svc := micro.NewService("orders",
 micro.Version("1.0.0"),
 )

 svc.Init()

 server.RegisterHandler(svc.Server(), &OrdersService{
 db: db,
 client: svc.Client(),
 })

 if err := svc.Run(); err != nil {
 panic(err)
 }
}

3. API Gateway

// gateway/main.go
package main

import (
 "encoding/json"
 "net/http"
 "strconv"
 "go-micro.dev/v6"
 "go-micro.dev/v6/client"
)

type Gateway struct {
 client client.Client
}

func (g *Gateway) GetUser(w http.ResponseWriter, r *http.Request) {
 idStr := r.URL.Query().Get("id")
 id, err := strconv.ParseInt(idStr, 10, 64)
 if err != nil {
 http.Error(w, "invalid id", http.StatusBadRequest)
 return
 }

 req := g.client.NewRequest("users", "UsersService.Get", &struct{ ID int64 }{ID: id})
 rsp := &struct{ User interface{} }{}

 if err := g.client.Call(r.Context(), req, rsp); err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 w.Header().Set("Content-Type", "application/json")
 json.NewEncoder(w).Encode(rsp)
}

func (g *Gateway) CreateOrder(w http.ResponseWriter, r *http.Request) {
 var body struct {
 UserID int64 `json:"user_id"`
 ProductID int64 `json:"product_id"`
 Amount float64 `json:"amount"`
 }

 if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 http.Error(w, "invalid request", http.StatusBadRequest)
 return
 }

 req := g.client.NewRequest("orders", "OrdersService.Create", body)
 rsp := &struct{ Order interface{} }{}

 if err := g.client.Call(r.Context(), req, rsp); err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 w.Header().Set("Content-Type", "application/json")
 w.WriteHeader(http.StatusCreated)
 json.NewEncoder(w).Encode(rsp)
}

func main() {
 svc := micro.NewService("api.gateway",
 )
 svc.Init()

 gw := &Gateway{client: svc.Client()}

 http.HandleFunc("/users", gw.GetUser)
 http.HandleFunc("/orders", gw.CreateOrder)

 http.ListenAndServe(":8080", nil)
}

Running the Example

Development (Local)

# Terminal 1: Users service
cd services/users
go run main.go

# Terminal 2: Products service
cd services/products
go run main.go

# Terminal 3: Orders service
cd services/orders
go run main.go

# Terminal 4: API Gateway
cd gateway
go run main.go

Testing

# Get user
curl http://localhost:8080/users?id=1

# Create order
curl -X POST http://localhost:8080/orders \
 -H 'Content-Type: application/json' \
 -d '{"user_id": 1, "product_id": 100, "amount": 99.99}'

Docker Compose

version: '3.8'

services:
 postgres:
 image: postgres:15
 environment:
 POSTGRES_PASSWORD: secret
 ports:
 - "5432:5432"

 users:
 build: ./services/users
 environment:
 MICRO_REGISTRY: nats
 MICRO_REGISTRY_ADDRESS: nats://nats:4222
 DATABASE_URL: postgres://postgres:secret@postgres/users
 depends_on:
 - postgres
 - nats

 products:
 build: ./services/products
 environment:
 MICRO_REGISTRY: nats
 MICRO_REGISTRY_ADDRESS: nats://nats:4222
 DATABASE_URL: postgres://postgres:secret@postgres/products
 depends_on:
 - postgres
 - nats

 orders:
 build: ./services/orders
 environment:
 MICRO_REGISTRY: nats
 MICRO_REGISTRY_ADDRESS: nats://nats:4222
 DATABASE_URL: postgres://postgres:secret@postgres/orders
 depends_on:
 - postgres
 - nats

 gateway:
 build: ./gateway
 ports:
 - "8080:8080"
 environment:
 MICRO_REGISTRY: nats
 MICRO_REGISTRY_ADDRESS: nats://nats:4222
 depends_on:
 - users
 - products
 - orders

 nats:
 image: nats:latest
 ports:
 - "4222:4222"

Run with:

Architecture Decision Records

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

Documentation of architectural decisions made in Go Micro, following the ADR pattern.

What are ADRs?

Architecture Decision Records (ADRs) capture important architectural decisions along with their context and consequences. They help understand why certain design choices were made.

Index

Available

Planned

Core Design

ADR-002: Interface-First Design
ADR-003: Default Implementations

Service Discovery

Atlas Cloud Integration

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

Atlas Cloud Integration Guide

Atlas Cloud is an enterprise AI infrastructure platform offering 300+ models across text, image, and video through a unified, OpenAI-compatible API. It is an official Go Micro sponsor and a first-class provider in the ai package.

Quick Start

Install or update Go Micro:

go get go-micro.dev/v6@latest

Import the Atlas Cloud provider and use it:

package main

import (
 "context"
 "fmt"
 "log"

 "go-micro.dev/v6/ai"
 _ "go-micro.dev/v6/ai/atlascloud"
)

func main() {
 m := ai.New("atlascloud",
 ai.WithAPIKey("your-atlas-cloud-key"),
 )

 resp, err := m.Generate(context.Background(), &ai.Request{
 Prompt: "What is Go Micro?",
 SystemPrompt: "You are a helpful assistant.",
 })
 if err != nil {
 log.Fatal(err)
 }

 fmt.Println(resp.Reply)
}

Configuration

Options

Option	Default	Description
`ai.WithAPIKey(key)`	required	Your Atlas Cloud API key
`ai.WithModel(name)`	`llama-3.3-70b`	Model to use (see Model Selection)
`ai.WithBaseURL(url)`	`https://api.atlascloud.ai`	API base URL

Environment Variables

The micro chat CLI and micro run / micro server read configuration from environment variables:

Best Practices for Tool Descriptions

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

Your Go doc comments become the documentation that AI agents read when deciding how to call your service. Better descriptions lead to fewer errors, faster task completion, and a better user experience.

How Agents Use Your Docs

When an AI agent receives a user request like “create a task for Alice”, it:

Queries the MCP tools endpoint for available tools
Reads each tool’s description to understand what it does
Reads the parameter schema and descriptions to build the input
References the example to verify the format
Makes the call

If any of these are missing or unclear, the agent guesses — and often guesses wrong.

Broker

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

The broker provides pub/sub messaging for Go Micro services.

Features

Publish messages to topics
Subscribe to topics
Multiple broker implementations

Implementations

Supported brokers include:

HTTP (default)
NATS (go-micro.dev/v6/broker/nats)
RabbitMQ (go-micro.dev/v6/broker/rabbitmq)
Memory (go-micro.dev/v6/broker/memory)

Plugins are scoped under go-micro.dev/v6/broker/<plugin>.

Configure the broker in code or via environment variables.

Example Usage

Here’s how to use the broker in your Go Micro service:

Building AI-Native Services

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

This guide walks you through building a Go Micro service that is AI-native from the start — meaning AI agents can discover, understand, and call your service automatically via the Model Context Protocol (MCP).

What You’ll Build

A task management service with full CRUD operations that:

Exposes every endpoint as an MCP tool automatically
Has rich documentation that agents can read
Includes auth scopes for write operations
Works with Claude Code, the agent playground, and any MCP client

Prerequisites

go install go-micro.dev/v6/cmd/micro@latest

Step 1: Create the Service

micro new tasks
cd tasks

Step 2: Define Your Types

Design your request/response types with description tags. These tags become parameter descriptions that agents read:

CLI & Gateway Guide

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

The Go Micro CLI provides two gateway modes for accessing your microservices: development (micro run) and production (micro server). Both use the same underlying gateway architecture, ensuring consistent behavior across environments.

Overview

 ┌─────────────────────┐
 │ HTTP Requests │
 └──────────┬──────────┘
 │
 ┌──────────▼──────────┐
 │ Unified Gateway │
 │ │
 │ • Service Discovery│
 │ • HTTP → RPC │
 │ • Web Dashboard │
 │ • Health Checks │
 └──────────┬──────────┘
 │
 ┌──────────▼──────────┐
 │ Your Services │
 │ (via Registry) │
 └─────────────────────┘

Quick Comparison

Feature	`micro run`	`micro server`
Purpose	Local development	Production API gateway
Authentication	Yes (default `admin`/`micro`)	Yes (default `admin`/`micro`)
Process Management	Yes (builds & runs services)	No (services run separately)
Hot Reload	Yes (watches file changes)	No
Endpoint Scopes	Yes (`/auth/scopes`)	Yes (`/auth/scopes`)
Best For	Coding, testing, iteration	Deployed environments

Development Mode: `micro run`

Quick Start

# Create and run a service
micro new myservice
cd myservice
micro run

Open http://localhost:8080 - no login required!

Client/Server

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

Go Micro uses a client/server model for RPC communication between services.

Client

The client is used to make requests to other services.

Server

The server handles incoming requests.

Both client and server are pluggable and support middleware wrappers for additional functionality.

Example Usage

Here’s how to define a simple handler and register it with a Go Micro server:

package main

import (
 "context"
 "go-micro.dev/v6"
 "log"
)

type Greeter struct{}

func (g *Greeter) Hello(ctx context.Context, req *struct{}, rsp *struct{Msg string}) error {
 rsp.Msg = "Hello, world!"
 return nil
}

func main() {
 service := micro.NewService("greeter",
 )
 service.Init()
 micro.RegisterHandler(service.Server(), new(Greeter))
 if err := service.Run(); err != nil {
 log.Fatal(err)
 }
}

Commercial Support

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

Go Micro is free and open source. There are two ways to get help: the community, and commercial support.

Community support (free)

Documentation — /docs
Examples — github.com/micro/go-micro/tree/master/examples
Bugs & features — github.com/micro/go-micro/issues
Questions — open a Question issue

Community support is best-effort, from maintainers and contributors, with no response-time guarantees.

Commercial support

If you’re running Go Micro in production — or building agents and services on it and want a hand — paid support and consulting are available directly from the maintainer. This is what keeps the project maintained.

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.

Contributing

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

This is a rendered copy of the repository CONTRIBUTING.md for convenient access via the documentation site.

Overview

Go Micro welcomes contributions of all kinds: code, documentation, examples, and plugins.

Quick Start

git clone https://github.com/micro/go-micro.git
cd go-micro
go mod download
go test ./...

Process

Fork and create a feature branch
Make focused changes with tests
Run linting and full test suite
Open a PR describing motivation and approach

Commit Format

Use conventional commits:

Contributing

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

Overview

Go Micro welcomes contributions of all kinds: code, documentation, examples, and plugins.

Quick Start

git clone --depth 1 https://github.com/micro/go-micro.git
cd go-micro
go mod download
go test ./...

Process

Fork and create a feature branch
Make focused changes with tests
Run linting and full test suite
Open a PR describing motivation and approach

Commit Format

Use conventional commits:

feat(registry): add consul health check
fix(broker): prevent reconnect storm

Testing

Run unit tests:

Debugging your agent

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

Debugging your agent

Use this guide when an agent surprises you: it answered without using a service, called the wrong endpoint, looped, lost memory, refused a tool, or behaved differently when a flow handed work to it. The local inner loop is:

micro run # start services, agents, gateway, dashboard
micro chat # reproduce one turn
micro inspect ... # read the recorded run or workflow history

Debug the lifecycle in the same order Go Micro runs it: first prove the service is registered and callable, then inspect the agent run that chose tools, then inspect any workflow that handed off to the agent.

Deployment

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

Deploying Go Micro Services

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:

Deployment Guide

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

This is a quick reference for deploying go-micro services. For the full guide, see the Deployment documentation.

Workflow

micro run → Develop locally with hot reload
micro build → Compile production binaries
micro deploy → Push to a remote Linux server via SSH + systemd
micro server → Optional: production web dashboard with auth

Quick Start

# Build binaries for Linux
micro build --os linux

# Deploy to server (builds automatically if needed)
micro deploy user@your-server

First-Time Server Setup

On your server (any Linux with systemd):

Error Handling for AI Agents

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

Error Handling for AI Agents

When AI agents call your services through MCP, they need to understand errors well enough to recover or inform the user. This guide covers how to write services that give agents useful error information.

Use Typed Errors

Go Micro’s errors package provides structured errors that the MCP gateway forwards to agents with status codes and detail messages.

import "go-micro.dev/v6/errors"

func (s *Users) Get(ctx context.Context, req *GetRequest, rsp *GetResponse) error {
 if req.ID == "" {
 return errors.BadRequest("users.Get", "id is required")
 }

 user, err := s.db.FindUser(req.ID)
 if err != nil {
 return errors.NotFound("users.Get", "user %s not found", req.ID)
 }

 rsp.User = user
 return nil
}

Agents receive structured error responses like:

Framework Comparison

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

How Go Micro compares to other Go microservices frameworks.

Quick Comparison

Feature	Go Micro	go-kit	gRPC	Dapr
Learning Curve	Low	High	Medium	Medium
Boilerplate	Low	High	Medium	Low
Plugin System	Built-in	External	Limited	Sidecar
Service Discovery	Yes (mDNS, Consul, etc)	No (BYO)	No	Yes
Load Balancing	Client-side	No	No	Sidecar
Pub/Sub	Yes	No	No	Yes
Transport	HTTP, gRPC, NATS	BYO	gRPC only	HTTP, gRPC
Zero-config Dev	Yes (mDNS)	No	No	No (needs sidecar)
Production Ready	Yes	Yes	Yes	Yes
Language	Go only	Go only	Multi-language	Multi-language

vs go-kit

go-kit Philosophy

“Just a toolkit” - minimal opinions
Compose your own framework
Maximum flexibility
Requires more decisions upfront

Go Micro Philosophy

“Batteries included” - opinionated defaults
Swap components as needed
Progressive complexity
Get started fast, customize later

When to Choose go-kit

You want complete control over architecture
You have strong opinions about structure
You’re building a custom framework
You prefer explicit over implicit

When to Choose Go Micro

You want to start coding immediately
You prefer conventions over decisions
You want built-in service discovery
You need pub/sub messaging

Code Comparison

go-kit (requires more setup):

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.
No LLM provider key is required for the first run below. Add an Anthropic, OpenAI, Gemini, or other provider key only when you reach the provider-backed generation and chat steps.

Install

# Binary (no Go required)
curl -fsSL https://go-micro.dev/install.sh | sh

# Or with Go
go install go-micro.dev/v6/cmd/micro@latest

If install or shell setup fails, start with Install troubleshooting to verify the binary installer or go install, PATH, micro --version, and the no-secret smoke path.

Go Micro Roadmap

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

Roadmap

This 2026 “AI-Native Era” roadmap has been superseded. Go Micro now has a single, current roadmap.

→ Read the roadmap

go-micro.dev/v4/api

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

go-micro.dev/v4/api/client

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

go-micro.dev/v4/api/handler

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

go-micro.dev/v4/api/handler/api

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

go-micro.dev/v4/api/handler/event

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

go-micro.dev/v4/api/handler/http

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

go-micro.dev/v4/api/handler/rpc

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

go-micro.dev/v4/api/handler/web

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

go-micro.dev/v4/api/internal/proto

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

go-micro.dev/v4/api/proto

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

go-micro.dev/v4/api/resolver

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

go-micro.dev/v4/api/resolver/grpc

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

go-micro.dev/v4/api/resolver/host

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

go-micro.dev/v4/api/resolver/path

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

go-micro.dev/v4/api/resolver/vpath

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

go-micro.dev/v4/api/router

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

go-micro.dev/v4/api/router/registry

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

go-micro.dev/v4/api/router/static

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

go-micro.dev/v4/api/router/util

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

go-micro.dev/v4/api/server

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

go-micro.dev/v4/api/server/acme

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

go-micro.dev/v4/api/server/acme/autocert

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

go-micro.dev/v4/api/server/cors

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

go-micro.dev/v4/api/server/http

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

go-micro.dev/v4/auth

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

go-micro.dev/v4/broker

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

go-micro.dev/v4/cache

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

go-micro.dev/v4/client

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

go-micro.dev/v4/codec

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

go-micro.dev/v4/codec/bytes

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

go-micro.dev/v4/codec/grpc

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

go-micro.dev/v4/codec/json

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

go-micro.dev/v4/codec/jsonrpc

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

go-micro.dev/v4/codec/proto

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

go-micro.dev/v4/codec/protorpc

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

go-micro.dev/v4/codec/text

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

go-micro.dev/v4/config

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

go-micro.dev/v4/config/encoder

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

go-micro.dev/v4/config/encoder/json

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

go-micro.dev/v4/config/loader

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

go-micro.dev/v4/config/loader/memory

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

go-micro.dev/v4/config/reader

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

go-micro.dev/v4/config/reader/json

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

go-micro.dev/v4/config/secrets

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

go-micro.dev/v4/config/secrets/box

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

go-micro.dev/v4/config/secrets/secretbox

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

go-micro.dev/v4/config/source

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

go-micro.dev/v4/config/source/cli

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

go-micro.dev/v4/config/source/env

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

go-micro.dev/v4/config/source/file

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

go-micro.dev/v4/config/source/flag

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

go-micro.dev/v4/config/source/memory

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

go-micro.dev/v4/debug/handler

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

go-micro.dev/v4/debug/log

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

go-micro.dev/v4/debug/log/memory

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

go-micro.dev/v4/debug/log/noop

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

go-micro.dev/v4/debug/profile

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

go-micro.dev/v4/debug/profile/http

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

go-micro.dev/v4/debug/profile/pprof

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

go-micro.dev/v4/debug/proto

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

go-micro.dev/v4/debug/stats

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

go-micro.dev/v4/debug/trace

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

go-micro.dev/v4/errors

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

go-micro.dev/v4/events

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

go-micro.dev/v4/logger

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

go-micro.dev/v4/metadata

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

go-micro.dev/v4/registry

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

go-micro.dev/v4/registry/cache

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

go-micro.dev/v4/runtime

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

go-micro.dev/v4/runtime/kubernetes

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

go-micro.dev/v4/runtime/local

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

go-micro.dev/v4/runtime/local/build

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

go-micro.dev/v4/runtime/local/build/docker

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

go-micro.dev/v4/runtime/local/build/go

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

go-micro.dev/v4/runtime/local/git

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

go-micro.dev/v4/runtime/local/process

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

go-micro.dev/v4/runtime/local/process/os

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

go-micro.dev/v4/runtime/local/source

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

go-micro.dev/v4/runtime/local/source/git

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

go-micro.dev/v4/runtime/local/source/go

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

go-micro.dev/v4/selector

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

go-micro.dev/v4/server

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

go-micro.dev/v4/server/mock

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

go-micro.dev/v4/server/proto

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

go-micro.dev/v4/store

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

go-micro.dev/v4/sync

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

go-micro.dev/v4/test

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

go-micro.dev/v4/transport

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

go-micro.dev/v4/transport/headers

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

go-micro.dev/v4/util/addr

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

go-micro.dev/v4/util/backoff

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

go-micro.dev/v4/util/buf

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

go-micro.dev/v4/util/cmd

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

go-micro.dev/v4/util/ctx

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

go-micro.dev/v4/util/file

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

go-micro.dev/v4/util/file/proto

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

go-micro.dev/v4/util/grpc

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

go-micro.dev/v4/util/http

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

go-micro.dev/v4/util/io

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

go-micro.dev/v4/util/jitter

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

go-micro.dev/v4/util/kubernetes/api

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

go-micro.dev/v4/util/kubernetes/client

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

go-micro.dev/v4/util/mdns

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

go-micro.dev/v4/util/net

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

go-micro.dev/v4/util/pki

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

go-micro.dev/v4/util/pool

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

go-micro.dev/v4/util/qson

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

go-micro.dev/v4/util/registry

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

go-micro.dev/v4/util/ring

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

go-micro.dev/v4/util/signal

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

go-micro.dev/v4/util/socket

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

go-micro.dev/v4/util/stream

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

go-micro.dev/v4/util/sync

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

go-micro.dev/v4/util/test

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

go-micro.dev/v4/util/tls

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

go-micro.dev/v4/util/wrapper

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

go-micro.dev/v4/web

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

go-micro.dev/v5/agent

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

go-micro.dev/v5/agent/proto

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

go-micro.dev/v5/ai

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

go-micro.dev/v5/ai/anthropic

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

go-micro.dev/v5/ai/atlascloud

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

go-micro.dev/v5/ai/flow

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

go-micro.dev/v5/ai/gemini

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

go-micro.dev/v5/ai/groq

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

go-micro.dev/v5/ai/mistral

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

go-micro.dev/v5/ai/openai

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

go-micro.dev/v5/ai/together

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

go-micro.dev/v5/auth

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

go-micro.dev/v5/auth/jwt

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

go-micro.dev/v5/auth/jwt/token

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

go-micro.dev/v5/auth/noop

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

go-micro.dev/v5/broker

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

go-micro.dev/v5/broker/nats

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

go-micro.dev/v5/broker/rabbitmq

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

go-micro.dev/v5/cache

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

go-micro.dev/v5/cache/redis

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

go-micro.dev/v5/client

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

go-micro.dev/v5/client/grpc

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

go-micro.dev/v5/cmd

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

go-micro.dev/v5/cmd/micro

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

go-micro.dev/v5/cmd/micro-mcp-gateway

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

go-micro.dev/v5/cmd/micro/a2a

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

go-micro.dev/v5/cmd/micro/api

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

go-micro.dev/v5/cmd/micro/chat

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

go-micro.dev/v5/cmd/micro/cli

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

go-micro.dev/v5/cmd/micro/cli/agent

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

go-micro.dev/v5/cmd/micro/cli/build

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

go-micro.dev/v5/cmd/micro/cli/deploy

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

go-micro.dev/v5/cmd/micro/cli/gen

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

go-micro.dev/v5/cmd/micro/cli/generate

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

go-micro.dev/v5/cmd/micro/cli/init

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

go-micro.dev/v5/cmd/micro/cli/new

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

go-micro.dev/v5/cmd/micro/cli/new/template

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

go-micro.dev/v5/cmd/micro/cli/remote

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

go-micro.dev/v5/cmd/micro/cli/util

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

go-micro.dev/v5/cmd/micro/flow

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

go-micro.dev/v5/cmd/micro/mcp

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

go-micro.dev/v5/cmd/micro/resource

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

go-micro.dev/v5/cmd/micro/run

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

go-micro.dev/v5/cmd/micro/run/config

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

go-micro.dev/v5/cmd/micro/run/watcher

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

go-micro.dev/v5/cmd/micro/server

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

go-micro.dev/v5/cmd/protoc-gen-micro

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

go-micro.dev/v5/cmd/protoc-gen-micro/examples/greeter

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

go-micro.dev/v5/cmd/protoc-gen-micro/generator

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

go-micro.dev/v5/cmd/protoc-gen-micro/plugin/micro

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

go-micro.dev/v5/codec

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

go-micro.dev/v5/codec/bytes

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

go-micro.dev/v5/codec/grpc

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

go-micro.dev/v5/codec/json

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

go-micro.dev/v5/codec/jsonrpc

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

go-micro.dev/v5/codec/proto

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

go-micro.dev/v5/codec/protorpc

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

go-micro.dev/v5/codec/text

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

go-micro.dev/v5/config

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

go-micro.dev/v5/config/encoder

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

go-micro.dev/v5/config/encoder/json

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

go-micro.dev/v5/config/loader

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

go-micro.dev/v5/config/loader/memory

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

go-micro.dev/v5/config/reader

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

go-micro.dev/v5/config/reader/json

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

go-micro.dev/v5/config/secrets

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

go-micro.dev/v5/config/secrets/box

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

go-micro.dev/v5/config/secrets/secretbox

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

go-micro.dev/v5/config/source

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

go-micro.dev/v5/config/source/cli

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

go-micro.dev/v5/config/source/env

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

go-micro.dev/v5/config/source/file

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

go-micro.dev/v5/config/source/flag

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

go-micro.dev/v5/config/source/memory

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

go-micro.dev/v5/config/source/nats

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

go-micro.dev/v5/debug/handler

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

go-micro.dev/v5/debug/log

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

go-micro.dev/v5/debug/log/memory

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

go-micro.dev/v5/debug/log/noop

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

go-micro.dev/v5/debug/profile

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

go-micro.dev/v5/debug/profile/http

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

go-micro.dev/v5/debug/profile/pprof

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

go-micro.dev/v5/debug/proto

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

go-micro.dev/v5/debug/stats

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

go-micro.dev/v5/debug/trace

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

go-micro.dev/v5/errors

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

go-micro.dev/v5/events

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

go-micro.dev/v5/events/natsjs

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

go-micro.dev/v5/examples/agent-demo

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

go-micro.dev/v5/examples/agent-plan-delegate

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

go-micro.dev/v5/examples/agent-wrap-tool

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

go-micro.dev/v5/examples/auth/client

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

go-micro.dev/v5/examples/auth/proto

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

go-micro.dev/v5/examples/auth/server

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

go-micro.dev/v5/examples/flow-durable

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

go-micro.dev/v5/examples/graceful-stop

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

go-micro.dev/v5/examples/grpc-interop/client

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

go-micro.dev/v5/examples/grpc-interop/proto

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

go-micro.dev/v5/examples/grpc-interop/server

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

go-micro.dev/v5/examples/hello-world

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

go-micro.dev/v5/examples/mcp/crud

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

go-micro.dev/v5/examples/mcp/documented

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

go-micro.dev/v5/examples/mcp/hello

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

go-micro.dev/v5/examples/mcp/platform

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

go-micro.dev/v5/examples/mcp/workflow

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

go-micro.dev/v5/examples/multi-service

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

go-micro.dev/v5/examples/web-service

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

go-micro.dev/v5/flow

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

go-micro.dev/v5/gateway/a2a

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

go-micro.dev/v5/gateway/api

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

go-micro.dev/v5/gateway/mcp

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

go-micro.dev/v5/health

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

go-micro.dev/v5/internal/harness/agent-flow

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

go-micro.dev/v5/internal/harness/plan-delegate

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

go-micro.dev/v5/internal/harness/universe

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

go-micro.dev/v5/internal/test

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

go-micro.dev/v5/internal/util/addr

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

go-micro.dev/v5/internal/util/backoff

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

go-micro.dev/v5/internal/util/buf

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

go-micro.dev/v5/internal/util/grpc

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

go-micro.dev/v5/internal/util/http

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

go-micro.dev/v5/internal/util/jitter

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

go-micro.dev/v5/internal/util/mdns

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

go-micro.dev/v5/internal/util/net

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

go-micro.dev/v5/internal/util/pool

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

go-micro.dev/v5/internal/util/registry

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

go-micro.dev/v5/internal/util/ring

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

go-micro.dev/v5/internal/util/signal

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

go-micro.dev/v5/internal/util/socket

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

go-micro.dev/v5/internal/util/test

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

go-micro.dev/v5/internal/util/tls

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

go-micro.dev/v5/internal/util/wrapper

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

go-micro.dev/v5/logger

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

go-micro.dev/v5/metadata

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

go-micro.dev/v5/model

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

go-micro.dev/v5/model/memory

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

go-micro.dev/v5/model/postgres

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

go-micro.dev/v5/model/sqlite

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

go-micro.dev/v5/registry

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

go-micro.dev/v5/registry/cache

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

go-micro.dev/v5/registry/consul

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

go-micro.dev/v5/registry/etcd

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

go-micro.dev/v5/registry/nats

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

go-micro.dev/v5/selector

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

go-micro.dev/v5/server

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

go-micro.dev/v5/server/grpc

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

go-micro.dev/v5/server/mock

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

go-micro.dev/v5/server/proto

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

go-micro.dev/v5/service

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

go-micro.dev/v5/service/profile

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

go-micro.dev/v5/store

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

go-micro.dev/v5/store/mysql

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

go-micro.dev/v5/store/nats-js-kv

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

go-micro.dev/v5/store/postgres

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

go-micro.dev/v5/store/postgres/pgx

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

go-micro.dev/v5/transport

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

go-micro.dev/v5/transport/grpc

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

go-micro.dev/v5/transport/grpc/proto

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

go-micro.dev/v5/transport/headers

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

go-micro.dev/v5/transport/nats

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

go-micro.dev/v5/web

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

go-micro.dev/v5/wrapper/auth

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

go-micro.dev/v5/wrapper/monitoring/prometheus

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

go-micro.dev/v5/wrapper/trace/opentelemetry

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

go-micro.dev/v5/wrapper/x402

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

go-micro.dev/v6/agent

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

go-micro.dev/v6/agent/proto

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

go-micro.dev/v6/ai

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

go-micro.dev/v6/ai/anthropic

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

go-micro.dev/v6/ai/atlascloud

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

go-micro.dev/v6/ai/gemini

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

go-micro.dev/v6/ai/groq

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

go-micro.dev/v6/ai/internal/openaiapi

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

go-micro.dev/v6/ai/minimax

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

go-micro.dev/v6/ai/mistral

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

go-micro.dev/v6/ai/ollama

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

go-micro.dev/v6/ai/openai

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

go-micro.dev/v6/ai/together

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

go-micro.dev/v6/auth

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

go-micro.dev/v6/auth/jwt

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

go-micro.dev/v6/auth/jwt/token

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

go-micro.dev/v6/auth/noop

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

go-micro.dev/v6/broker

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

go-micro.dev/v6/broker/nats

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

go-micro.dev/v6/broker/rabbitmq

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

go-micro.dev/v6/cache

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

go-micro.dev/v6/cache/redis

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

go-micro.dev/v6/client

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

go-micro.dev/v6/client/grpc

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

go-micro.dev/v6/cmd

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

go-micro.dev/v6/cmd/micro

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

go-micro.dev/v6/cmd/micro-mcp-gateway

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

go-micro.dev/v6/cmd/micro/a2a

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

go-micro.dev/v6/cmd/micro/ai

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

go-micro.dev/v6/cmd/micro/api

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

go-micro.dev/v6/cmd/micro/chat

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

go-micro.dev/v6/cmd/micro/cli

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

go-micro.dev/v6/cmd/micro/cli/agent

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

go-micro.dev/v6/cmd/micro/cli/build

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

go-micro.dev/v6/cmd/micro/cli/deploy

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

go-micro.dev/v6/cmd/micro/cli/gen

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

go-micro.dev/v6/cmd/micro/cli/generate

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

go-micro.dev/v6/cmd/micro/cli/init

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

go-micro.dev/v6/cmd/micro/cli/new

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

go-micro.dev/v6/cmd/micro/cli/new/template

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

go-micro.dev/v6/cmd/micro/cli/remote

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

go-micro.dev/v6/cmd/micro/cli/util

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

go-micro.dev/v6/cmd/micro/flow

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

go-micro.dev/v6/cmd/micro/inspect

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

go-micro.dev/v6/cmd/micro/loop

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

go-micro.dev/v6/cmd/micro/mcp

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

go-micro.dev/v6/cmd/micro/resource

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

go-micro.dev/v6/cmd/micro/run

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

go-micro.dev/v6/cmd/micro/run/config

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

go-micro.dev/v6/cmd/micro/run/watcher

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

go-micro.dev/v6/cmd/micro/server

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

go-micro.dev/v6/cmd/protoc-gen-micro

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

go-micro.dev/v6/cmd/protoc-gen-micro/examples/greeter

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

go-micro.dev/v6/cmd/protoc-gen-micro/generator

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

go-micro.dev/v6/cmd/protoc-gen-micro/plugin/micro

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

go-micro.dev/v6/codec

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

go-micro.dev/v6/codec/bytes

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

go-micro.dev/v6/codec/grpc

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

go-micro.dev/v6/codec/json

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

go-micro.dev/v6/codec/jsonrpc

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

go-micro.dev/v6/codec/proto

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

go-micro.dev/v6/codec/protorpc

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

go-micro.dev/v6/codec/text

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

go-micro.dev/v6/config

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

go-micro.dev/v6/config/encoder

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

go-micro.dev/v6/config/encoder/json

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

go-micro.dev/v6/config/loader

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

go-micro.dev/v6/config/loader/memory

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

go-micro.dev/v6/config/reader

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

go-micro.dev/v6/config/reader/json

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

go-micro.dev/v6/config/secrets

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

go-micro.dev/v6/config/secrets/box

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

go-micro.dev/v6/config/secrets/secretbox

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

go-micro.dev/v6/config/source

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

go-micro.dev/v6/config/source/cli

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

go-micro.dev/v6/config/source/env

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

go-micro.dev/v6/config/source/file

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

go-micro.dev/v6/config/source/flag

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

go-micro.dev/v6/config/source/memory

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

go-micro.dev/v6/config/source/nats

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

go-micro.dev/v6/debug/handler

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

go-micro.dev/v6/debug/log

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

go-micro.dev/v6/debug/log/memory

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

go-micro.dev/v6/debug/log/noop

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

go-micro.dev/v6/debug/profile

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

go-micro.dev/v6/debug/profile/http

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

go-micro.dev/v6/debug/profile/pprof

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

go-micro.dev/v6/debug/proto

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

go-micro.dev/v6/debug/stats

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

go-micro.dev/v6/debug/trace

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

go-micro.dev/v6/deploy/kubernetes

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

go-micro.dev/v6/errors

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

go-micro.dev/v6/events

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

go-micro.dev/v6/events/natsjs

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

go-micro.dev/v6/examples/agent-demo

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

go-micro.dev/v6/examples/agent-durable

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

go-micro.dev/v6/examples/agent-ollama

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

go-micro.dev/v6/examples/agent-plan-delegate

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

go-micro.dev/v6/examples/agent-wrap-tool

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

go-micro.dev/v6/examples/agent-x402-buyer

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

go-micro.dev/v6/examples/auth/client

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

go-micro.dev/v6/examples/auth/proto

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

go-micro.dev/v6/examples/auth/server

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

go-micro.dev/v6/examples/first-agent

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

go-micro.dev/v6/examples/flow-durable

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

go-micro.dev/v6/examples/flow-loop

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

go-micro.dev/v6/examples/graceful-stop

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

go-micro.dev/v6/examples/grpc-interop/client

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

go-micro.dev/v6/examples/grpc-interop/proto

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

go-micro.dev/v6/examples/grpc-interop/server

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

go-micro.dev/v6/examples/hello-world

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

go-micro.dev/v6/examples/mcp/crud

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

go-micro.dev/v6/examples/mcp/documented

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

go-micro.dev/v6/examples/mcp/hello

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

go-micro.dev/v6/examples/mcp/platform

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

go-micro.dev/v6/examples/mcp/workflow

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

go-micro.dev/v6/examples/multi-service

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

go-micro.dev/v6/examples/support

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

go-micro.dev/v6/examples/web-service

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

go-micro.dev/v6/flow

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

go-micro.dev/v6/gateway/a2a

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

go-micro.dev/v6/gateway/api

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

go-micro.dev/v6/gateway/mcp

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

go-micro.dev/v6/health

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

go-micro.dev/v6/internal/harness/a2a-stream-fallback

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

go-micro.dev/v6/internal/harness/a2a-streaming

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

go-micro.dev/v6/internal/harness/agent-flow

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

go-micro.dev/v6/internal/harness/harnessutil

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

go-micro.dev/v6/internal/harness/plan-delegate

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

go-micro.dev/v6/internal/harness/provider-conformance

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

go-micro.dev/v6/internal/harness/universe

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

go-micro.dev/v6/internal/network

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

go-micro.dev/v6/internal/test

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

go-micro.dev/v6/internal/util/addr

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

go-micro.dev/v6/internal/util/backoff

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

go-micro.dev/v6/internal/util/buf

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

go-micro.dev/v6/internal/util/grpc

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

go-micro.dev/v6/internal/util/http

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

go-micro.dev/v6/internal/util/jitter

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

go-micro.dev/v6/internal/util/mdns

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

go-micro.dev/v6/internal/util/net

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

go-micro.dev/v6/internal/util/pool

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

go-micro.dev/v6/internal/util/registry

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

go-micro.dev/v6/internal/util/ring

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

go-micro.dev/v6/internal/util/signal

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

go-micro.dev/v6/internal/util/socket

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

go-micro.dev/v6/internal/util/test

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

go-micro.dev/v6/internal/util/tls

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

go-micro.dev/v6/internal/util/wrapper

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

go-micro.dev/v6/logger

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

go-micro.dev/v6/metadata

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

go-micro.dev/v6/model

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

go-micro.dev/v6/model/memory

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

go-micro.dev/v6/model/postgres

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

go-micro.dev/v6/model/sqlite

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

go-micro.dev/v6/registry

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

go-micro.dev/v6/registry/cache

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

go-micro.dev/v6/registry/consul

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

go-micro.dev/v6/registry/etcd

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

go-micro.dev/v6/registry/nats

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

go-micro.dev/v6/selector

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

go-micro.dev/v6/server

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

go-micro.dev/v6/server/grpc

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

go-micro.dev/v6/server/mock

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

go-micro.dev/v6/server/proto

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

go-micro.dev/v6/service

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

go-micro.dev/v6/service/profile

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

go-micro.dev/v6/store

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

go-micro.dev/v6/store/mysql

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

go-micro.dev/v6/store/nats-js-kv

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

go-micro.dev/v6/store/postgres

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

go-micro.dev/v6/store/postgres/pgx

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

go-micro.dev/v6/transport

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

go-micro.dev/v6/transport/grpc

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

go-micro.dev/v6/transport/grpc/proto

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

go-micro.dev/v6/transport/headers

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

go-micro.dev/v6/transport/nats

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

go-micro.dev/v6/web

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

go-micro.dev/v6/wrapper/auth

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

go-micro.dev/v6/wrapper/monitoring/prometheus

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

go-micro.dev/v6/wrapper/trace/opentelemetry

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

go-micro.dev/v6/wrapper/x402

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

Graceful Shutdown

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

Properly shutting down services to avoid dropped requests and data loss.

The Problem

Without graceful shutdown:

In-flight requests are dropped
Database connections leak
Resources aren’t cleaned up
Load balancers don’t know service is down

Solution

Go Micro handles SIGTERM/SIGINT by default, but you need to implement cleanup logic.

Basic Pattern

package main

import (
 "context"
 "os"
 "os/signal"
 "syscall"
 "time"
 "go-micro.dev/v6"
 "go-micro.dev/v6/logger"
)

func main() {
 svc := micro.NewService("myservice",
 micro.BeforeStop(func() error {
 logger.Info("Service stopping, running cleanup...")
 return cleanup()
 }),
 )

 svc.Init()

 // Your service logic
 if err := svc.Handle(new(Handler)); err != nil {
 logger.Fatal(err)
 }

 // Run with graceful shutdown
 if err := svc.Run(); err != nil {
 logger.Fatal(err)
 }

 logger.Info("Service stopped gracefully")
}

func cleanup() error {
 // Close database connections
 // Flush logs
 // Stop background workers
 // etc.
 return nil
}

Database Cleanup

type Service struct {
 db *sql.DB
}

func (s *Service) Shutdown(ctx context.Context) error {
 logger.Info("Closing database connections...")
 
 // Stop accepting new requests
 s.db.SetMaxOpenConns(0)
 
 // Wait for existing connections to finish (with timeout)
 done := make(chan struct{})
 go func() {
 s.db.Close()
 close(done)
 }()
 
 select {
 case <-done:
 logger.Info("Database closed gracefully")
 return nil
 case <-ctx.Done():
 logger.Warn("Database close timeout, forcing")
 return ctx.Err()
 }
}

Background Workers

type Worker struct {
 quit chan struct{}
 done chan struct{}
}

func (w *Worker) Start() {
 w.quit = make(chan struct{})
 w.done = make(chan struct{})
 
 go func() {
 defer close(w.done)
 ticker := time.NewTicker(5 * time.Second)
 defer ticker.Stop()
 
 for {
 select {
 case <-ticker.C:
 w.doWork()
 case <-w.quit:
 logger.Info("Worker stopping...")
 return
 }
 }
 }()
}

func (w *Worker) Stop(timeout time.Duration) error {
 close(w.quit)
 
 select {
 case <-w.done:
 logger.Info("Worker stopped gracefully")
 return nil
 case <-time.After(timeout):
 return fmt.Errorf("worker shutdown timeout")
 }
}

Complete Example

package main

import (
 "context"
 "database/sql"
 "fmt"
 "os"
 "os/signal"
 "sync"
 "syscall"
 "time"
 
 "go-micro.dev/v6"
 "go-micro.dev/v6/logger"
)

type Application struct {
 db *sql.DB
 workers []*Worker
 wg sync.WaitGroup
 mu sync.RWMutex
 closing bool
}

func NewApplication(db *sql.DB) *Application {
 return &Application{
 db: db,
 workers: make([]*Worker, 0),
 }
}

func (app *Application) AddWorker(w *Worker) {
 app.workers = append(app.workers, w)
 w.Start()
}

func (app *Application) Shutdown(ctx context.Context) error {
 app.mu.Lock()
 if app.closing {
 app.mu.Unlock()
 return nil
 }
 app.closing = true
 app.mu.Unlock()
 
 logger.Info("Starting graceful shutdown...")
 
 // Stop accepting new work
 logger.Info("Stopping workers...")
 for _, w := range app.workers {
 if err := w.Stop(5 * time.Second); err != nil {
 logger.Warnf("Worker failed to stop: %v", err)
 }
 }
 
 // Wait for in-flight requests (with timeout)
 shutdownComplete := make(chan struct{})
 go func() {
 app.wg.Wait()
 close(shutdownComplete)
 }()
 
 select {
 case <-shutdownComplete:
 logger.Info("All requests completed")
 case <-ctx.Done():
 logger.Warn("Shutdown timeout, forcing...")
 }
 
 // Close resources
 logger.Info("Closing database...")
 if err := app.db.Close(); err != nil {
 logger.Errorf("Database close error: %v", err)
 }
 
 logger.Info("Shutdown complete")
 return nil
}

func main() {
 db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
 if err != nil {
 logger.Fatal(err)
 }
 
 app := NewApplication(db)
 
 // Add background workers
 app.AddWorker(&Worker{name: "cleanup"})
 app.AddWorker(&Worker{name: "metrics"})
 
 svc := micro.NewService("myservice",
 micro.BeforeStop(func() error {
 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 defer cancel()
 return app.Shutdown(ctx)
 }),
 )
 
 svc.Init()
 
 handler := &Handler{app: app}
 if err := svc.Handle(handler); err != nil {
 logger.Fatal(err)
 }
 
 // Run service
 if err := svc.Run(); err != nil {
 logger.Fatal(err)
 }
}

Kubernetes Integration

Liveness and Readiness Probes

func (h *Handler) Health(ctx context.Context, req *struct{}, rsp *HealthResponse) error {
 // Liveness: is the service alive?
 rsp.Status = "ok"
 return nil
}

func (h *Handler) Ready(ctx context.Context, req *struct{}, rsp *ReadyResponse) error {
 h.app.mu.RLock()
 closing := h.app.closing
 h.app.mu.RUnlock()
 
 if closing {
 // Stop receiving traffic during shutdown
 return fmt.Errorf("shutting down")
 }
 
 // Check dependencies
 if err := h.app.db.Ping(); err != nil {
 return fmt.Errorf("database unhealthy: %w", err)
 }
 
 rsp.Status = "ready"
 return nil
}

Kubernetes Manifest

apiVersion: apps/v1
kind: Deployment
metadata:
 name: myservice
spec:
 replicas: 3
 template:
 spec:
 containers:
 - name: myservice
 image: myservice:latest
 ports:
 - containerPort: 8080
 livenessProbe:
 httpGet:
 path: /health
 port: 8080
 initialDelaySeconds: 10
 periodSeconds: 10
 readinessProbe:
 httpGet:
 path: /ready
 port: 8080
 initialDelaySeconds: 5
 periodSeconds: 5
 lifecycle:
 preStop:
 exec:
 # Give service time to drain before SIGTERM
 command: ["/bin/sh", "-c", "sleep 10"]
 terminationGracePeriodSeconds: 40

Best Practices

Set timeouts: Don’t wait forever for shutdown
Stop accepting work early: Set readiness to false
Drain in-flight requests: Let current work finish
Close resources properly: Databases, file handles, etc.
Log shutdown progress: Help debugging
Handle SIGTERM and SIGINT: Kubernetes sends SIGTERM
Coordinate with load balancer: Use readiness probes
Test shutdown: Regularly test graceful shutdown works

Testing Shutdown

# Start service
go run main.go &
PID=$!

# Send some requests
for i in {1..10}; do
 curl http://localhost:8080/endpoint &
done

# Trigger graceful shutdown
kill -TERM $PID

# Verify all requests completed
wait

Common Pitfalls

No timeout: Service hangs during shutdown
Not stopping workers: Background jobs continue
Database leaks: Connections not closed
Ignored signals: Service killed forcefully
No readiness probe: Traffic during shutdown

API Gateway Example - Multi-service architecture
Getting Started Guide - Basic service setup

Health Checks

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

The health package provides health check functionality for microservices, including Kubernetes-style liveness and readiness probes.

Quick Start

import "go-micro.dev/v6/health"

func main() {
 // Register health checks
 health.Register("database", health.PingCheck(db.Ping))
 health.Register("cache", health.TCPCheck("localhost:6379", time.Second))
 
 // Add health endpoints
 mux := http.NewServeMux()
 health.RegisterHandlers(mux) // Registers /health, /health/live, /health/ready
 
 http.ListenAndServe(":8080", mux)
}

Endpoints

Endpoint	Purpose	Returns 200 when
`/health`	Overall health status	All critical checks pass
`/health/live`	Kubernetes liveness probe	Service is running
`/health/ready`	Kubernetes readiness probe	All critical checks pass

Response Format

{
 "status": "up",
 "checks": [
 {
 "name": "database",
 "status": "up",
 "duration": 1234567
 },
 {
 "name": "cache",
 "status": "up", 
 "duration": 567890
 }
 ],
 "info": {
 "go_version": "go1.22.0",
 "go_os": "linux",
 "go_arch": "amd64",
 "version": "1.0.0"
 }
}

When unhealthy:

Hello Service

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

A minimal HTTP service using Go Micro, with a single endpoint.

Service

package main

import (
 "context"
 "go-micro.dev/v6"
)

type Request struct { Name string `json:"name"` }

type Response struct { Message string `json:"message"` }

type Say struct{}

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

func main() {
 svc := micro.NewService("helloworld")
 svc.Init()
 svc.Handle(new(Say))
 svc.Run()
}

Run it:

Hello Service

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

Service

package main

import (
 "context"
 "go-micro.dev/v6"
)

type Request struct { Name string `json:"name"` }

type Response struct { Message string `json:"message"` }

type Say struct{}

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

func main() {
 svc := micro.NewService("helloworld")
 svc.Init()
 svc.Handle(new(Say))
 svc.Run()
}

Run it:

Hosting

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

Hosting Go Micro Services

This document outlines what hosting looks like for go-micro services, the options available today, and what an ideal hosting platform would provide.

Overview

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.

Install troubleshooting

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

Install troubleshooting

Use this page before micro new or micro agent demo when the CLI install is unclear. The goal is to prove three boundaries in order: the micro binary is on PATH, it is the version you expected, and the no-secret first-run path works without provider keys.

1. Choose one install path

Binary installer (no Go required to install)

curl -fsSL https://go-micro.dev/install.sh | sh

Use this when you want the released micro binary without building it yourself. The generated services still need a Go toolchain when you run micro run, but the installer itself does not require Go.

MCP Security Guide

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

This guide covers how to secure your MCP gateway for production use, including authentication, per-tool scopes, rate limiting, and audit logging.

Overview

The MCP gateway provides four layers of security:

Authentication - Verify the caller’s identity via bearer tokens
Scopes - Control which tools each token can access
Rate Limiting - Prevent abuse with per-tool rate limits
Audit Logging - Record every tool call for compliance and debugging

Authentication

Bearer Token Auth

The MCP gateway uses bearer token authentication. Tokens are validated by the configured auth.Auth provider.

MCP Troubleshooting

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

MCP Troubleshooting

Common issues when using the MCP gateway and AI agents with Go Micro services.

Agent Can’t Find My Tools

Symptom: Agent says “no tools available” or doesn’t list your service endpoints.

Check 1: Is the service registered?

# List registered services
micro services

If your service isn’t listed, it hasn’t registered with the registry. Make sure your service is running and using the same registry as the MCP gateway.

micro run - Local Development

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

micro run provides a complete development environment for Go microservices.

Note: This guide focuses on micro run features. For a comparison with micro server and gateway architecture details, see the CLI & Gateway Guide.

Quick Start

micro new helloworld
cd helloworld
micro run

Open http://localhost:8080 to see your service.

What You Get

When you run micro run, you get:

URL	Description
http://localhost:8080	Web dashboard - browse and call services
http://localhost:8080/agent	Agent playground - AI chat with MCP tools
http://localhost:8080/api	API explorer - browse endpoints and schemas
http://localhost:8080/api/{service}/{method}	API gateway - HTTP to RPC proxy
http://localhost:8080/mcp/tools	MCP tools - list all services as AI tools
http://localhost:8080/auth/tokens	Token management - create and manage API tokens
http://localhost:8080/auth/scopes	Scope management - restrict endpoint access
http://localhost:8080/auth/users	User management - create and manage users
http://localhost:8080/health	Health checks - aggregated service health
http://localhost:8080/services	Service list - JSON

Plus:

Micro Server (Optional)

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

micro server does not build, run, or watch services. It only discovers services via the registry and provides a UI/API to interact with them.

micro server vs micro run

	`micro run`	`micro server`
Purpose	Local development	Production dashboard
Builds services	Yes	No
Runs services	Yes (as child processes)	No (discovers already-running services)
Hot reload	Yes	No
Authentication	Yes (default `admin`/`micro`)	Yes (default `admin`/`micro`)
Scopes	Yes (`/auth/scopes`)	Yes (`/auth/scopes`)
Dashboard	Full gateway UI with auth, scopes, agent	Full dashboard with API explorer, logs, user/token management
When to use	Day-to-day development	Deployed environments, shared servers

For local development, use micro run instead.

Migrating from gRPC

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

Step-by-step guide to migrating existing gRPC services to Go Micro.

Why Migrate?

Go Micro adds:

Built-in service discovery
Client-side load balancing
Pub/sub messaging
Multiple transport options
Unified tooling

You keep:

Your proto definitions
gRPC performance (via gRPC transport)
Type safety
Streaming support

Migration Strategy

Phase 1: Parallel Running

Run Go Micro alongside existing gRPC services

Phase 2: Gradual Migration

Migrate services one at a time

Migrating from v5 to v6

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

v6 is a small, mechanical upgrade. The bulk of it is the Go module path; the behavioral changes are two, both with a one-line fix.

1. Module path: `go-micro.dev/v6`

Go puts the major version in the import path, so every import changes:

// before
import "go-micro.dev/v5"
import "go-micro.dev/v5/server"

// after
import "go-micro.dev/v6"
import "go-micro.dev/v6/server"

A repo-wide find/replace does it:

grep -rl 'go-micro.dev/v5' --include='*.go' . \
 | xargs sed -i 's|go-micro.dev/v5|go-micro.dev/v6|g'
go mod tidy

Update the CLI too:

Model Context Protocol (MCP)

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

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:

Automatic service discovery via the registry
Dynamic tool generation from service endpoints
Stdio transport for local AI tools (Claude Code, etc.)
HTTP/SSE transport for web-based agents
Automatic documentation extraction from Go comments

Quick Start

1. Add Documentation to Your Service

Simply write Go doc comments on your handler methods:

Native gRPC Compatibility

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

This guide explains how to make your Go Micro services compatible with native gRPC clients like grpcurl, grpcui, or clients generated by the standard protoc gRPC plugin in any language.

Understanding Transport vs Server

Go Micro has two different gRPC-related concepts that are often confused:

gRPC Transport (`go-micro.dev/v6/transport/grpc`)

The gRPC transport uses the gRPC protocol as a communication layer, similar to how you might use NATS, RabbitMQ, or HTTP. It does not guarantee compatibility with native gRPC clients.

NATS Transport

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

Use NATS as the transport between services.

In code

package main

import (
 "go-micro.dev/v6"
 tnats "go-micro.dev/v6/transport/nats"
)

func main() {
 t := tnats.NewTransport()
 svc := micro.NewService("nats-transport", micro.Transport(t))
 svc.Init()
 svc.Run()
}

Via environment

Run your service with env vars set:

MICRO_TRANSPORT=nats MICRO_TRANSPORT_ADDRESS=nats://127.0.0.1:4222 go run main.go

No-secret first-agent transcript

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

This is the fastest first-agent success path when you do not have a provider key handy. It starts from the maintained examples/support app and uses the repository harness that CI already runs: real Go Micro services, registry, broker, client, store, agent loop, flow handoff, and guardrail code with only the LLM provider mocked.

Use it before the live-provider Your First Agent walkthrough when you want to see the services → agents → workflows lifecycle run end to end with no secrets.

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:

Payments (x402)

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

Go Micro can require a payment before a tool runs, using x402 — the open HTTP 402 Payment Required standard for stablecoin payments, designed for AI agents and onchain APIs. It lets every Go Micro endpoint, already exposed as an AI-callable tool, become a paid tool: a service answers a call with 402 and payment requirements, the client pays and retries, and the gateway verifies the payment before serving.

Payments are opt-in and dependency-light. Go Micro carries no chain or crypto code — it speaks the protocol and delegates verification and settlement to a pluggable facilitator (Coinbase CDP, Alchemy, or self-hosted), so Base and Solana are just different facilitators behind one interface.

Performance Considerations

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

Overview

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:

Plan & Delegate

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

Every Go Micro agent has two built-in capabilities, on top of the service tools it discovers:

plan — record an ordered plan in memory before doing multi-step work.
delegate — hand a self-contained subtask to another agent.

They are exposed to the model as ordinary tools. There is no separate graph runtime to configure — these harness capabilities are tools, and the agent calls them the same way it calls a service endpoint. They are added automatically to every agent, so you don’t wire anything up. micro chat exposes them too, so you get planning and delegation even when talking to your services directly.

Plugins

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

Plugins are scoped under each interface directory within this repository. To use a plugin, import it directly from the corresponding interface subpackage and pass it to your service via options.

Common interfaces and locations:

Registry: go-micro.dev/v6/registry/* (e.g. consul, etcd, nats, mdns)
Broker: go-micro.dev/v6/broker/* (e.g. nats, rabbitmq, http, memory)
Transport: go-micro.dev/v6/transport/* (e.g. nats, default http)
Server: go-micro.dev/v6/server/* (e.g. grpc for native gRPC compatibility)
Client: go-micro.dev/v6/client/* (e.g. grpc for native gRPC compatibility)
Store: go-micro.dev/v6/store/* (e.g. postgres, mysql, nats-js-kv, memory)
Auth, Cache, etc. follow the same pattern under their respective directories.

Registry Examples

Consul:

Provider Conformance Matrix

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

Go Micro treats model providers as interchangeable pieces of the same agent harness: services expose tools, agents reason over them, and workflows stitch the work together. The conformance harness keeps that promise honest by running the same deterministic services → agents → workflows scenarios against every configured provider.

The live harness is in internal/harness/provider-conformance. It skips providers without API keys by default, so it is safe to run locally, and it fails when any configured provider breaks the shared contract.

Pub/Sub with NATS Broker

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

Use the NATS broker for pub/sub.

In code

package main

import (
 "log"
 "go-micro.dev/v6"
 "go-micro.dev/v6/broker"
 bnats "go-micro.dev/v6/broker/nats"
)

func main() {
 b := bnats.NewNatsBroker()
 svc := micro.NewService("nats-pubsub", micro.Broker(b))
 svc.Init()

 // subscribe
 _, _ = broker.Subscribe("events", func(e broker.Event) error {
 log.Printf("received: %s", string(e.Message().Body))
 return nil
 })

 // publish
 _ = broker.Publish("events", &broker.Message{Body: []byte("hello")})

 svc.Run()
}

Via environment

Run your service with env vars set:

Quick Start

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

Install

go install go-micro.dev/v5/cmd/micro@v5.16.0

Note: Use a specific version instead of @latest to avoid module path conflicts. See releases for the latest version.

Create Your First Service

# Create a new service
micro new helloworld
cd helloworld

# Review the generated code
ls -la

# Run locally with hot reload
micro run

# Test it
curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
 -H "Content-Type: application/json" \
 -d '{"name": "World"}'

Next Steps

Full Tutorial - In-depth guide
Examples - Learn by example
API Reference - Complete API docs
Deployment - Deploy to production

Common Patterns

RPC Service

package main

import "go-micro.dev/v5"

type Greeter struct{}

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

func main() {
 service := micro.New("greeter")
 service.Handle(new(Greeter))
 service.Run()
}

Pub/Sub Event Handler

import "go-micro.dev/v5"

func main() {
 service := micro.New("subscriber")
 
 // Subscribe to events
 micro.RegisterSubscriber("user.created", service.Server(), 
 func(ctx context.Context, event *UserCreatedEvent) error {
 log.Infof("User created: %s", event.Email)
 return nil
 },
 )
 
 service.Run()
}

Publishing Events

publisher := micro.NewEvent("user.created", client)
publisher.Publish(ctx, &UserCreatedEvent{
 Email: "user@example.com",
})

Get Help

Discord Community - Chat with other users
GitHub Issues - Report bugs or request features
Documentation - Complete docs

Quick Start

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

Get up and running with go-micro in under 5 minutes.

Install

The recommended way is the precompiled binary — no Go toolchain required:

curl -fsSL https://go-micro.dev/install.sh | sh

Or, if you have Go and prefer to build from source:

go install go-micro.dev/v6/cmd/micro@latest

If the installer finishes but your shell cannot find micro, open Install troubleshooting before creating your first service.

Create Your First Service

# Create a new service
micro new helloworld
cd helloworld

# Review the generated code
ls -la

# Run locally with hot reload
micro run

# Test it
curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
 -H "Content-Type: application/json" \
 -d '{"name": "World"}'

Next Steps

You now have the service half of the services → agents → workflows lifecycle running locally. Keep the on-ramp going in this order:

Registry

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

The registry is responsible for service discovery in Go Micro. It allows services to register themselves and discover other services.

Features

Service registration and deregistration
Service lookup
Watch for changes

Implementations

Go Micro supports multiple registry backends, including:

MDNS (default)
Consul
Etcd
NATS

You can configure the registry when initializing your service.

Plugins Location

Registry plugins live in this repository under go-micro.dev/v6/registry/<plugin> (e.g., consul, etcd, nats). Import the desired package and pass it via micro.Registry(...).

Roadmap

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

Where we are (v6)

The foundation is in place:

Services — register, discover, RPC, events; every endpoint is automatically an MCP tool.
Agents — a model with memory and tools that manages services, with plan, delegate, guardrails (MaxSteps, LoopLimit, ApproveTool), tool-execution middleware (WrapTool), run metadata, checkpoint/resume, and OpenTelemetry run spans built in.
Flows — durable, event-driven workflows: ordered steps that checkpoint and resume after a crash.
Interop — the MCP gateway (services as tools) and the A2A gateway (agents as agents, both directions, including A2A streaming, push notifications, and multi-turn continuation), both generated from the registry; x402 for paid tools.
Secure by default — TLS verification on, state scoped per component.

Principles

These constrain everything below:

Rpc Client

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

package main

import (
 "context"
 "fmt"
 "go-micro.dev/v6"
)

type Request struct { Name string }

type Response struct { Message string }

func main() {
 svc := micro.NewService("caller")
 svc.Init()

 req := svc.Client().NewRequest("helloworld", "Say.Hello", &Request{Name: "John"})
 var rsp Response

 if err := svc.Client().Call(context.TODO(), req, &rsp); err != nil {
 fmt.Println("error:", err)
 return
 }

 fmt.Println(rsp.Message)
}

RPC Client

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

Call a running service using the Go Micro client.

package main

import (
 "context"
 "fmt"
 "go-micro.dev/v6"
)

type Request struct { Name string }

type Response struct { Message string }

func main() {
 svc := micro.NewService("caller")
 svc.Init()

 req := svc.Client().NewRequest("helloworld", "Say.Hello", &Request{Name: "John"})
 var rsp Response

 if err := svc.Client().Call(context.TODO(), req, &rsp); err != nil {
 fmt.Println("error:", err)
 return
 }

 fmt.Println(rsp.Message)
}

Search Results

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

Service Discovery with Consul

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

In code

package main

import (
 "go-micro.dev/v6"
 "go-micro.dev/v6/registry/consul"
)

func main() {
 reg := consul.NewConsulRegistry()
 svc := micro.NewService("consul-registry", micro.Registry(reg))
 svc.Init()
 svc.Run()
}

Via environment

Run your service with env vars set:

MICRO_REGISTRY=consul MICRO_REGISTRY_ADDRESS=127.0.0.1:8500 go run main.go

Service Discovery with Consul

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

Use Consul as the service registry.

In code

package main

import (
 "go-micro.dev/v6"
 "go-micro.dev/v6/registry/consul"
)

func main() {
 reg := consul.NewConsulRegistry()
 svc := micro.NewService("consul-registry", micro.Registry(reg))
 svc.Init()
 svc.Run()
}

Via environment

Run your service with env vars set:

MICRO_REGISTRY=consul MICRO_REGISTRY_ADDRESS=127.0.0.1:8500 go run main.go

State with Postgres Store

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

Use the Postgres store for persistent key/value state.

In code

package main

import (
 "log"
 "go-micro.dev/v6"
 "go-micro.dev/v6/store"
 postgres "go-micro.dev/v6/store/postgres"
)

func main() {
 st := postgres.NewStore()
 svc := micro.NewService("postgres-store", micro.Store(st))
 svc.Init()

 _ = store.Write(&store.Record{Key: "foo", Value: []byte("bar")})
 recs, _ := store.Read("foo")
 log.Println("value:", string(recs[0].Value))

 svc.Run()
}

Via environment

Run your service with env vars set:

Store

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

The store provides a pluggable interface for data storage in Go Micro.

Features

Key-value storage
Multiple backend support

Implementations

Supported stores include:

Memory (default)
File (go-micro.dev/v6/store/file)
MySQL (go-micro.dev/v6/store/mysql)
Postgres (go-micro.dev/v6/store/postgres)
NATS JetStream KV (go-micro.dev/v6/store/nats-js-kv)

Plugins are scoped under go-micro.dev/v6/store/<plugin>.

Configure the store in code or via environment variables.

Example Usage

Here’s how to use the store in your Go Micro service:

package main

import (
 "go-micro.dev/v6"
 "go-micro.dev/v6/store"
 "log"
)

func main() {
 service := micro.NewService("store-example")
 service.Init()

 // Write a record
 if err := store.Write(&store.Record{Key: "foo", Value: []byte("bar")}); err != nil {
 log.Fatal(err)
 }

 // Read a record
 recs, err := store.Read("foo")
 if err != nil {
 log.Fatal(err)
 }
 log.Printf("Read value: %s", string(recs[0].Value))
}

Configure a specific store in code

Postgres:

Store Postgres

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

In code

package main

import (
 "log"
 "go-micro.dev/v6"
 "go-micro.dev/v6/store"
 postgres "go-micro.dev/v6/store/postgres"
)

func main() {
 st := postgres.NewStore()
 svc := micro.NewService("postgres-store", micro.Store(st))
 svc.Init()

 _ = store.Write(&store.Record{Key: "foo", Value: []byte("bar")})
 recs, _ := store.Read("foo")
 log.Println("value:", string(recs[0].Value))

 svc.Run()
}

Via environment

Run your service with env vars set:

MICRO_STORE=postgres \
MICRO_STORE_ADDRESS=postgres://user:pass@127.0.0.1:5432/postgres \
MICRO_STORE_DATABASE=micro \
MICRO_STORE_TABLE=micro \
go run main.go

Summary: Reflection Removal Evaluation

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

Issue: [FEATURE] Remove reflect
Date: 2026-02-03
Status: EVALUATION COMPLETE - RECOMMENDATION AGAINST REMOVAL

Executive Summary

After comprehensive analysis of go-micro’s reflection usage and comparison with livekit/psrpc (the referenced example), we recommend AGAINST removing reflection from go-micro.

Key Findings

1. Reflection is Fundamental to go-micro’s Architecture

Reflection enables go-micro’s core value proposition:

// Simple, idiomatic Go - no proto files, no code generation
type MyService struct{}

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

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

This requires reflection. There is no way to achieve this simplicity with generics or code generation.

Support

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

Choose your level

From free community help to hands-on engagements. Recurring amounts are set on GitHub Sponsors; support and consulting are scoped per engagement.

Testing Micro Services

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

The testing package provides utilities for testing micro services in isolation.

Quick Start

import (
 "testing"
 "go-micro.dev/v6/test"
)

func TestGreeter(t *testing.T) {
 h := test.NewHarness(t)
 defer h.Stop()

 h.Name("greeter").Register(new(GreeterHandler))
 h.Start()

 var rsp HelloResponse
 err := h.Call("GreeterHandler.Hello", &HelloRequest{Name: "World"}, &rsp)
 if err != nil {
 t.Fatal(err)
 }

 if rsp.Message != "Hello World" {
 t.Errorf("expected 'Hello World', got '%s'", rsp.Message)
 }
}

How It Works

The harness creates isolated instances of:

The Agent Harness

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

The first wave of agent frameworks solved one problem: put a model in a loop with some tools. The harder problem is operating that loop — and that’s what a harness is.

A harness is the runtime around an agent:

the tools it can call,
the memory it keeps,
the guardrails that bound it,
the workflows that trigger and structure it,
the state that survives a restart,
the observability to see what it did,
the services it depends on,
and the protocols other agents use to reach it.

Go Micro’s bet is that this runtime is the one you already deploy. An agent is a service with a model inside; the harness is the distributed-systems machinery services already have. So you don’t bolt a separate orchestration product onto your stack — the harness is the stack.

TLS Security Migration Guide

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

Overview

Go Micro v6 verifies TLS certificates by default. This guide is for teams upgrading from v5, where TLS verification was disabled by default for backward compatibility.

Current Status (v6)

Default Behavior: TLS certificate verification is enabled by default (InsecureSkipVerify: false).

What changed from v5: v5 allowed MICRO_TLS_SECURE=true to opt into certificate verification. In v6, secure verification is the default and MICRO_TLS_SECURE is no longer used.

TLS Security Update - Important Information

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

What Changed

Go Micro v6 verifies TLS certificates by default. This completes the v5 security migration where verification was opt-in.

Current Behavior (v6.x)

Default: TLS certificate verification is enabled.

MICRO_TLS_SECURE was a v5 opt-in flag and is no longer used.
For local development with untrusted self-signed certificates, opt out explicitly with MICRO_TLS_INSECURE=true or an explicit insecure TLS config.

Production Recommendation

For production deployments:

Use CA-signed certificates or distribute your private CA to every host.
Remove old MICRO_TLS_SECURE settings from v5-era manifests.
Do not set MICRO_TLS_INSECURE=true in production.
Consider service mesh mTLS (Istio, Linkerd) if certificate lifecycle should be managed outside the application.

Migration Timeline

v5.x: Insecure by default, opt-in security via MICRO_TLS_SECURE=true.
v6.x current: Secure by default; use MICRO_TLS_INSECURE=true only for an explicit development opt-out.

Documentation

See SECURITY_MIGRATION.md for the detailed migration guide.

Transport

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

The transport layer is responsible for communication between services.

Features

Pluggable transport implementations
Secure and efficient communication

Implementations

Supported transports include:

HTTP (default)
NATS (go-micro.dev/v6/transport/nats)
gRPC (go-micro.dev/v6/transport/grpc)
Memory (go-micro.dev/v6/transport/memory)

Important: Transport vs Native gRPC

Transport Nats

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

In code

package main

import (
 "go-micro.dev/v6"
 tnats "go-micro.dev/v6/transport/nats"
)

func main() {
 t := tnats.NewTransport()
 svc := micro.NewService("nats-transport", micro.Transport(t))
 svc.Init()
 svc.Run()
}

Via environment

Run your service with env vars set:

MICRO_TRANSPORT=nats MICRO_TRANSPORT_ADDRESS=nats://127.0.0.1:4222 go run main.go

Website information

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

Site built with Docsy v0.14.4-dev

Build information

Netlify build information:

Attribute	Value
Netlify built	`false`
Deploy context	local

Your First Agent

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

This walkthrough builds the smallest useful Go Micro agent path: one service with typed endpoints, one agent scoped to that service, and one CLI conversation that proves the agent can use the service as a tool. It is the 0→1 version of the services → agents → workflows lifecycle: build capability first, add intelligence on top, then keep a clear path toward flows when the work needs to run on events or schedules.