codex/planner-4721
39 次代码提交
| 作者 | SHA1 | 备注 | 提交日期 | |
|---|---|---|---|---|
 Asim Aslam
|
a11b84e817 |
blog: add v6.6.0 whats new (#4672)
Co-authored-by: Codex <codex@openai.com> |
||
|
Asim Aslam
|
3560208edc |
blog: draft v6.3.15 update (#4022)
Co-authored-by: Codex <codex@openai.com> |
||
|
Asim Aslam
|
573e043cb1 |
blog: introduce micro loop (#33) (#3659)
A detailed post on `micro loop` — the autonomous loop that builds Go Micro, now shippable as a command. Covers the mechanism/policy split (Actions as the runtime, prompt files as editable policy), the five roles, the quickstart and the two things the CLI can't do (token + branch protection), the load-bearing decisions and the gotchas we hit (fresh-issue-per-run, bot-comment gating, the persist-credentials 403), and the dogfood: Go Micro now runs on it. Sequel to /blog/31 "How Go Micro Builds Itself". Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
2d8e3da943 |
blog: expand /blog/32 into a field guide on agent frameworks (#3478)
* blog+docs: drop the word "bet" from the tRPC-Agent-Go comparison Reword "two bets" / "opposite bet" / "the bet is" to approaches / premise / principle across blog/32 and the comparison guide. * blog: expand /blog/32 into a field guide on agent frameworks Roughly double the length with deeper context: the first wave (LangChain & co.), the two layers of a harness (intra-agent vs operational), loop engineering and the move to scheduled/looping/work-performing agents, a survey of where the frameworks are going (LangGraph, CrewAI, AutoGen, ADK, tRPC-Agent-Go), then Go Micro's "an agent is a service" position, the honest tRPC-Agent-Go contrast, and MCP/A2A interop. Drops the word "bet" throughout. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
fdc422c16e |
blog+docs: position go-micro vs tRPC-Agent-Go (agent = service) (#3475)
Add a fair, honest positioning piece on the architectural fork with tRPC-Agent-Go (an agent SDK alongside your services / graph DSL) vs Go Micro (one runtime where an agent is a service, every endpoint a tool, durable flows not a graph DSL). New blog post /blog/32 + a parallel section in the existing comparison guide; honest about where tRPC-Agent-Go is ahead (eval, self-evolution, RAG) and that they interoperate over MCP/A2A. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
7b9c583dcf |
blog: "How Go Micro Builds Itself" — the autonomous Codex loop (#3090)
A post on how the framework is increasingly built by an autonomous loop of two AI agents (Codex implementing scoped increments, Claude Code orchestrating, the human setting direction): the dispatch→build→auto-merge mechanism, the three altitudes (architect/increment/DevRel), the failure modes we hit wiring it up, and the concrete increments it produces. Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
8a19dc2d7c |
docs/blog: anchor the agent-harness positioning (#3015)
- Add the canonical concept doc 'The Agent Harness' (docs/guides/agent-harness.md) + nav entry: what the harness is, each piece mapped to a feature, honest about shipped vs in-progress. - Add blog post /blog/30 'Go Micro is an Agent Harness' (the public articulation; precise about what ships today vs the Now/Next roadmap). - Align the ROADMAP.md opening line to the agent-harness framing. Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
2c04f61331 |
blog: announce OpenAI Codex for Open Source grant (/blog/29) (#3003)
Add a blog post for the OpenAI Codex for Open Source grant, list it on the blog index, and repoint the OpenAI sponsor logo (README + landing) to the post — matching how the Anthropic (/blog/3) and Atlas Cloud (/blog/8) sponsor logos link to their posts. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
cdc6ee9aa1 |
examples: support desk agent + blog walkthrough (#2983)
A real-world, runnable example (examples/support): customers/tickets/notify services become the agent's tools, a flow turns a ticket.created event into the agent's work, and an approval gate guards the one action that touches a customer. Runs with no API key (mock model) or against a live provider. Adds blog/28 'Building a Support Agent in Go' and indexes both. Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
d54cfab1bd |
blog: Bringing an Open Source Project Back from the Dead (#27) (#2979)
A first-person journey of Go Micro from January 2015 through the VC/company era, the platform pivot, the quiet years, and the revival via the Claude Code grant — into v6 and the services/agents/flows model. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
307b94aab7 |
Implement A2A protocol gateway and update documentation (#2974)
goreleaser / goreleaser (push) Has been cancelled
* feat(a2a): Agent2Agent protocol gateway Add gateway/a2a — exposes registered agents over the open A2A protocol so agents on other frameworks can discover and call them. Agent Cards are generated from registry metadata (the same way the MCP gateway derives tools from service endpoints); incoming A2A tasks translate to the agent's existing Agent.Chat RPC, so there's no per-agent code. v1 is the synchronous JSON-RPC binding: message/send returns a completed Task, tasks/get retrieves it, and Agent Cards are served for discovery; streaming and push notifications are advertised as unsupported. Run with 'micro a2a serve' (cmd/micro/a2a). Tests cover card generation, message/send, tasks/get, listing, and unknown-method errors. * docs: A2A guide, README contents + A2A section, universe A2A check - Add a Contents table of contents at the top of the README and an A2A subsection under Building Agents. - Add the Agent2Agent (A2A) guide and register it in the docs nav. - Exercise the A2A gateway in the universe harness: the concierge agent is reached over A2A (message/send -> Agent.Chat -> completed task). * feat(a2a): outbound client — call external A2A agents Add a2a.Client (Send/Card) so a Go Micro agent or flow can call an agent on any framework by URL — the outbound counterpart to the gateway. Wired in two places: flow.A2A(url) as a workflow step (the cross-framework Dispatch), and agent delegate to an http(s) URL routes over A2A. The universe harness now drives the gateway through the client, exercising both directions. Tests cover client send/card and the round trip. * docs: A2A both-directions — guide, README, changelog, blog #26 --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
7ee32e8721 |
Update changelog and enhance retrospective blog on agentic features (#2973)
* docs: changelog catch-up + retrospective blog (agentic development) Add the headline agentic features that shipped this quarter but were never logged (agents, plan/delegate, guardrails, workflows, x402) to the changelog, and add blog #25 — a three-month progress reflection on Go Micro becoming a framework for agentic development. * docs: tighten retrospective post — cut slogans, triads, and filler * docs: tighten retrospective intro, bridge, and conclusion for a single through-line * docs: frame Go Micro as how you build a distributed system, not run one --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
9fdcc24cce |
Implement durable execution and scoped state management for flows (#2972)
* docs: design note for flow steps + Checkpoint durable execution
* docs: fold in durable-execution decisions (State struct, single Step, run retention, retry)
* docs: rename State.Payload to State.Data
* feat(flow): ordered steps + Checkpoint durable execution
A flow can now be an ordered list of steps (a task with stages) instead
of a single LLM turn. State carries typed Data plus a Stage marker; each
step is checkpointed before and after via a pluggable Checkpoint
(store-backed by default), so a run survives a crash and resumes where it
stopped without re-running completed steps. Flow-level Retry with a
per-step override; runs retained for audit unless DeleteOnSuccess.
Step actions: Call (RPC), LLM (augmented turn), Dispatch (to an agent),
or any StepFunc. Single-step and agent-dispatch flows are unchanged.
* feat(flow): top-level re-exports + durable flow example
Expose the step/checkpoint API from the micro package (FlowSteps,
FlowStep, FlowState, FlowRetry, FlowWithCheckpoint, FlowCall/LLM/Dispatch,
Checkpoint, StoreCheckpoint) and add a runnable, key-free example
demonstrating crash + resume.
* docs: document durable flow steps (guide, README, CLI help)
* docs: blog post + changelog for durable workflows
* fix(flow): scope checkpoint keys by flow name (flow/{name}/runs/{id})
Run keys were flow/runs/{id} — a single global keyspace shared by every
flow on the default store. Namespace them by flow name so each flow's
state is kept apart. StoreCheckpoint now takes a scope argument (the flow
passes its name by default).
* feat(store): Scope handle; scope agent and flow state by name
Add store.Scope(s, database, table) — a store handle that confines every
operation to a database/table without mutating the shared store, so
co-located components don't clobber each other's table (the failure mode
of the global Init(Table(...)) approach).
Use it to keep each agent's memory and plan in its own table
(agent/{name}) and each flow's runs in its own (flow/{name}), instead of
one global table partitioned only by key prefix. Services already scope
by service name.
* feat: consistent state model — service store scoping, flow registry, list/history CLI
- service: scope store via store.Scope (database service / table name),
retiring the Init(store.Table(name)) global-mutation hack; bridge the
default store so handlers using store.DefaultStore stay isolated.
- flow: register in the registry as type=flow while running (with trigger
and step count), deregister on Stop. Live discovery, like agents.
- cli: micro flow list (registry), micro flow runs <name> (durable store),
micro agent history <name> (durable store). list = running, runs/history
= durable, mirroring the service model.
* test: mini-universe end-to-end harness + scheduled GitHub Action
internal/harness/universe boots a small but real go-micro world — four
services, a durable checkout flow that crashes at payment and resumes,
and a guardrailed agent with a tool wrapper reached over RPC — drives the
scenario, asserts the end state (10 checks), and shuts down. Everything
is real except the LLM (mocked), so it's deterministic and needs no key;
-provider anthropic runs it live. Exits non-zero on failure, so it's an
end-to-end test, not just a demo.
Adds .github/workflows/universe.yml (push/PR/daily/dispatch) running the
universe + existing harnesses on the mock provider, plus an opt-in job
that runs live when ANTHROPIC_API_KEY is set. 'make harness' runs them
locally.
* ci: run the live universe job against AtlasCloud (ATLASCLOUD_API_KEY)
* ci: run the live universe job only on schedule or manual dispatch
The deterministic mock job still runs on push/PR/daily; the live
(AtlasCloud) job runs daily and on manual workflow_dispatch only, so
changes don't burn API credits on every PR but can still be checked
against a real model on demand.
---------
Co-authored-by: Claude <noreply@anthropic.com>
|
||
|
Asim Aslam
|
e079e083da |
feat(agent): loop detection guardrail + document/blog agent guardrails (#2968)
Add LoopLimit: refuse a tool call repeated with identical arguments in one Ask, with a self-heal message so the model changes approach. Catches the no-progress loop that MaxSteps (count) and the gateway circuit breaker (failures) miss. Enforced at the same tool-handler choke point as MaxSteps/ApproveTool; on by default (lenient 3); AgentLoopLimit(0) to disable. Tests cover repeats, distinct calls, disabled, and default-on. Docs: new Agent Guardrails guide (MaxSteps/LoopLimit/ApproveTool, the ApproveTool integration seam for external policy engines, and the gateway's RateLimit/CircuitBreaker), nav + README + AGENT_DESIGN updates, and blog/23 'Agent Guardrails'. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
9deac487cb |
feat(x402): opt-in agent-native payments for tools (#2964)
Integrate the x402 payment protocol (HTTP 402) so a tool can require a stablecoin payment and an agent can settle it — the next step after autonomous agents (blog 21): agents that act, and pay. - wrapper/x402: HTTP middleware enforcing the 402 challenge/verify flow, with a pluggable Facilitator interface. Go Micro carries no chain or crypto code — verification/settlement is delegated to a facilitator (Coinbase CDP, Alchemy, self-hosted), so Base and Solana are just different facilitators behind one interface. HTTPFacilitator default; tests cover challenge / accept / reject via a mock facilitator. - MCP gateway: optional Options.Payment gates /mcp/call (listing tools and health stay free); off unless configured. - micro mcp serve and micro-mcp-gateway: opt-in --x402-pay-to/-price/ -network/-facilitator flags (env vars on the standalone binary). - blog/22 'Integrating x402: Payments for Agents'; README feature row. Pricing is flat per call for now; richer models and an agent-side spend cap (next to MaxSteps/ApproveTool) are follow-ups. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
6eec83a045 |
blog: 'When the Event Is the Prompt' (#21) + autonomous agent-flow harness (#2962)
The autonomy direction: agents that run on events, not human prompts. - internal/harness/agent-flow: a runnable, deterministic demo — a user.created broker event drives a Flow that hands off to a registered agent (FlowAgent), which creates a workspace and sends a welcome over real RPC. Only the LLM is mocked; passes under -race. - blog/21: 'When the Event Is the Prompt' — the shift from agents you talk to, to agents that act on their own; where microagents become real; and the honest bar autonomy raises (guardrails, observability, durable/resumable execution — the next things to build). Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
9dae4e34b7 |
Enhance README with sponsorship CTA and improve agent architecture (#2961)
* docs: add 'become a sponsor' call-to-action linking to Discord Now that there are a couple of sponsors, invite more: a short CTA under the Sponsors section in the README and on the landing page, pointing to the Discord to get in touch. * fix(health): remove duplicate RegistryCheck declaration Two PRs (#2957 and #2958) each added a RegistryCheck to the health package, leaving the package uncompilable on master (RegistryCheck redeclared: health/registry.go vs health/health.go). Keep the health.go implementation — it honors the check's context timeout so a hung registry (e.g. an unreachable etcd) reports down instead of blocking the probe — and remove the duplicate registry.go and its test. registry_check_test.go already covers healthy/down/nil/timeout/not-ready. * feat(agent): pluggable memory and custom tools Make agents compose the way services do — pluggable pieces with working defaults — by adding the two abstractions an agent needs beyond the model: - Memory: a pluggable interface for conversation memory. The default is store-backed and durable across restarts (the previous hardcoded behavior, now behind an interface); supply your own with WithMemory (in-memory, database, semantic store). NewMemory / NewInMemory provided. - Custom tools: WithTool registers any function as a tool the agent can call, so agents are no longer limited to orchestrating RPC services. Both exposed at the micro package (AgentMemory, AgentTool, NewMemory, NewInMemory). Behavior-preserving refactor of the agent's history into the default Memory; tests cover persistence, in-memory, clear, custom tool dispatch and errors. README + AGENT_DESIGN document the pluggable composition (model / memory / tools / guardrails). * blog: 'Doubling Down on Agents' (#20) The vision post for making agents a first-class framework the way services were: opinionated, batteries-included, pluggable. Frames an agent as a composition of model + memory + tools + guardrails with working defaults; introduces the new pluggable memory and custom tools; makes the microagents argument (an agent for everything, distributed like microservices); and lays out the three primitives — services, agents, workflows — as one substrate, with an honest list of the gaps still to fill (knowledge/retrieval, streaming, explicit loop). --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
d3be610367 |
Refactor README features and add end-to-end flow testing (#2954)
goreleaser / goreleaser (push) Has been cancelled
* docs: group README features by section (AI / Framework / DX) The features table repeated 'AI' down the Category column. Split into three grouped tables — AI, Framework, Developer experience & deployment — dropping the repetitive column. Adds a Guardrails row (MaxSteps, ApproveTool). * test: flow-to-agent end-to-end in the harness Proves 'Flow triggers, Agent reasons': a workflow with FlowAgent hands an event to the registered conductor agent over RPC, which plans, creates tasks, and delegates to comms — the whole chain over real RPC with only the LLM mocked. Deterministic (shared in-memory registry, no sleeps), passes under -race. * blog: 'The Evolution of Microservices' (#19) A technical history of distributed-systems eras — the monolith's coordination cost, the distributed-systems tax, containers and declarative orchestration, the service mesh, and the modular-monolith correction — establishing the durable unit (named, typed, discoverable, independently deployable) that every runtime wave required. Then the technical argument for agents: an LLM tool call needs exactly a service interface, so the caller shifts from deterministic code to a reasoner that composes typed capabilities from intent, with the honest caveats (non-determinism, cost, guardrails). Not a product pitch. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
35bc58e5d2 |
Enhance onboarding experience and clarify workflows vs agents (#2953)
* blog: 'Not Everything Should Be an Agent' (#18) on workflows The workflow counterpart to the plan/delegate post: when the path is known, use a deterministic Flow, not an autonomous agent. Frames flow vs agent as two modes of the same building blocks, covers flow-triggers- agent dispatch and the agent guardrails, and gives the simplest-first guidance (single call -> workflow -> agent). Continues the arc from blog 14/16/17; references Building Effective Agents in passing. * docs: fix new-user onboarding friction - README: lead Quick Start with a no-key 30-second path (micro new -> micro run -> curl), then the AI --prompt path with an explicit 'export ANTHROPIC_API_KEY' so the headline command no longer fails silently for users without a key. - Unify all install versions to v5.26.0 (README + docs were split across v5.16.0 / v5.25.0). - Refresh the docs landing overview from the old 'microservices framework' framing to 'services and agents', matching the README. - getting-started: add Prerequisites (Go 1.21+, and that a provider key is only needed for AI features). - README features: Flows -> Workflows wording. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
cb33decd97 |
Add built-in plan and delegate tools for agents with examples (#2949)
* feat: add plan and delegate as built-in agent tools Give agents two self-capabilities, expressed as plain tools wired into the existing tool handler — no harness or graph, consistent with "services are the only abstraction": - plan: record/update an ordered plan, persisted to store-backed memory and surfaced in the system prompt on later turns (externalized planning). - delegate: hand a self-contained subtask to another agent. Delegate-first — if the target names a registered agent it is called via RPC; otherwise a focused ephemeral sub-agent is created with agent.New + Ask in a fresh, isolated context (loads/persists no history, no built-in tools, so it cannot re-delegate). Both are added automatically to any non-ephemeral agent, so existing micro.NewAgent services and micro chat routing get them for free. Tests are hermetic (memory store + memory registry). * feat: add agent-plan-delegate example and document plan/delegate - examples/agent-plan-delegate: coordinator that plans multi-step work, creates tasks with its own tools, and delegates notification to a separate registered comms agent over RPC. - integration tests driving the full Ask loop through a fake provider: plan tool exposure + persistence, ephemeral delegation with isolated context, delegate-first RPC routing to a registered agent. - docs: README (Building Agents + features + examples), AGENT_DESIGN (Built-in Capabilities), agent-patterns guide (Pattern 9), CLAUDE.md. * docs: blog post and guide for plan & delegate - blog/17: "Plan & Delegate: Deep Agents in Go" — what the feature is, how plan and delegate work, and a runnable getting-started path. - guides/plan-delegate: reference guide with the smallest-agent snippet, plan/delegate semantics, and the multi-agent example; linked in nav. - example: auto-detect provider/key from common env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...) so 'export KEY && go run main.go' just works. - onboarding: getting-started paths now include go mod init / go get and a clone-and-run path, so a reader can actually run it from a cold start. * refactor: reframe plan/delegate blog and clean up sub-agent construction - blog/17 retitled "Agents That Plan and Delegate" and reframed around intent (plan = state intent, delegate = direct it), positioned as the next beat after blog 15/16 and tied to the existing store + agent RPC rather than re-announcing them. "Deep agents" now a single in-passing nod, matching how blog 14 references LangChain. - agent: add unexported newEphemeral constructor for sub-agents instead of type-asserting the public Agent interface to set an internal field; matches the options-only construction idiom used elsewhere. * feat: expose plan & delegate in the micro chat fallback Add agent.Builtins(opts...) — returns the built-in tools plus a handler, so the plan/delegate capabilities can be wired into a tool loop that isn't a running Agent. micro chat's direct-service fallback now reuses it (single source of truth, no duplicated handler logic), so planning and delegation are available there too, not just for registered agents. Adds a test for the accessor; notes CLI availability in the guide. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
1bc886fa82 |
Introduce Agent abstraction and integrate with chat router (#2939)
* docs: Agent interface design sketch Proposes Agent as a top-level abstraction alongside Service in the micro package. Agent manages services — scoped tools, system prompt, conversation memory, registry-discoverable. Design only, no implementation. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: Agent as a first-class abstraction Introduce micro.NewAgent() alongside micro.New() — Agent is to intelligence what Service is to capability. Agent interface: - Chat(ctx, message) (*Response, error) — core interaction method - Run() — registers in registry, subscribes to broker, blocks - Stop() — graceful shutdown - Scoped tools — only sees endpoints of its assigned services - Persistent memory — conversation history stored in store - Agent-to-agent — communication via broker topics Top-level API: agent := micro.NewAgent("task-mgr", micro.AgentServices("task"), micro.AgentPrompt("You manage tasks."), micro.AgentProvider("anthropic"), ) agent.Run() https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: wire agents into chat router, add micro agent CLI, expose Flow Three top-level abstractions: micro.New("task") — Service (capability) micro.NewAgent("task-mgr") — Agent (intelligence) micro.NewFlow("onboard-user") — Flow (event-driven orchestration) micro chat as router: - Discovers agents from registry on startup - Single agent: routes directly - Multiple agents: LLM classifies intent, dispatches to right agent via route_to_agent tool - No agents: falls back to current direct-service behaviour - Banner shows discovered agents micro agent CLI: - micro agent list — shows registered agents and their services - micro agent describe <name> — shows agent details from registry https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: move flow to top level, update docs for three abstractions Package structure now consistent: service/ — Service (capability) agent/ — Agent (intelligence) flow/ — Flow (event-driven orchestration) ai/flow/ kept as backward-compatible re-export. Updated across all surfaces: - CLAUDE.md: added agent/ and flow/ to project structure - README: added "Building Agents" section with NewAgent() examples, updated features table (Agents, Flows, Chat router), CLI table (agent list, agent describe), docs links - Website: features grid shows Services, Agents, Flows as the three pillars alongside generation, MCP, and pluggable architecture - micro.go: Flow imported from top-level flow/ package https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * docs: rewrite getting-started, fix ai-integration import paths Getting started now covers all three abstractions: - Service (write handlers, micro run, templates) - Agent (micro.NewAgent, scoped tools, memory, CLI) - Flow (event-driven LLM orchestration) Leads with prompt-based generation, then manual service creation. ai-integration.md: fixed flow import path from go-micro.dev/v5/ai/flow to go-micro.dev/v5/flow, updated stack diagram to show agent/flow/chat. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * blog: Introducing micro.NewAgent() Post 16 — announces Agent as a first-class abstraction. Shows the API (NewAgent, AgentServices, AgentPrompt, AgentProvider), scoped tools, persistent memory, multi-service agents, multi-agent systems, and the three-abstraction comparison table (Service/Agent/Flow). https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: fix agent registration, blog post 16 Agent registration: - Add node with address so mDNS can discover agents - Store type and services in node metadata (mDNS requirement) - Connect broker before subscribing, non-fatal if broker unavailable - Print registration confirmation on Run() Agent/chat discovery: - Check both service-level and node-level metadata for type=agent (mDNS stores metadata on nodes, not services) Blog post 16: "Introducing micro.NewAgent()" — announces the Agent abstraction with code examples, comparison table, multi-agent patterns. Tested end-to-end: micro run → micro agent list discovers the agent → micro chat routes to it → agent calls service endpoints. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: agents are proper services with RPC Chat endpoint Refactored agent to use server.Server instead of fake registry entries. An agent now: - Creates a real RPC server with server.Name(agentName) - Registers an Agent.Chat handler callable via standard RPC - Sets server metadata type=agent, services=x,y for discovery - No more fake addresses or broker hacks micro chat calls agents via RPC (client.Call) instead of creating local agent instances. The registry stays clean — agents are real services with real endpoints. Removed broker dependency from agent options. Agent-to-agent communication is just RPC like everything else. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: agent uses proto-defined RPC interface Added agent/proto/agent.proto with Agent service definition: rpc Chat(ChatRequest) returns (ChatResponse) Agent now implements the generated AgentHandler interface and registers via pb.RegisterAgentHandler. The Chat endpoint is a standard proto-based RPC callable by any go-micro client. Renamed the programmatic API from Chat() to Ask() to avoid collision with the proto handler method name. micro chat calls agents via standard RPC with JSON-encoded request/response — no special types needed on the caller side. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * feat: generate agent alongside services, update all docs micro run --prompt now generates an agent binary that manages all the generated services. The agent reads MICRO_AI_PROVIDER and MICRO_AI_API_KEY from the environment. micro run propagates these when started with --prompt. Run banner shows services and agents separately. Updated README, getting-started guide, and landing page to show the complete flow: generate → services + agent start → micro chat routes to agent → agent orchestrates services. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
844ac5bc52 |
Revamp landing hero and introduce agent-based microservices model (#2938)
* docs: update landing hero — describe it, run it, talk to it Lead with the AI-first experience instead of "write services in Go." The entry point is now describing what you need, not writing code. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * blog: Agents for Services — a new model for microservices Post 15 — explores the concept of distributed agents managing services. Each service has an agent assigned to it (not embedded in it). Agents are the intelligence layer; services are the capability layer. Multi-service agents span domain boundaries. Agent-to-agent communication through the broker. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
bc1092b18a |
Restructure README for AI experience and framework clarity (#2934)
* docs: restructure README — AI story completes before manual code Quick Start now flows through the full AI experience: generate → review → run → chat → grow (mid-conversation service generation). The reader sees the complete prompt-to-production story without interruption. "Writing Services" is a separate section below for developers who want to understand the framework underneath. Shows Go code, doc comments, @example tags, micro run, and scaffolding templates. Features table and CLI table reordered: AI first, then framework. https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd * blog: Going All In on AI Post 14 — the strategic case for making AI the primary direction. Covers the evolution from microservices framework to AI-native platform, why the timing is right (tool calling works, MCP is real, sponsors align), and what's not changing (framework still works, no agent framework complexity). https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
397010a82a |
docs: add blog post 13 to blog index (#2927)
https://claude.ai/code/session_01QTp4SshuVmLAvvEGJe4TJd Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
5d7609027b |
Enhance CLI with color output and add teardown blog post (#2923)
* feat(cli): add color output to micro chat and micro api micro chat: - Startup banner matching micro run style: bold header, cyan provider/model, green dots for each discovered tool endpoint - Cyan bold prompt (> ) instead of plain - Yellow arrow (→) with dimmed tool name for tool calls - Red "error:" prefix for errors - Dimmed "(history cleared)" for reset micro api: - Startup banner matching micro run style: bold header, cyan address, colored HTTP methods (green GET, yellow POST) Brings the CLI UX closer to what the generated terminal screenshot depicts — color-coded, professional, readable. * feat(cli): adopt consistent color output across all commands Apply the same banner/output style across the remaining commands: micro new: bold header, cyan service name, green ✓, cyan URLs micro build: green ✓ checkmarks, cyan file paths micro deploy: bold header, cyan target micro mcp: bold header, green dots per tool, dimmed count micro flow: bold header, cyan flow/topic/provider All commands now follow the micro run/chat/api pattern: bold header, cyan values, green status indicators, dimmed hints. * docs: add "Tools as Services" blog post Write blog/12 — connects the AI story back to Go Micro's original design: services were always self-describing, named, and uniformly callable. The path from API gateway to MCP to LLM tools is the same pattern — read the registry, present services in a format the consumer understands, route calls back. Covers the access layer pattern (HTTP, web, CLI, MCP, chat), why doc comments became functional in the AI era, and how the framework primitives (registry, broker, store) could all become tools using the same mechanism. Add to blog index, link forward from blog/11. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
5601be009a |
docs: add "Build Your Own AI Agent CLI" teardown blog post (#2921)
Write blog/11 — a teardown of micro chat showing how to build an LLM tool-calling agent in ~150 lines. Walks through the four pieces: discover tools, create the model, track conversation, run the loop. Uses the actual chat.go source. Ends with extension ideas and a "make it yours" framing. Add to blog index, link forward from blog/10. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
a9421e5b7e |
Update logo design, add AI integration documentation and blog post (#2916)
* feat: update Go Micro logo to interconnected nodes design Replace the text-on-blue-square logo with a modern icon: three teal nodes connected in a triangle, representing distributed systems. Generated via Atlas Cloud. Clean at all sizes — works as GitHub avatar, favicon, and nav bar icon. * feat: new logo, AI integration architecture doc, and landing page CTA Update logo to triangle-nodes icon + "Go Micro" text wordmark. Save icon-only variant for favicon/avatar use. Add docs/ai-integration.md — a single page that explains how the AI stack fits together: services → registry → MCP gateway → ai/tools → ai.Model → micro chat. Layer-by-layer with code examples, provider table, and "what you don't need" section. Add AI Integration to docs sidebar navigation (after Getting Started). Update the landing page AI section with a direct CTA button linking to the new doc. * fix: restore original logo and add border-radius to all renders Revert logo to original. Add border-radius: 8px to the logo img in the landing page nav, docs layout nav, and blog layout nav so the square logo renders with rounded corners everywhere. Remove unused icon.png. * docs: add micro chat blog post Write blog/10 — a dedicated post for micro chat covering: - What it does (interactive LLM agent for services) - How it works (ai/tools → ai.History → ai.Model stack) - Multi-turn conversation examples - All provider options and env vars - Single prompt mode for scripting - Why it works (registry metadata + doc comments = tool descriptions) - Programmatic usage with the same building blocks - Link to micro flow as the event-driven counterpart Add to blog index. Update blog 9 nav to link forward. --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
c26d74a8a1 |
Add CRUD, pub/sub, and API gateway templates; update AI features (#2909)
* feat(website): redesign docs and blog layouts, add blog header images Redesign both layouts to match the new landing page: - Consistent nav bar with logo, Docs, Blog, GitHub, Reference, Home - Consistent footer with copyright and links - CSS custom properties for theming - Updated typography, spacing, and code block styling - Active sidebar link highlighting in docs - Dark mode support preserved Generate 4 blog header images via Atlas Cloud: - blog-deploy.png for post 1 (micro deploy) - blog-mcp.png for posts 2, 3, 7 (MCP-related) - blog-agents-demo.png for post 4 (agents demo) - blog-dx.png for post 5 (DX cleanup) - Reuse data-model.png for post 6 (model package) All 7 existing blog posts now have header images. * fix(website): prevent horizontal scroll on mobile landing page Add overflow-x: hidden on html and body. Set max-width: 100% and height: auto on all section and two-col images. Add overflow: hidden to .two-col grid. Constrain hero pre with max-width and overflow-x. Reduce font sizes and padding at mobile breakpoint. * feat(website): add images to remaining core doc pages Generate 5 more images via Atlas Cloud for docs: - registry.png: service discovery diagram - broker.png: pub/sub message broker pattern - transport.png: multi-transport layers (HTTP, gRPC, NATS) - config.png: dynamic configuration from multiple sources - observability.png: monitoring dashboard with metrics/traces Add images to registry.md, broker.md, transport.md, config.md, observability.md, and architecture.md. All 11 main doc pages now have header images. * feat: add sponsor logos to landing page, README images, and flows blog post Add Anthropic and Atlas Cloud sponsor logos to the landing page with links to their respective blog posts. Logos display at 0.7 opacity with hover effect. Add architecture and MCP agent images to the GitHub README for the Overview and MCP sections. Write blog post 9: "From Chat to Flows" — explores the concept of LLM-powered service orchestration. Compares micro chat's interactive model with persistent event-driven flows, shows how the existing building blocks (ai/tools, History, broker) could compose into a flow engine, discusses tradeoffs vs traditional orchestration (Step Functions, Temporal), and includes a working 15-line code example. Explicitly positions it as a concept for community feedback, not an announcement. * feat(website): add animated hero video to landing page Generate a 6-second hero video via Atlas Cloud's image-to-video API (gemini-omni-flash). Shows the microservices network diagram animating with data flowing between nodes. Replace the static hero image with an autoplay muted looping video element. Falls back to the static image via poster attribute and img fallback for browsers without video support. * feat(ai): add VideoModel interface with Atlas Cloud provider Add ai.VideoModel interface for video generation alongside Model and ImageModel. Supports text-to-video and image-to-video via VideoRequest with prompt, reference images, duration, aspect ratio, and resolution fields. Implement GenerateVideo for Atlas Cloud using their async API: POST /api/v1/model/generateVideo → poll /api/v1/model/prediction. Default model is gemini-omni-flash image-to-video. Polls every 5 seconds until completion or context cancellation. Register Atlas Cloud as a video provider via ai.RegisterVideo. Add 3 tests: registration, no-key error, compile-time interface check. Update ai/README.md with VideoModel docs. The ai package now covers all three modalities: - Model (text) — 7 providers - ImageModel (image) — 2 providers (Atlas Cloud, OpenAI) - VideoModel (video) — 1 provider (Atlas Cloud) --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
5968fce2d6 |
docs: add Atlas Cloud sponsorship blog post and integration guide (#2902)
Add blog/8 announcing Atlas Cloud as an official Go Micro sponsor. Covers the sponsorship, Atlas Cloud's platform (300+ models, OpenAI compatibility, enterprise compliance), and how the integration works with the ai package, ai/tools, micro chat, and micro run. Add guides/atlascloud-integration.md with full setup instructions: quick start, configuration options, environment variables, model selection, tool calling with services, and provider swapping. Add Atlas Cloud and AI Provider guides to the docs sidebar navigation. Add sponsorship link to README header. Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
07411b1ef6 |
Remove article on chat app from blog index
Removed an article about building a chat app from the blog. |
||
|
Asim Aslam
|
d96f12f57b |
Claude/update docs roadmap f zd2 j (#2889)
* feat: add agent platform showcase and blog post Add a complete platform example (Users, Posts, Comments, Mail) that mirrors micro/blog, demonstrating how existing microservices become AI-accessible through MCP with zero code changes. Includes blog post "Your Microservices Are Already an AI Platform" walking through real agent workflows: signup, content creation, commenting, tagging, and cross-service messaging. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * refactor: rename handler types to drop redundant Service suffix UserService → Users, PostService → Posts, CommentService → Comments, MailService → Mail. Matches micro/blog naming convention. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * refactor: consolidate top-level directories, reduce framework bloat Move internal/non-public packages behind internal/ or into their parent packages where they belong: - deploy/ → gateway/mcp/deploy/ (Helm charts belong with the gateway) - profile/ → service/profile/ (preset plugin profiles are a service concern) - scripts/ → internal/scripts/ (install script is not public API) - test/ → internal/test/ (test harness is not public API) - util/ → internal/util/ (internal helpers shouldn't be imported externally) Also fixes CLAUDE.md merge conflict markers and updates project structure documentation. All import paths updated. Build and tests pass. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * refactor: redesign model package to match framework conventions Rename model.Database interface to model.Model (consistent with client.Client, server.Server, store.Store). Remove generics in favor of interface{}-based API with reflection. Key changes: - model.Model interface: Register once, CRUD infers table from type - DefaultModel + NewModel() + package-level convenience functions - Schema registered via Register(&User{}), no per-call schema passing - Memory implementation as default (in model package, like store) - memory/sqlite/postgres backends updated for new interface - protoc-gen-micro generates RegisterXModel() instead of generic factory - All docs, blog, and README updated https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: clarify blog post 7 uses modular monolith, not multi-service Blog post 7 demonstrated all handlers in a single process but framed it as microservices without acknowledging the architectural difference. - Add "A Note on Architecture" section explaining this is a modular monolith demo and pointing to micro/blog for multi-service - Clarify that handlers can be broken out into separate services later - Fix "service registry" language to match single-process reality - Restructure "Adding MCP to Existing Services" to distinguish the in-process approach from registry-based gateway options - Update closing to acknowledge both paradigms - Fix README type names (&CommentService{} -> &Comments{}, etc.) https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: add Micro Chat to website showcase https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: github artifact release CI (#2886) * 👷feat(ci): add artifact and docker releases * 💚fix(ci): build issues * 💚fix(ci): add permissions * 💚fix(ci): multiple artifacts * 💚fix(ci): split archives * 💚fix(ci): cross platform list * 🚧chore(ci): package name * 🐛fix(script): install script extract arch * 👷fix(ci): docker origin go-micro * Update image reference in goreleaser configuration (#2887) Fix wrong order `user/repo` * Add blog post on building a chat app with Go Micro Added a blog post detailing the development of a full chat app using Go Micro, outlining features, architecture, and lessons learned. * docs: add blog post 8 to index, put Blog before Docs on homepage - Add "We Built a Full Chat App in a Day" (blog/8) to blog index - Reorder homepage links: Blog first (primary), Docs second - Rename "Documentation" to "Docs" https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: Alexander Serheyev <74361701+alex-dna-tech@users.noreply.github.com> |
||
|
Asim Aslam
|
b8fc0902d7 |
Claude/update docs roadmap f zd2 j (#2883)
* feat: add agent platform showcase and blog post Add a complete platform example (Users, Posts, Comments, Mail) that mirrors micro/blog, demonstrating how existing microservices become AI-accessible through MCP with zero code changes. Includes blog post "Your Microservices Are Already an AI Platform" walking through real agent workflows: signup, content creation, commenting, tagging, and cross-service messaging. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * refactor: rename handler types to drop redundant Service suffix UserService → Users, PostService → Posts, CommentService → Comments, MailService → Mail. Matches micro/blog naming convention. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
76bfeae456 |
Claude/update docs roadmap f zd2 j (#2880)
* docs: update all four documentation guides and mark Q2 complete - ai-native-services: add WithMCP one-liner, standalone gateway, WebSocket client example, and OpenTelemetry observability section - mcp-security: add OTel distributed tracing, WebSocket authentication (connection-level and per-message), DeniedReason audit field - tool-descriptions: add manual overrides with WithEndpointDocs and export formats section - agent-patterns: add LangChain/LlamaIndex SDK pattern and standalone gateway production pattern with Docker example - Update roadmap: mark Q2 documentation as complete, Q2 at 100% - Update status: reflect all recent completions, shift priorities https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add agent demo example and blog post Add examples/agent-demo with a multi-service project management app (projects, tasks, team) that demonstrates AI agents interacting with Go Micro services through MCP. Includes seed data and example prompts. Add blog post 4 "Agents Meet Microservices: A Hands-On Demo" walking through the example code and showing cross-service agent workflows. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: enable multiple services in a single binary Remove global state mutations from service and cmd option functions so that configuring one service no longer overwrites another's settings. Key changes: - service/options.go: remove all DefaultXxx global writes from option functions; newOptions() now creates fresh Server, Client, Store, and Cache per service while sharing Registry, Broker, and Transport - cmd/cmd.go: newCmd() uses local copies instead of pointers to package globals; Before() no longer mutates DefaultXxx vars - cmd/options.go: remove global mutations from all option functions - service/service.go: export ServiceImpl type for cross-package use - service/group.go: new Group type for multi-service lifecycle - micro.go: add Start/Stop to Service interface, expose Group and NewGroup convenience function - examples/multi-service: working example with two services https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: highlight multi-service binary support Add multi-service section to README with code example, update features list, add to examples index, and note in status summary. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: unify service API and clean up developer experience - Unified service creation: micro.New("name", opts...) as canonical API - Clean handler registration: service.Handle(handler, opts...) accepts server.HandlerOption args directly, no need to reach through Server() - Unexported serviceImpl: users interact through Service interface only - Service groups use Service interface (not concrete type) - Fixed Stop() to properly propagate BeforeStop/AfterStop errors - Fixed store init: error-level log instead of fatal on init failure - Updated all examples to use consistent patterns - Updated README, getting-started, MCP docs, and guides - Added blog post about the DX cleanup https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * fix: add blog post 5 to blog index Blog post 5 (Developer Experience Cleanup) existed as a file but was missing from the blog index page. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: make micro new generate MCP-enabled services by default - main.go template includes mcp.WithMCP(":3001") by default - Handler template has agent-friendly doc comments with @example tags - Proto template has descriptive field comments - README includes MCP usage, Claude Code config, and tool description tips - Makefile adds mcp-tools, mcp-test, mcp-serve targets - go.mod updated to Go 1.22 - Added --no-mcp flag to opt out of MCP integration - Post-create output shows MCP endpoint URLs https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: add MCP migration guide and troubleshooting guide - Migration guide: 3 approaches to add MCP to existing services (WithMCP one-liner, standalone gateway, CLI) - Troubleshooting guide: common issues with agents, WebSocket, Claude Code, auth, rate limiting, and performance https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * refactor: rename model/ package to ai/ for AI model providers The model/ package name conflicted with the conventional use of "model" for data models. Renamed to ai/ which better describes the package's purpose (AI provider abstraction for Anthropic, OpenAI, etc.) and frees up model/ for future data model layer use. - Rename model/ → ai/ with package name change - Update all Go imports from go-micro.dev/v5/model to go-micro.dev/v5/ai - Update cmd/micro/server/server.go references (model.X → ai.X) - Update all documentation and roadmap references - All tests pass, CLI builds successfully https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add model package for typed data access with CRUD and queries New model/ package provides a typed data model layer using Go generics. Supports structured CRUD operations, WHERE filters, ordering, pagination, and automatic schema creation from struct tags. Three backends: - memory: in-memory for development and testing - sqlite: embedded SQL for dev and single-node production - postgres: full PostgreSQL for production deployments Key features: - Generic Model[T] with Create/Read/Update/Delete/List/Count - Query builder: Where(), WhereOp(), OrderAsc/Desc(), Limit(), Offset() - Struct tags: model:"key" for primary key, model:"index" for indexes - Auto table creation from struct schema - 19 tests passing across memory and sqlite backends https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add model code generation to protoc-gen-micro Extend the micro plugin to generate model structs from proto messages annotated with // @model. Generated alongside client/server code in the same .pb.micro.go file. For a proto message like: // @model message User { string id = 1; string name = 2; } Generates: - UserModel struct with model:"key" and json tags - NewUserModel(db) factory returning *model.Model[UserModel] - UserModelFromProto(*User) *UserModel converter - (*UserModel).ToProto() *User converter Supports @model(table=custom_table, key=custom_field) options. Adds GetComments() to generator for plugin comment inspection. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add Model() to Service interface for Client/Server/Model trifecta Every service now exposes Client(), Server(), and Model() — call services, handle requests, and save/query data from the same interface. Includes README docs, blog post, and a full model guide on the docs site. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
19892f2c67 |
Claude/update docs roadmap f zd2 j (#2874)
* docs: update all four documentation guides and mark Q2 complete - ai-native-services: add WithMCP one-liner, standalone gateway, WebSocket client example, and OpenTelemetry observability section - mcp-security: add OTel distributed tracing, WebSocket authentication (connection-level and per-message), DeniedReason audit field - tool-descriptions: add manual overrides with WithEndpointDocs and export formats section - agent-patterns: add LangChain/LlamaIndex SDK pattern and standalone gateway production pattern with Docker example - Update roadmap: mark Q2 documentation as complete, Q2 at 100% - Update status: reflect all recent completions, shift priorities https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add agent demo example and blog post Add examples/agent-demo with a multi-service project management app (projects, tasks, team) that demonstrates AI agents interacting with Go Micro services through MCP. Includes seed data and example prompts. Add blog post 4 "Agents Meet Microservices: A Hands-On Demo" walking through the example code and showing cross-service agent workflows. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: enable multiple services in a single binary Remove global state mutations from service and cmd option functions so that configuring one service no longer overwrites another's settings. Key changes: - service/options.go: remove all DefaultXxx global writes from option functions; newOptions() now creates fresh Server, Client, Store, and Cache per service while sharing Registry, Broker, and Transport - cmd/cmd.go: newCmd() uses local copies instead of pointers to package globals; Before() no longer mutates DefaultXxx vars - cmd/options.go: remove global mutations from all option functions - service/service.go: export ServiceImpl type for cross-package use - service/group.go: new Group type for multi-service lifecycle - micro.go: add Start/Stop to Service interface, expose Group and NewGroup convenience function - examples/multi-service: working example with two services https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: highlight multi-service binary support Add multi-service section to README with code example, update features list, add to examples index, and note in status summary. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: unify service API and clean up developer experience - Unified service creation: micro.New("name", opts...) as canonical API - Clean handler registration: service.Handle(handler, opts...) accepts server.HandlerOption args directly, no need to reach through Server() - Unexported serviceImpl: users interact through Service interface only - Service groups use Service interface (not concrete type) - Fixed Stop() to properly propagate BeforeStop/AfterStop errors - Fixed store init: error-level log instead of fatal on init failure - Updated all examples to use consistent patterns - Updated README, getting-started, MCP docs, and guides - Added blog post about the DX cleanup https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * fix: add blog post 5 to blog index Blog post 5 (Developer Experience Cleanup) existed as a file but was missing from the blog index page. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
ffe43e0e6d |
Claude/update docs roadmap f zd2 j (#2871)
* docs: update all four documentation guides and mark Q2 complete - ai-native-services: add WithMCP one-liner, standalone gateway, WebSocket client example, and OpenTelemetry observability section - mcp-security: add OTel distributed tracing, WebSocket authentication (connection-level and per-message), DeniedReason audit field - tool-descriptions: add manual overrides with WithEndpointDocs and export formats section - agent-patterns: add LangChain/LlamaIndex SDK pattern and standalone gateway production pattern with Docker example - Update roadmap: mark Q2 documentation as complete, Q2 at 100% - Update status: reflect all recent completions, shift priorities https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add agent demo example and blog post Add examples/agent-demo with a multi-service project management app (projects, tasks, team) that demonstrates AI agents interacting with Go Micro services through MCP. Includes seed data and example prompts. Add blog post 4 "Agents Meet Microservices: A Hands-On Demo" walking through the example code and showing cross-service agent workflows. https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
Asim Aslam
|
beeaad748e |
Claude/update docs roadmap f zd2 j (#2868)
* feat: add LlamaIndex SDK for Go Micro services Add LlamaIndex integration package that enables LlamaIndex agents to discover and call Go Micro microservices through the MCP gateway. Follows the same pattern as the existing LangChain SDK. - GoMicroToolkit with from_gateway() factory and tool filtering - FunctionTool integration via llama_index.core.tools - Auth support, error handling, and retry configuration - Examples for basic agent and RAG + microservices workflows - Unit tests with mocked gateway responses https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * docs: update status for OTel, WebSocket, and LlamaIndex SDK completion Reflect recently completed work in roadmap and status documents: - Q2 progress: 85% -> 95% (WebSocket, LlamaIndex SDK done) - Q3 progress: 40% -> 50% (OpenTelemetry integration done) - Transports: 2 -> 3 (added WebSocket) - Agent SDKs: 1 -> 2 (added LlamaIndex) - Test coverage: 568 -> 1,000+ lines https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc * feat: add WithMCP convenience option, improve startup banner, and blog post - Add mcp.WithMCP(":3000") service option for one-line MCP setup - Improve `micro run` startup banner to show Agent playground, MCP tools, and WebSocket endpoints prominently - Add blog post: "Building the AI-Native Future of Go Micro with Claude" covering WebSocket transport, OTel integration, LlamaIndex SDK, and Anthropic's Claude Max sponsorship - Update blog index and navigation links https://claude.ai/code/session_01GkduEhcrqcG45rdfYh8dAc --------- Co-authored-by: Claude <noreply@anthropic.com> |
||
|
asim
|
e311586bd2 | update mcp doc location | ||
|
asim
|
8d0180aef1 |
v5.15.0: Unified Gateway Architecture + MCP Support
Major Features: - Unified gateway architecture (micro run + micro server use same code) - MCP (Model Context Protocol) integration as library package - AI-accessible microservices with 3 lines of code Gateway Unification: - Created reusable gateway module (cmd/micro/server/gateway.go) - Updated micro run to use unified gateway (removed duplicate code) - Conditional authentication (disabled in dev, required in prod) - Reduced code duplication, simplified maintenance MCP Integration: - New library package: gateway/mcp - Automatic service discovery → MCP tools - HTTP/SSE transport support (stdio coming soon) - Works for both library users and CLI users - CLI flags: --mcp-address for micro run and micro server Documentation: - ADR-010: Unified Gateway Architecture - CLI & Gateway Guide for users - MCP Gateway README and examples - Blog post: Making Your Microservices AI-Native with MCP Breaking Changes: None (fully backward compatible) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> |
||
|
Shelley
|
cf9629c41f |
Add blog section with first post: Introducing micro deploy
- /blog/ - Blog index page - /blog/1 - First post announcing micro deploy - /docs/deployment.md - Deployment guide in website docs - Updated navigation to include Blog link - New blog layout template Co-authored-by: Shelley <shelley@exe.dev> |