Function calling with Claude on Amazon Bedrock in .NET Core

To call Claude with function calling (tool use) on Amazon Bedrock in .NET Core, you must set the InputSchema JSON type field to "object" at the top level of the schema. The error The value at toolConfig.tools.0.toolSpec.inputSchema.json.type must be one of the following: object occurs when the JSON object you pass to ToolInputSchema.Json has a type field that is not exactly "object". The fix is to ensure your anonymous type or dictionary includes Type = "object" as a top-level property, and that the Properties dictionary is correctly structured with nested objects for each property definition. The working code example below resolves this issue and demonstrates a complete function calling flow with Claude on Bedrock in .NET Core.

The Full Answer

This guide covers how to implement function calling (tool use) with Claude on Amazon Bedrock using .NET Core and the official AWSSDK.BedrockRuntime NuGet package (version 3.7.412.3 or later). The core challenge is correctly constructing the ToolInputSchema JSON so that the Bedrock API accepts it. We will walk through the complete setup, including the corrected code, prerequisites, and step-by-step explanation.

Prerequisites

Before you begin, ensure you have:

• An AWS account with access to Amazon Bedrock. You must have requested access to the Claude model (e.g., anthropic.claude-3-sonnet-20240229-v1:0) in the AWS console.
• AWS credentials configured on your development machine (via environment variables, AWS CLI, or IAM roles).
• .NET Core SDK (version 6.0 or later) installed.
• The AWSSDK.BedrockRuntime NuGet package installed in your project. You can add it via the .NET CLI:

dotnet add package AWSSDK.BedrockRuntime --version 3.7.412.3

Or via the Package Manager Console:

Install-Package AWSSDK.BedrockRuntime -Version 3.7.412.3

Step-by-Step Implementation

Step 1: Set up the Bedrock client and message list

Create an instance of the AmazonBedrockRuntimeClient and prepare the conversation messages. The example below starts with a user message asking for the most popular song on a radio station.

using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;

var bedrock = new AmazonBedrockRuntimeClient(Amazon.RegionEndpoint.USWest2); // Use your region

var messages = new List<Message>
{
    new Message
    {
        Role = ConversationRole.User,
        Content = new List<ContentBlock>
        {
            new ContentBlock { Text = "Get the most popular song played on a radio station." }
        }
    }
};

Explanation: The AmazonBedrockRuntimeClient is the entry point for all Bedrock API calls. The Messages list holds the conversation history. Each message has a Role (User or Assistant) and Content blocks. For a simple function call request, we start with a user message that describes the task.

Step 2: Define the tool configuration with correct JSON schema

The critical part is the ToolConfiguration object. The error from the original code occurs because the InputSchema.Json object must have a top-level type field set to "object". The Properties dictionary must contain nested objects for each property, each with its own type and description. The Required array lists property names that are mandatory.

Here is the corrected tool configuration:

var toolConfig = new ToolConfiguration
{
    Tools = new List<Tool>
    {
        new Tool
        {
            ToolSpec = new ToolSpecification
            {
                Name = "GetSong",
                Description = "Gets the current song on the radio",
                InputSchema = new ToolInputSchema
                {
                    Json = Document.FromObject(new
                    {
                        Type = "object",  // Must be exactly "object"
                        Properties = new Dictionary<string, object>
                        {
                            {
                                "sign", new
                                {
                                    Type = "string",
                                    Description = "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
                                }
                            }
                        },
                        Required = new string[] { "sign" }
                    })
                }
            }
        }
    }
};

Key points:

