AWS Bedrock

[cmac4603]

I'm seen one mention of bedrock in this repo, and it seems it can be used but with some issues? Is anyone able to clarify if how to get it to work/if it works? A bit confused if it's available, if anyone can share anything would be greatly appreciated

[cefigueiredo]

@pettni Wasn't you who manage to make this integration work? Could you help on that?
It would be really helpful if there were a post anywhere describing the steps to make this work.

[lfilho]

Also interested in this

[ivo-toby]

Bedrock now support longlive API tokens: https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html

This makes Bedrock very interesting option for inference in CodeCompanion, especially for enterprise software engineers like myself :D

[pettni]

My full lazy config is below. You'd need to modify the get_credentials function with your preferred way to get credentials (AccessKeyId, SecretAccessKey, SessionToken). Or use some other option from https://codecompanion.olimorris.dev/extending/adapters.html#environment-variables to set the aws_access_key_id, aws_secret_access_key, aws_session_token variables

This is for anthropic models only.

-- Get aws credentials from 'ada' command
local function get_credentials(name)
  <IMPLEMENTATION HERE>
end

-- Parse bedrock streaming response into format expected by regular anthropic adapter
local function parse_bedrock_stream(chunk)
  local decoded_chunks = {}
  for bedrock_data_match in chunk:gmatch 'event(%b{})' do
    local ok, json_data = pcall(vim.json.decode, bedrock_data_match)
    if ok and json_data.bytes then
      local decoded_data = vim.base64.decode(json_data.bytes)
      table.insert(decoded_chunks, decoded_data)
    end
  end
  return decoded_chunks
end

-- Success marker from upstream anthropic adapter
local STATUS_SUCCESS = 'success'

-- Merge content strings
local function merge_content(target, source)
  if not source or source == '' then return target end
  return (target or '') .. source
end

-- Merge dicts of type { content: str, signature: str }
local function merge_reasoning(target, source)
  if not source then return target end
  target = target or { content = nil, signature = nil }
  target.content = merge_content(target.content, source.content)
  target.signature = merge_content(target.signature, source.signature)
  return target
end

return {
  {
    'olimorris/codecompanion.nvim',
    lazy = true,
    cmd = {
      'CodeCompanion',
      'CodeCompanionChat',
    },
    keys = {
      { '<leader>ll', ':CodeCompanionChat toggle<CR>', desc = 'Toggle chat' },
      { '<leader>la', ':CodeCompanionAction<CR>', desc = 'Run action' },
      { '<leader>lp', ':CodeCompanion<CR>', desc = 'Prompt' },
      { '<leader>lc', ':CodeCompanionCmd<CR>', desc = 'Command' },
    },
    dependencies = {
      'nvim-lua/plenary.nvim',
      'nvim-treesitter/nvim-treesitter',
    },
    opts = {
      adapters = {
        bedrock = function()
          local anthropic = require 'codecompanion.adapters.anthropic'

          ---@class Bedrock.Adapter: CodeCompanion.Adapter
          return require('codecompanion.adapters').extend('anthropic', {
            name = 'bedrock',
            formatted_name = 'Bedrock',
            url = 'https://bedrock-runtime.${aws_region}.amazonaws.com/model/${model}/${endpoint}',
            env = {
              aws_access_key_id = function() return get_credentials 'AccessKeyId' end,
              aws_region = 'schema.region.default',
              aws_secret_access_key = function() return get_credentials 'SecretAccessKey' end,
              aws_session_token = function() return get_credentials 'SessionToken' end,
              endpoint = function(self)
                if self.opts.stream then
                  return 'invoke-with-response-stream'
                else
                  return 'invoke'
                end
              end,
              model = 'schema.model.default',
            },
            headers = {
              ['x-amz-security-token'] = '${aws_session_token}',
            },
            raw = {
              '--aws-sigv4',
              'aws:amz:${aws_region}:bedrock',
              '--user',
              '${aws_access_key_id}:${aws_secret_access_key}',
            },
            handlers = {
              setup = function(_) return true end,
              tokens = function(self, data)
                local total_tokens = 0
                if self.opts.stream then
                  for _, message in ipairs(parse_bedrock_stream(data)) do
                    total_tokens = total_tokens + (anthropic.handlers.tokens(self, message) or 0)
                  end
                else
                  total_tokens = anthropic.handlers.tokens(self, data)
                end
                return total_tokens
              end,
              chat_output = function(self, data, tools)
                if not self.opts.stream then return anthropic.handlers.chat_output(self, data, tools) end

                local output = { role = nil, reasoning = nil, content = nil }
                local chunks = parse_bedrock_stream(data)
                if not chunks or #chunks == 0 then return { status = STATUS_SUCCESS, output = output } end

                for _, message in ipairs(chunks) do
                  local part = anthropic.handlers.chat_output(self, message, tools)
                  if not part then goto continue end

                  -- Handle error status
                  if part.status ~= STATUS_SUCCESS then return { status = part.status, output = output } end

                  -- Merge successful response data
                  if part.output then
                    output.role = output.role or part.output.role
                    output.reasoning = merge_reasoning(output.reasoning, part.output.reasoning)
                    output.content = merge_content(output.content, part.output.content)
                  end

                  ::continue::
                end
                return {
                  status = STATUS_SUCCESS,
                  output = output,
                }
              end,
            },
            schema = {
              model = {
                mapping = 'temp',
                default = 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
                choices = {
                  ['us.anthropic.claude-sonnet-4-20250514-v1:0'] = { opts = { can_reason = true, has_vision = true } },
                  ['us.anthropic.claude-3-7-sonnet-20250219-v1:0'] = { opts = { can_reason = true, has_vision = true } },
                },
              },
              region = {
                type = 'string',
                default = 'us-west-2',
                desc = 'AWS region',
                choices = {
                  'us-east-1',
                  'us-east-2',
                  'us-west-1',
                  'us-west-2',
                },
              },
              anthropic_version = {
                mapping = 'parameters',
                type = 'string',
                optional = false,
                default = 'bedrock-2023-05-31',
                desc = 'Bedrock anthropic API version',
              },
            },
          })
        end,
      },
      display = {
        chat = {
          show_settings = true,
          window = {
            layout = 'vertical',
            position = 'right',
          },
        },
      },
      strategies = {
        chat = {
          adapter = 'bedrock',
        },
        inline = {
          adapter = 'bedrock',
        },
      },
      opts = {
        log_level = 'DEBUG',
      },
    },
  },
}

[hernancerm]

Now that Claude Code is supported by CodeCompanion I noticed this setup works to use Claude Sonnet through Amazon Bedrock:

1. Install Claude Code as per: https://claude.com/product/claude-code

2. Configure AWS credentials, I prefer using the AWS CLI configuration (~/.aws).

3. Set environment variables in: ~/.zshrc (or your shell's startup file).

# Claude Code
# <https://docs.claude.com/en/docs/claude-code/amazon-bedrock>

# Enable Bedrock integration
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-west-2

# Recommended output token settings for Bedrock
export CLAUDE_CODE_MAX_OUTPUT_TOKENS=4096
export MAX_THINKING_TOKENS=1024

4. Use this minimal codecompanion.nvim configuration (here using lazy.nvim):

{
  "olimorris/codecompanion.nvim",
  opts = {
    strategies = {
      chat = {
        adapter = "claude_code",
      }
    }
  }
},

5. :CodeCompanionChat should work using Claude Code and Amazon Bedrock.

[cefigueiredo]

Great news! Thanks for sharing that! I missed the release of this new adapter.