Skip to content
TruthVouch Docs

Go SDK Quick Start

The TruthVouch Go SDK provides drop-in replacements for OpenAI, Anthropic, and Google AI providers. All LLM calls are automatically governed with fact-checking, PII detection, and policy enforcement.

Status: Coming Soon (Q2 2026)

Expected Installation

Terminal window
go get github.com/truthvouch/truthvouch-go

Requires Go 1.21+.

Planned Features

  • Drop-in provider replacements (OpenAI, Anthropic, Google AI)
  • Streaming support
  • Manual content scanning
  • Batch scanning
  • Circuit breaker with fail-open/fail-closed modes
  • OpenTelemetry integration
  • Context propagation for request cancellation
  • No external HTTP dependencies (uses stdlib net/http)

Planned Quick Start

package main


import (
    "context"
    "fmt"
    tv "github.com/truthvouch/truthvouch-go"
)


func main() {
    client := tv.New(tv.WithAPIKey("tv_live_..."))
    defer client.Close()


    // Drop-in OpenAI replacement
    openai := client.OpenAI()
    resp, err := openai.Chat.Create(context.Background(), tv.ChatRequest{
        Model: "gpt-4o",
        Messages: []tv.Message{{Role: "user", Content: "What is TruthVouch?"}},
    })
    if err != nil {
        panic(err)
    }


    fmt.Println(resp.Content)
    fmt.Printf("Verdict: %s\n", resp.Governance.Verdict)
}

Planned API Overview

Client Initialization

client := tv.New(
    tv.WithAPIKey("tv_live_..."),
    tv.WithGatewayURL("https://gateway.truthvouch.com"),
    tv.WithTimeout(30 * time.Second),
    tv.WithMaxRetries(3),
    tv.WithFailMode(tv.FailModeOpen),
)
defer client.Close()

Drop-In Providers

// OpenAI
openai := client.OpenAI()
resp, err := openai.Chat.Create(ctx, request)


// Anthropic
anthropic := client.Anthropic()
resp, err := anthropic.Messages.Create(ctx, request)


// Google AI
google := client.Google()
resp, err := google.GenerateContent(ctx, prompt)

Manual Scanning

result, err := client.Scan(ctx, &tv.ScanRequest{
    Prompt:   "Tell me about NASA",
    Response: "NASA was founded in 1958...",
})
if err != nil {
    log.Fatal(err)
}


fmt.Printf("Verdict: %s\nTrust Score: %.2f\n", result.Verdict, result.TrustScore)

Batch Scanning

job, err := client.Batch.Submit(ctx, &tv.BatchScanRequest{
    SourceURL:   "s3://my-bucket/docs.jsonl",
    Format:      "jsonl",
    ScanMode:    "deep",
    CallbackURL: "https://myapp.com/webhooks/scan-complete",
})


status, err := client.Batch.GetStatus(ctx, job.ID)
fmt.Printf("Progress: %d%%\n", status.ProgressPercent)

Error Handling

import "github.com/truthvouch/truthvouch-go/errors"


resp, err := client.OpenAI.Chat.Create(ctx, request)
if err != nil {
    switch err.(type) {
    case *errors.PolicyBlockedError:
        log.Printf("Blocked by policy: %v\n", err)
    case *errors.RateLimitError:
        log.Printf("Rate limited, retry after: %v\n", err)
    case *errors.AuthenticationError:
        log.Printf("Auth failed: %v\n", err)
    default:
        log.Printf("Error: %v\n", err)
    }
}

Streaming

stream, err := client.OpenAI.Chat.CreateStream(ctx, request)
if err != nil {
    log.Fatal(err)
}
defer stream.Close()


for {
    chunk, err := stream.Recv()
    if errors.Is(err, io.EOF) {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
    fmt.Print(chunk.Content)
}


gov := stream.GovernanceReport()
fmt.Printf("\nVerdict: %s\n", gov.Verdict)

Timeline

  • Q2 2026: Public beta release with core provider support
  • Q3 2026: GA release with full feature parity

Next Steps