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

> Atlas Cloud joins as an official Go Micro sponsor, bringing 300+ AI models across text, image, and video to the framework's ai package.

---

LLMS index: [llms.txt](/llms.txt)

---

![](blog-atlas.jpg)

We're excited to announce that **[Atlas Cloud](https://www.atlascloud.ai/)** 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.

Their sponsorship supports Go Micro's continued development as an AI-native microservices framework. Like Anthropic's Claude Max sponsorship that accelerated our [MCP integration](/blog/2026/03/04/building-the-ai-native-future-of-go-micro-with-claude/), Atlas Cloud's support helps us maintain and expand the framework for the growing community of developers building AI-powered services.

## What Atlas Cloud Brings

Atlas Cloud's platform stands out for three reasons:

**Breadth of models.** Over 300 curated models including DeepSeek, Qwen, GLM, Kimi for text; GPT Image, Flux, ERNIE for images; and Seedance, Kling, Wan, Veo for video. New SOTA models are deployed on day zero of release.

**OpenAI-compatible API.** Atlas Cloud exposes a `/v1/chat/completions` endpoint that's a drop-in replacement for OpenAI. If you're already using the OpenAI SDK, switching to Atlas Cloud is a one-line change — just swap the base URL.

**Enterprise-ready.** SOC 2 certified, HIPAA compliant, pay-as-you-go pricing with no minimums. Competitive rates, often 48-54% below comparable providers.

## The Integration

Atlas Cloud is available in Go Micro's `ai` package as a registered provider. Here's the quick start:

```go
import (
    "go-micro.dev/v5/ai"
    _ "go-micro.dev/v5/ai/atlascloud"
)

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

resp, err := m.Generate(ctx, &ai.Request{
    Prompt:       "Explain microservices in one paragraph",
    SystemPrompt: "You are a helpful assistant",
})
fmt.Println(resp.Reply)
```

The default model is `llama-3.3-70b` and the default base URL is `https://api.atlascloud.ai`. Both are configurable:

```go
m := ai.New("atlascloud",
    ai.WithAPIKey("your-key"),
    ai.WithModel("deepseek-v4"),
    ai.WithBaseURL("https://api.atlascloud.ai"),
)
```

### Image Generation

Atlas Cloud's image generation models are available through Go Micro's `ImageModel` interface. Generate images from text prompts with the same pattern as text generation:

```go
ig := ai.NewImage("atlascloud",
    ai.WithAPIKey("your-key"),
)

resp, err := ig.GenerateImage(ctx, &ai.ImageRequest{
    Prompt: "A futuristic city skyline at sunset, digital art",
    Size:   "1024x1024",
})

// resp.Images[0].URL contains the generated image
fmt.Println(resp.Images[0].URL)
```

Atlas Cloud supports models like `gpt-image-1`, `flux-2`, and more from their 300+ model catalog. The same `ImageModel` interface works with OpenAI too — swap the provider name and your code stays the same.

### Tool Calling

Atlas Cloud supports OpenAI-compatible function calling, which means it works with Go Micro's tool execution flow. Services registered in the registry become tools that the model can call:

```go

tools := ai.NewTools(service.Registry())
discovered, _ := tools.Discover()

m := ai.New("atlascloud",
    ai.WithAPIKey(key),
    ai.WithTools(tools),
)

resp, _ := m.Generate(ctx, &ai.Request{
    Prompt: "List all users and send a welcome email to each",
    Tools:  discovered,
})
```

The model discovers your services, picks the right endpoints, and the `ToolHandler` executes the RPCs. This works identically to how it works with Anthropic or OpenAI — the provider is swappable.

### micro chat

Atlas Cloud works out of the box with the `micro chat` CLI:

```bash
ATLASCLOUD_API_KEY=your-key micro chat --provider atlascloud
> list all orders from the last week
> create a new user named Alice with role admin
```

### micro run

When running `micro run` or `micro server`, Atlas Cloud is auto-detected if you set the base URL:

```bash
export MICRO_AI_API_KEY=your-atlas-cloud-key
export MICRO_AI_BASE_URL=https://api.atlascloud.ai
micro run
```

The agent playground at `/agent` will use Atlas Cloud for all LLM calls.

## Provider Lineup

With Atlas Cloud, Go Micro now supports seven AI providers:

| Provider | API Format | Default Model |
|----------|-----------|---------------|
| **Anthropic** | Native (Messages API) | `claude-sonnet-4-20250514` |
| **Google Gemini** | Native (generateContent) | `gemini-2.5-flash` |
| **OpenAI** | Native (chat/completions) | `gpt-4o` |
| **Atlas Cloud** | OpenAI-compatible | `llama-3.3-70b` |
| **Groq** | OpenAI-compatible | `llama-3.3-70b-versatile` |
| **Mistral** | OpenAI-compatible | `mistral-large-latest` |
| **Together AI** | OpenAI-compatible | `Llama-3.3-70B-Instruct-Turbo` |

All providers implement the same `ai.Model` interface and work with `ai.Tools`, `micro chat`, and the agent playground.

## Getting Started

1. **Sign up** at [atlascloud.ai](https://www.atlascloud.ai/) and get an API key
2. **Import** the provider:

```go
import _ "go-micro.dev/v5/ai/atlascloud"
```

3. **Use it** in your service, the CLI, or the agent playground

See the full [Atlas Cloud Integration Guide](/docs/guides/atlascloud-integration) for detailed examples, environment variable configuration, and model selection.

## What This Means

Go Micro's position is that every microservice should be agent-accessible, and the model powering the agent should be your choice. Atlas Cloud's 300+ models mean developers aren't locked into a single provider or pricing tier. A service built with Go Micro works with Claude, GPT-4, Gemini, Llama, DeepSeek, or any of the hundreds of models Atlas Cloud offers — same code, different import.

We're grateful to Atlas Cloud for their sponsorship and excited to have them as part of the Go Micro ecosystem.

---

*Go Micro is an open source framework for distributed systems development. [Star us on GitHub](https://github.com/micro/go-micro).*

*Thanks to Atlas Cloud for sponsoring Go Micro and supporting the open source community.*