• The Type property at the top level of the anonymous object is set to "object". This satisfies the Bedrock API requirement that the input schema must be a JSON object type.
• The Properties dictionary uses string keys (property names) and object values (each property's schema). Each property schema must itself be an object with Type and Description.
• The Required array lists property names that Claude must provide when it decides to call the tool.
• Document.FromObject() converts the anonymous object into the Amazon.Runtime.Documents.Document type that the SDK expects.

Step 3: Make the Converse API call

Now, send the request to Bedrock:

var response = await bedrock.ConverseAsync(new ConverseRequest
{
    ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
    Messages = messages,
    ToolConfig = toolConfig
});

Explanation: The ConverseAsync method sends the conversation and tool configuration to the specified model. The response will contain either a text response or a ToolUse content block if Claude decides to call the GetSong tool.

Step 4: Handle the response

After the API call, you need to process the response. Claude may respond with a ToolUse content block, which includes the tool name and input parameters. Here is how to handle it:

if (response.Output.Message.Content.Any(c => c.ToolUse != null))
{
    var toolUse = response.Output.Message.Content.First(c => c.ToolUse != null);
    Console.WriteLine($"Tool called: {toolUse.ToolUse.Name}");
    Console.WriteLine($"Input: {toolUse.ToolUse.Input}");
    
    // Extract the sign parameter
    var sign = toolUse.ToolUse.Input.ToString(); // You may need to parse this JSON
    Console.WriteLine($"Sign requested: {sign}");
    
    // Here you would call your actual function (e.g., a database query or API)
    // and then send the result back to Claude in a follow-up message.
}
else
{
    // Claude responded with text
    var text = response.Output.Message.Content.First(c => c.Text != null).Text;
    Console.WriteLine($"Claude says: {text}");
}

Explanation: The response.Output.Message.Content list contains ContentBlock objects. Each block can be of type Text, ToolUse, or ToolResult. When Claude decides to use a tool, it returns a ToolUse block with the Name and Input (a JSON document containing the parameters). You then execute the actual function (e.g., query a database) and return the result in a subsequent message with a ToolResult block.

Complete Working Example

Here is the full corrected code that runs without the validation exception:

using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;

var bedrock = new AmazonBedrockRuntimeClient(Amazon.RegionEndpoint.USWest2);

var messages = new List<Message>
{
    new Message
    {
        Role = ConversationRole.User,
        Content = new List<ContentBlock>
        {
            new ContentBlock { Text = "Get the most popular song played on a radio station." }
        }
    }
};

var toolConfig = new ToolConfiguration
{
    Tools = new List<Tool>
    {
        new Tool
        {
            ToolSpec = new ToolSpecification
            {
                Name = "GetSong",
                Description = "Gets the current song on the radio",
                InputSchema = new ToolInputSchema
                {
                    Json = Document.FromObject(new
                    {
                        Type = "object",
                        Properties = new Dictionary<string, object>
                        {
                            {
                                "sign", new
                                {
                                    Type = "string",
                                    Description = "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
                                }
                            }
                        },
                        Required = new string[] { "sign" }
                    })
                }
            }
        }
    }
};

var response = await bedrock.ConverseAsync(new ConverseRequest
{
    ModelId = "anthropic.claude-3-sonnet-20240229-v1:0",
    Messages = messages,
    ToolConfig = toolConfig
});

// Process the response
if (response.Output.Message.Content.Any(c => c.ToolUse != null))
{
    var toolUse = response.Output.Message.Content.First(c => c.ToolUse != null);
    Console.WriteLine($"Tool called: {toolUse.ToolUse.Name}");
    Console.WriteLine($"Input: {toolUse.ToolUse.Input}");
}
else
{
    var text = response.Output.Message.Content.First(c => c.Text != null).Text;
    Console.WriteLine($"Claude says: {text}");
}

When to Use This Approach

This approach is the standard way to implement function calling with Claude on Amazon Bedrock in .NET Core. Use it when:

• You need Claude to call external functions or APIs based on user input.
• You are building a conversational agent that can perform actions like database queries, API calls, or data processing.
• You want to use the Converse API for a simplified interface compared to the lower-level InvokeModel API.

If you need more control over the model parameters (e.g., temperature, top_p), you can use the InvokeModel or InvokeModelWithResponseStream APIs instead, but the Converse API is recommended for most use cases because it handles message formatting and tool configuration more cleanly.