AWS Bedrock

Amazon Bedrock exposes foundation models from several vendors (Anthropic Claude, Meta Llama, Amazon Titan and Nova, and others) behind one API. The llms/bedrock package talks to it through the AWS SDK.

Prerequisites

• AWS credentials with Bedrock access, resolved the standard AWS way (environment variables such as AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY / AWS_REGION, a shared profile, or an IAM role).
• Access enabled for the specific model IDs you intend to call, in your region.

Setup

llm, err := bedrock.New(
    bedrock.WithModel(bedrock.ModelAnthropicClaudeSonnet5),
)

If no model is set, the client defaults to Claude Haiku 4.5. Model IDs are available as constants in the package (see models_list.go), or pass any Bedrock model ID string. For non-Anthropic models whose provider cannot be inferred from the ID, set it explicitly with bedrock.WithModelProvider.

Useful options:

• bedrock.WithConverseAPI() — use the unified Converse API. Claude models support tool use and reasoning on the default InvokeModel path as well; for every other provider those features are only available through Converse. Structured output works on both paths for the Claude models Bedrock serves it for (Opus 4.6 and 4.5, Sonnet 4.6 and 4.5, Haiku 4.5).
• bedrock.WithAutomaticCaching() — enable Anthropic prompt caching on supported Claude models.
• bedrock.WithClient(...) — supply a preconfigured *bedrockruntime.Client.

Example

package main

import (
	"context"
	"flag"
	"fmt"
	"log"

	"github.com/vxcontrol/langchaingo/llms"
	"github.com/vxcontrol/langchaingo/llms/bedrock"
)

func main() {
	var (
		modelID   = flag.String("model", "amazon.titan-text-lite-v1", "Model ID to use")
		provider  = flag.String("provider", "", "Explicit provider (optional)")
		prompt    = flag.String("prompt", "Say hello in one word", "Prompt to send")
		awsRegion = flag.String("region", "us-east-1", "AWS region")
		verbose   = flag.Bool("verbose", false, "Enable verbose output")
	)
	flag.Parse()

	ctx := context.Background()

	// Create Bedrock LLM options
	opts := []bedrock.Option{
		bedrock.WithModel(*modelID),
	}

	// Add explicit provider if specified
	if *provider != "" {
		opts = append(opts, bedrock.WithModelProvider(*provider))
		if *verbose {
			fmt.Printf("Using explicit provider: %s\n", *provider)
		}
	}

	// Create LLM instance
	llm, err := bedrock.New(opts...)
	if err != nil {
		log.Fatalf("Failed to create Bedrock LLM: %v", err)
	}

	if *verbose {
		fmt.Printf("Model ID: %s\n", *modelID)
		fmt.Printf("AWS Region: %s\n", *awsRegion)
		fmt.Printf("Prompt: %s\n", *prompt)
		fmt.Println("---")
	}

	// Test 1: Simple Call
	fmt.Println("Testing Call method:")
	response, err := llm.Call(ctx, *prompt)
	if err != nil {
		log.Printf("Error calling model: %v", err)
	} else {
		fmt.Printf("Response: %s\n", response)
	}

	// Test 2: GenerateContent with messages
	fmt.Println("\nTesting GenerateContent method:")
	messages := []llms.MessageContent{
		{
			Role: llms.ChatMessageTypeSystem,
			Parts: []llms.ContentPart{
				llms.TextPart("You are a helpful assistant."),
			},
		},
		{
			Role: llms.ChatMessageTypeHuman,
			Parts: []llms.ContentPart{
				llms.TextPart(*prompt),
			},
		},
	}

	resp, err := llm.GenerateContent(ctx, messages)
	if err != nil {
		log.Printf("Error generating content: %v", err)
	} else {
		if len(resp.Choices) > 0 && len(resp.Choices[0].Content) > 0 {
			fmt.Printf("Response: %s\n", resp.Choices[0].Content)
		}
	}
}