Open-source Go SDK

GoAI

Name: GoAI SDK
Author: zendev

AI SDK, the Go way.

One unified API across 25+ providers. Streaming, structured output, MCP support, minimal dependencies.

$go get github.com/zendev-sh/goai@latestcopy

Get Started GitHub

main.go

 1  package main
 2
 3  import (
 4      "context"
 5      "fmt"
 6
 7      "github.com/zendev-sh/goai"
 8      "github.com/zendev-sh/goai/provider/openai"
 9  )
10
11  func main() {
12      result, _ := goai.GenerateText(
13          context.Background(),
14          openai.Chat("gpt-4o"),
15          goai.WithPrompt("Explain goroutines."),
16      )
17      fmt.Println(result.Text)
18  }

What's new

v0.7.2NVIDIA NIM provider — New provider. OpenAI-compatible chat + embeddings. E2E tested with meta/llama-3.3-70b-instruct.v0.7.0Cloudflare Workers AI & FPT Smart Cloud — New providers. OpenAI-compatible chat + embeddings. FPT supports Global and Japan regions.v0.6.0OpenTelemetry integration — Tracing, metrics, GenAI semantic conventions.v0.5.8RunPod provider — Serverless vLLM support. Bedrock embeddings. Docs accuracy improvements.

01GenerateText

result, _ := goai.GenerateText(ctx,
    openai.Chat("gpt-4o"),
    goai.WithPrompt("Hello."),
)
fmt.Println(result.Text)

02StreamText

stream, _ := goai.StreamText(ctx,
    anthropic.Chat("claude-sonnet-4-6"),
    goai.WithMessages(msgs...),
)
for chunk := range stream.TextStream() {
    fmt.Print(chunk)
}

03GenerateObject[T]

type Recipe struct {
    Name   string   `json:"name"`
    Steps  []string `json:"steps"`
}
recipe, _ := goai.GenerateObject[Recipe](ctx,
    google.Chat("gemini-2.5-flash"),
    goai.WithPrompt("Pho recipe"),
)

04Tools & Agent Loop

calc := goai.Tool{
    Name:    "calc",
    Execute: evalMath,
}
result, _ := goai.GenerateText(ctx, model,
    goai.WithTools(calc),
    goai.WithMaxSteps(5), // auto loop
    goai.WithPrompt("127 * 43?"),
)

05MCP Client

// Any MCP server → GoAI tools
c := mcp.NewClient("app", "1.0",
    mcp.WithTransport(
        mcp.NewStdioTransport(
            "npx", serverArgs),
    ),
)
c.Connect(ctx)
r, _ := c.ListTools(ctx, nil)
mcp.ConvertTools(c, r.Tools)

06TokenSource

// Auto-refresh OAuth tokens
ts := provider.CachedTokenSource(
    func(ctx) (*provider.Token, error) {
        tok, _ := oauth.Exchange(ctx, code)
        return &provider.Token{
            Value: tok.AccessToken,
        }, nil
    },
)
openai.Chat("gpt-4o",
    openai.WithTokenSource(ts))

25providers

100+models tested

24xfaster cold start

0third-party deps

What's New

v0.7.2 — New provider: NVIDIA NIM (OpenAI-compatible, chat + embeddings). E2E tested with meta/llama-3.3-70b-instruct. Changelog →
v0.7.0 — New providers: Cloudflare Workers AI and FPT Smart Cloud (both OpenAI-compatible, chat + embeddings). Changelog →
v0.6.0 — OpenTelemetry tracing + metrics, context propagation via RequestInfo.Ctx, Langfuse data race fix. Changelog →
v0.5.8 — RunPod provider (serverless vLLM), Bedrock embeddings, and docs accuracy improvements. Changelog →

What is GoAI SDK?

GoAI SDK is an open-source Go library for building AI applications. It provides one unified API across 25+ LLM providers — OpenAI, Anthropic, Google Gemini, AWS Bedrock, Azure OpenAI, Groq, Mistral, Cohere, DeepSeek, Ollama, vLLM, NVIDIA NIM, and more.

Inspired by the Vercel AI SDK, GoAI is designed idiomatically for Go with generics, interfaces, and channels.

Core Features

GenerateText — non-streaming text generation across all providers
StreamText — real-time streaming with auto tool loops via Go channels
GenerateObject[T] — type-safe structured output using Go generics
StreamObject[T] — partial object streaming with typed results
Embed / EmbedMany — text embeddings with auto-chunking
GenerateImage — image generation (OpenAI, Google, Azure, Vertex AI)
Tool Calling — custom tools with auto tool loops (MaxSteps)
20 Provider-Defined Tools — web search, code execution, computer use, file search
MCP Client — connect to any MCP server (stdio, HTTP, SSE), auto-convert tools for GoAI
Prompt Caching — automatic cache control for Anthropic and OpenAI
Observability — built-in Langfuse and OpenTelemetry integrations for tracing generations, tools, and multi-step loops

Why GoAI?

One API, 25+ providers — switch providers by changing one line of code
Minimal deps — core requires only golang.org/x/oauth2; optional OTel integration in separate submodule
Go-native design — generics for type safety, channels for streaming, interfaces for extensibility
24x faster cold start than Vercel AI SDK (569μs vs 13.9ms)
3.1x less memory per request (220KB vs 676KB)

Quick Start

package main

import (
    "context"
    "fmt"

    "github.com/zendev-sh/goai"
    "github.com/zendev-sh/goai/provider/openai"
)

func main() {
    result, _ := goai.GenerateText(context.Background(),
        openai.Chat("gpt-4o"),
        goai.WithPrompt("Explain Go interfaces in one sentence."),
    )
    fmt.Println(result.Text)
}

MCP Support v0.5.0

Connect to any MCP server and use its tools with GoAI:

transport := mcp.NewStdioTransport("npx", []string{"-y", "@modelcontextprotocol/server-github"})
client := mcp.NewClient("my-app", "1.0", mcp.WithTransport(transport))
_ = client.Connect(ctx)
defer client.Close()

tools, _ := client.ListTools(ctx, nil)
goaiTools := mcp.ConvertTools(client, tools.Tools)

result, _ := goai.GenerateText(ctx, model,
    goai.WithTools(goaiTools...),
    goai.WithPrompt("Search for popular Go repositories"),
    goai.WithMaxSteps(5),
)

3 transports (stdio, HTTP, SSE), tools/prompts/resources, pagination, notifications. Learn more →

Supported Providers

OpenAI, Anthropic, Google Gemini, AWS Bedrock, Azure OpenAI, Vertex AI, Cohere, Mistral, xAI (Grok), Groq, DeepSeek, Fireworks, Together AI, DeepInfra, OpenRouter, Perplexity, Cerebras, Cloudflare Workers AI, FPT Smart Cloud, NVIDIA NIM, Ollama, vLLM, RunPod, and any OpenAI-compatible endpoint.

View all providers →

Explore the architecture →

Compare with other Go AI libraries →

GoAI

What's New ​

What is GoAI SDK? ​

Core Features ​

Why GoAI? ​

Quick Start ​

MCP Support v0.5.0 ​

Supported Providers ​