Metalogue
Docs

Go SDK

Full reference for the Metalogue Go SDK.

Go SDK

Official Go SDK for the Metalogue API.

Installation

go get github.com/metalogue/metalogue-sdk-go

Quick Start

package main

import (
    "context"
    "fmt"
    "os"

    metalogue "github.com/metalogue/metalogue-sdk-go"
)

func main() {
    client := metalogue.NewClient(os.Getenv("METALOGUE_API_KEY"))

    response, err := client.Query(context.Background(), "What was the auth decision?", nil)
    if err != nil {
        panic(err)
    }

    for _, result := range response.Results {
        fmt.Printf("[%s] %s\n", result.Source, result.Content)
    }
}

Configuration

// Basic initialization
client := metalogue.NewClient("mlo_xxxxxxxxxxxx")

// With options
client := metalogue.NewClient("mlo_xxxxxxxxxxxx",
    metalogue.WithBaseURL("https://api.metalogue.xyz"),
    metalogue.WithTimeout(30 * time.Second),
)

// From environment
client := metalogue.NewClientFromEnv() // Uses METALOGUE_API_KEY

Methods

Query

response, err := client.Query(ctx, "What was the auth decision?", &metalogue.QueryOptions{
    Limit:            10,
    IncludeReasoning: true,
    Sources:          []string{"slack", "notion"},
    DateAfter:        "2026-01-01",
    DateBefore:       "2026-01-31",
    Authors:          []string{"alice@example.com"},
    Types:            []string{"message", "document"},
})

// Response types
type QueryResponse struct {
    Results   []QueryResult `json:"results"`
    Reasoning string        `json:"reasoning,omitempty"`
    QueryID   string        `json:"query_id"`
    LatencyMs int64         `json:"latency_ms"`
}

type QueryResult struct {
    ID         string                 `json:"id"`
    Content    string                 `json:"content"`
    Source     string                 `json:"source"`
    SourceType string                 `json:"source_type"`
    Score      float64                `json:"score"`
    Metadata   map[string]interface{} `json:"metadata"`
    URL        string                 `json:"url,omitempty"`
}

Connectors

// List all connectors
connectors, err := client.ListConnectors(ctx)

// Get specific connector
connector, err := client.GetConnector(ctx, "slack-123")

// Create connector
newConnector, err := client.CreateConnector(ctx, metalogue.CreateConnectorRequest{
    ConnectorType: "slack",
    DisplayName:   "Company Slack",
    Credentials:   map[string]interface{}{"token": "xoxb-..."},
    Settings:      map[string]interface{}{"channels": []string{"general"}},
})

// Sync connector
err = client.SyncConnector(ctx, "slack-123", true) // full sync

// Execute agentic action
result, err := client.ExecuteAction(ctx, "slack-123", metalogue.ActionParams{
    Intent:  "Send message to #general",
    Context: map[string]interface{}{"priority": "high"},
    DryRun:  false,
})

// Delete connector
err = client.DeleteConnector(ctx, "slack-123")

Audit Logs

// Get audit logs
logs, err := client.GetAuditLogs(ctx, &metalogue.AuditOptions{
    Limit:  100,
    Action: "query.executed",
    Start:  "2026-01-01T00:00:00Z",
    End:    "2026-01-31T23:59:59Z",
})

// Export SOC2 report
report, err := client.ExportSOC2(ctx, "2026-01-01", "2026-01-31")

Usage & Billing

// Get usage metrics
usage, err := client.GetUsage(ctx, "month")

// Get subscription
subscription, err := client.GetSubscription(ctx)

Users

// List users
users, err := client.ListUsers(ctx)

// Invite user
err = client.InviteUser(ctx, "bob@example.com", "member")

Error Handling

response, err := client.Query(ctx, "...")
if err != nil {
    switch e := err.(type) {
    case *metalogue.RateLimitError:
        fmt.Printf("Retry after %d seconds\n", e.RetryAfter)
        time.Sleep(time.Duration(e.RetryAfter) * time.Second)
    case *metalogue.AuthenticationError:
        log.Fatal("Invalid API key")
    case *metalogue.NotFoundError:
        log.Fatal("Resource not found")
    case *metalogue.MetalogueError:
        log.Fatalf("API error: %s", e.Message)
    default:
        log.Fatalf("Error: %v", err)
    }
}

Context and Cancellation

All methods accept a context for cancellation:

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

response, err := client.Query(ctx, "...")
if ctx.Err() == context.DeadlineExceeded {
    log.Println("Query timed out")
}

Next Steps