Go - Armature

The Go SDK instruments servers built with mark3labs/mcp-go (v0.49–v0.56) or the official modelcontextprotocol/go-sdk (v1.7.0, MCP protocol 2026-07-28 and earlier). Go 1.25.12+.

Install

go get github.com/armature-tech/mcp-analytics-go/armatureanalytics@latest

go get github.com/armature-tech/mcp-analytics-go/armatureanalytics/official@latest

Set your API key

ANALYTICS_INGEST_API_KEY=<your ingest key>
ANALYTICS_INGEST_URL=<your region's ingest URL>

Copy both values from the dashboard when you mint the key. US workspaces can omit ANALYTICS_INGEST_URL (the SDK defaults to the US endpoint); EU workspaces must set it to https://eu.armature.tech/api/mcp-analytics/ingest. If the key is missing, the SDK quietly no-ops — your server keeps working, and no data is sent.

Instrument your server

mark3labs/mcp-go
Official go-sdk

Create the server with NewMCPServer and register tools with InstrumentTool:

main.go

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/armature-tech/mcp-analytics-go/armatureanalytics"
	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)

func main() {
	s, shutdown := armatureanalytics.NewMCPServer(
		"Customer MCP", "1.0.0",
		server.WithToolCapabilities(true),
	)
	defer func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		_ = shutdown(ctx)
	}()

	armatureanalytics.InstrumentTool(s,
		mcp.NewTool("lookup_customer",
			mcp.WithString("customer_id", mcp.Required()),
		),
		func(_ context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
			id := req.GetArguments()["customer_id"]
			return mcp.NewToolResultText(fmt.Sprintf("customer %v is active", id)), nil
		},
	)

	if err := server.ServeStdio(s); err != nil {
		log.Fatal(err)
	}
}

main.go

package main

import (
	"context"
	"time"

	"github.com/armature-tech/mcp-analytics-go/armatureanalytics/official"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

type LookupInput struct {
	CustomerID string `json:"customer_id"`
}

type LookupOutput struct {
	Active bool `json:"active"`
}

func main() {
	s, shutdown := official.NewMCPServer(
		&mcp.Implementation{Name: "Customer MCP", Version: "1.0.0"}, nil,
	)
	defer func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		_ = shutdown(ctx)
	}()

	official.InstrumentTool(s,
		&mcp.Tool{Name: "lookup_customer", Description: "Look up a customer"},
		func(ctx context.Context, req *mcp.CallToolRequest, input LookupInput) (*mcp.CallToolResult, LookupOutput, error) {
			return nil, LookupOutput{Active: true}, nil
		},
	)

	// serve over stdio or HTTP as usual
}

The typed InstrumentTool derives the input schema from your input struct automatically.

Existing servers

Attach a recorder to a server you already construct:

config := armatureanalytics.EnvConfig()
config.Disabled = config.APIKey == ""

rec, err := armatureanalytics.NewRecorder(config)
if err != nil {
	return err
}

s := server.NewMCPServer("Customer MCP", "1.0.0",
	server.WithToolCapabilities(true),
	server.WithHooks(rec.Hooks()),
)
// on shutdown: rec.Close(ctx)

For the official SDK, use official.NewRecorder(config) followed by rec.Install(server).

Running on serverless or stateless HTTP? See Stateless & serverless servers and set Delivery: armatureanalytics.DeliveryAwait.

Configuration

config := armatureanalytics.EnvConfig()
config.OnError = func(err error, batch armatureanalytics.Batch) {
	log.Printf("analytics delivery failed: %v", err)
}

s, shutdown := armatureanalytics.NewMCPServerWithConfig("Customer MCP", "1.0.0", config)

Field	Default	Description
`APIKey`	`ANALYTICS_INGEST_API_KEY` env var (via `EnvConfig`)	API key used to authenticate ingestion.
`EndpointURL`	US ingest endpoint	Override with `ANALYTICS_INGEST_URL` or this field; EU workspaces must use the EU endpoint.
`Disabled`	`false`	Set `true` to disable capture entirely.
`Delivery`	`DeliveryBackground`	`DeliveryBackground` posts on a goroutine off the request path; `DeliveryAwait` sends before returning (use in serverless).
`Timeout`	`5 * time.Second`	Delivery timeout.
`ActorSeed`	`Authorization` header	Function used to attribute calls to a user. See Identifying users.
`ActorIdentifier`	`nil`	Attach a caller-provided identifier verbatim. See Identifying users.
`Emit`	Network delivery	Replace delivery with your own function — useful in tests. Makes `APIKey` optional.
`OnError`	`nil` (silent)	Called when delivery fails. Set this in production so ingest failures are visible.
`CaptureTelemetry`	`nil` (on)	Point at `false` to disable conversation-derived telemetry while keeping call analytics.
`RequestCapability`	`nil` (on)	Injects the `request_capability` tool (see What the SDK captures); point a `*bool` at `false` to disable.

OnError is silent by default in Go. Set it in production — otherwise an invalid key or network failure drops events with no signal.

Flush on shutdown

NewMCPServer returns a Shutdown function that drains pending deliveries — call it with a timeout on exit (as in the quickstart above). With a manual recorder, call rec.Close(ctx).

What’s not captured

The Go SDK records one session_init per session and every tools/call. On the classic protocol the session_init comes from the initialize handshake; on the 2026-07-28 stateless protocol there is no handshake, so the SDK emits it when a new session identity first appears on any method. Prompts, resources, and OAuth flows are not captured.

Troubleshooting

Actor always shows as anonymous behind auth middleware

With the official SDK adapter, install the analytics middleware before your auth middleware if your ActorSeed reads values that auth injects into the context.

No data arrives

Check ANALYTICS_INGEST_API_KEY is set (missing keys disable delivery silently by design), check ANALYTICS_INGEST_URL matches your workspace region — EU keys are rejected by the US endpoint — and set Config.OnError to surface failures.

Getting started

Analytics

Evaluation

SDKs

Armature MCP

Privacy & security

Go

Install

Set your API key

Instrument your server

Existing servers

Configuration

Flush on shutdown

What’s not captured

Troubleshooting

​Install

​Set your API key

​Instrument your server

​Existing servers

​Configuration

​Flush on shutdown

​What’s not captured

​Troubleshooting

Install

Set your API key

Instrument your server

Existing servers

Configuration

Flush on shutdown

What’s not captured

Troubleshooting