claude

Claude Model

A Claude model implementation for Eino that implements the ToolCallingChatModel interface. This enables seamless integration with Eino's LLM capabilities for enhanced natural language processing and generation.

Features

• Implements github.com/cloudwego/eino/components/model.Model
• Easy integration with Eino's model system
• Configurable model parameters
• Support for chat completion
• Support for streaming responses
• Custom response parsing support
• Flexible model configuration

Installation

go get github.com/cloudwego/eino-ext/components/model/claude@latest

Quick Start

Here's a quick example of how to use the Claude model:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/cloudwego/eino/schema"

	"github.com/cloudwego/eino-ext/components/model/claude"
)

func main() {
	ctx := context.Background()
	apiKey := os.Getenv("CLAUDE_API_KEY")
	modelName := os.Getenv("CLAUDE_MODEL")
	baseURL := os.Getenv("CLAUDE_BASE_URL")
	if apiKey == "" {
		log.Fatal("CLAUDE_API_KEY environment variable is not set")
	}

	var baseURLPtr *string = nil
	if len(baseURL) > 0 {
		baseURLPtr = &baseURL
	}

	// Create a Claude model
	cm, err := claude.NewChatModel(ctx, &claude.Config{
		// if you want to use Aws Bedrock Service, set these four field.
		// ByBedrock:       true,
		// AccessKey:       "",
		// SecretAccessKey: "",
		// Region:          "us-west-2",

		// if you want to use Google Vertex AI, set ByVertex: true.
		// Pass raw service account JSON via VertexServiceAccountJSON for explicit credentials.
		// ByVertex:                 true,
		// VertexProjectID:          "my-gcp-project",
		// VertexRegion:             "us-east5",
		// VertexServiceAccountJSON: serviceAccountJSON,
		APIKey: apiKey,
		// Model:     "claude-3-5-sonnet-20240620",
		BaseURL:   baseURLPtr,
		Model:     modelName,
		MaxTokens: 3000,
	})
	if err != nil {
		log.Fatalf("NewChatModel of claude failed, err=%v", err)
	}

	messages := []*schema.Message{
		{
			Role:    schema.System,
			Content: "You are a helpful AI assistant. Be concise in your responses.",
		},
		{
			Role:    schema.User,
			Content: "What is the capital of France?",
		},
	}

	resp, err := cm.Generate(ctx, messages, claude.WithThinkingConfig(&anthropic.ThinkingConfigParamUnion{
		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
			Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized,
		},
	}))
	if err != nil {
		log.Printf("Generate error: %v", err)
		return
	}

	thinking, ok := claude.GetThinking(resp)
	fmt.Printf("Thinking(have: %v): %s\n", ok, thinking)
	fmt.Printf("Assistant: %s\n", resp.Content)
	if resp.ResponseMeta != nil && resp.ResponseMeta.Usage != nil {
		fmt.Printf("Tokens used: %d (prompt) + %d (completion) = %d (total)\n",
			resp.ResponseMeta.Usage.PromptTokens,
			resp.ResponseMeta.Usage.CompletionTokens,
			resp.ResponseMeta.Usage.TotalTokens)
	}
}

Configuration

The model can be configured using the claude.ChatModelConfig struct:

type Config struct {
    // ByBedrock indicates whether to use Bedrock Service
    // Required for Bedrock
    ByBedrock bool
    
    // AccessKey is your Bedrock API Access key
    // Obtain from: https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
    // Optional for Bedrock
    AccessKey string
    
    // SecretAccessKey is your Bedrock API Secret Access key
    // Obtain from: https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
    // Optional for Bedrock
    SecretAccessKey string
    
    // SessionToken is your Bedrock API Session Token
    // Obtain from: https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
    // Optional for Bedrock
    SessionToken string
    
    // Profile is your Bedrock API AWS profile
    // This parameter is ignored if AccessKey and SecretAccessKey are provided
    // Obtain from: https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
    // Optional for Bedrock
    Profile string
    
    // Region is your Bedrock API region
    // Obtain from: https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
    // Optional for Bedrock
    Region string

    // ByVertex indicates whether to use Google Vertex AI
    ByVertex bool

    // VertexProjectID is your Google Cloud project ID.
    // If not set, auto-detected from ANTHROPIC_VERTEX_PROJECT_ID, GOOGLE_CLOUD_PROJECT, or GCLOUD_PROJECT
    VertexProjectID string

    // VertexRegion is the Vertex AI region (e.g., "us-east5").
    // If not set, auto-detected from CLOUD_ML_REGION environment variable.
    VertexRegion string

    // VertexServiceAccountJSON is raw GCP service account JSON for Vertex.
    // When non-empty, credentials are built in-memory and passed to vertex.WithCredentials.
    // When empty and ByVertex is true, vertex.WithGoogleAuth (ADC) is used instead.
    VertexServiceAccountJSON []byte
    
    // BaseURL is the custom API endpoint URL
    // Use this to specify a different API endpoint, e.g., for proxies or enterprise setups
    // Optional. Example: "https://custom-claude-api.example.com"
    BaseURL *string
    
    // APIKey is your Anthropic API key for direct Anthropic API access.
    // Obtain from: https://console.anthropic.com/account/keys
    // Optional when AuthToken is set.
    APIKey string

    // AuthToken is your Anthropic auth token for direct Anthropic API access.
    // Optional when APIKey is set.
    AuthToken string

    // Model specifies which Claude model to use
    // Required
    Model string
    
    // MaxTokens limits the maximum number of tokens in the response
    // Range: 1 to model's context length
    // Required. Example: 2000 for a medium-length response
    MaxTokens int
    
    // Temperature controls randomness in responses
    // Range: [0.0, 1.0], where 0.0 is more focused and 1.0 is more creative
    // Optional. Example: float32(0.7)
    Temperature *float32
    
    // TopP controls diversity via nucleus sampling
    // Range: [0.0, 1.0], where 1.0 disables nucleus sampling
    // Optional. Example: float32(0.95)
    TopP *float32
    
    // TopK controls diversity by limiting the top K tokens to sample from
    // Optional. Example: int32(40)
    TopK *int32
    
    // StopSequences specifies custom stop sequences
    // The model will stop generating when it encounters any of these sequences
    // Optional. Example: []string{"\n\nHuman:", "\n\nAssistant:"}
    StopSequences []string
    
    // Deprecated: Use ThinkingConfig instead.
    Thinking *Thinking

    // ThinkingConfig configures Claude thinking using Anthropic SDK's native union.
    ThinkingConfig *anthropic.ThinkingConfigParamUnion

    // HTTPClient specifies the client to send HTTP requests.
    HTTPClient *http.Client `json:"http_client"`

    // RequestTimeout specifies the timeout for each API request.
    // Optional.
    RequestTimeout time.Duration `json:"request_timeout"`
    
    DisableParallelToolUse *bool `json:"disable_parallel_tool_use"`
}

For direct Anthropic API access, authentication resolution works as follows:

• If Config.APIKey or Config.AuthToken is set, Config takes precedence and environment auth settings are ignored.
• Otherwise, it falls back to environment variables.
• Within the chosen source, APIKey and AuthToken can both be set and will both be passed through as-is.
• If neither source provides auth, client creation still succeeds and auth errors surface later when requests are sent.

For Google Vertex AI, authentication resolution works as follows:

• Set ByVertex: true and provide VertexProjectID / VertexRegion, or rely on the environment variables documented on Config.
• When VertexServiceAccountJSON is set, credentials are built in-memory via google.CredentialsFromJSON and passed to vertex.WithCredentials (no ADC or env vars required for auth).
• When VertexServiceAccountJSON is empty, vertex.WithGoogleAuth (Application Default Credentials) is used.

Structured Output

Use ResponseFormat to get JSON responses conforming to a schema:

import (
	"github.com/cloudwego/eino-ext/components/model/claude"
	"github.com/eino-contrib/jsonschema"
)

type ContactInfo struct {
	Name         string `json:"name" jsonschema:"description=Full name"`
	Email        string `json:"email" jsonschema:"description=Email address"`
	PlanInterest string `json:"plan_interest" jsonschema:"description=Plan type"`
}

r := jsonschema.Reflector{AllowAdditionalProperties: false, DoNotReference: true}
s := r.Reflect(&ContactInfo{})

cm, err := claude.NewChatModel(ctx, &claude.Config{
	APIKey:    "your-api-key",
	Model:     "claude-sonnet-4-6-20250514",
	MaxTokens: 1024,
	ResponseFormat: &claude.ResponseFormat{
		Schema: s,
	},
})

You can also use Eino's utils.GoStruct2ParamsOneOf to derive the schema from a Go struct:

import (
	"github.com/cloudwego/eino-ext/components/model/claude"
	"github.com/cloudwego/eino/components/tool/utils"
)

type ContactInfo struct {
	Name         string `json:"name" jsonschema:"description=Full name"`
	Email        string `json:"email" jsonschema:"description=Email address"`
	PlanInterest string `json:"plan_interest" jsonschema:"description=Plan type"`
}

params, _ := utils.GoStruct2ParamsOneOf[ContactInfo]()
s, _ := params.ToJSONSchema()

cm, err := claude.NewChatModel(ctx, &claude.Config{
	APIKey:    "your-api-key",
	Model:     "claude-sonnet-4-6-20250514",
	MaxTokens: 1024,
	ResponseFormat: &claude.ResponseFormat{
		Schema: s,
	},
})

The response format can also be set per-request using WithResponseFormat:

resp, err := cm.Generate(ctx, messages, claude.WithResponseFormat(&claude.ResponseFormat{
	Schema: s,
}))

Examples

See the following examples for more usage:

• Prompt Caching
• Basic Generation
• Image Input
• Intent & Tool Calling
• Streaming Response

For More Details

• Eino Documentation
• Claude Documentation