Model Providers

What are Model Providers?

A model provider is a service or platform that hosts and serves large language models through an API. The Strands Agents SDK is provider-agnostic: the same agent code runs against any supported provider, so you can switch providers or run several in one application without rewriting your agent. First-party providers include Amazon Bedrock, Anthropic, OpenAI, and Google; community packages add more, and the custom provider interface covers anything else.

Provider capabilities

You get the same core behavior from every first-party provider, because each one reaches the agent through the same Model interface: streaming responses, tool calling, and structured output work the same way whichever provider you configure. Prompt caching is the capability that varies most, because it depends on the underlying model API.

Provider	Streaming	Tool calling	Structured output	Prompt caching
Amazon Bedrock	✓	✓	✓	✓
Anthropic	✓	✓	✓	✓
OpenAI	✓	✓	✓
OpenAI Responses	✓	✓	✓
Google	✓	✓	✓
Ollama	✓	✓	✓
LiteLLM	✓	✓	✓	✓
Mistral	✓	✓	✓
Llama API	✓	✓	✓
llama.cpp	✓	✓	✓	✓
SageMaker	✓	✓	✓
Vercel	✓	✓	✓	✓
Writer	✓	✓	✓
Custom provider	✓

Streaming uses an async interface in both SDKs, so an async event stream is available wherever streaming is. The Python SDK implements structured output on each provider; the TypeScript SDK provides it at the agent layer for every provider. A custom provider implements the Model interface, where the streaming method is required and the other capabilities depend on your implementation.

Prompt caching is marked only where the provider writes cache points or cache control into the request: Amazon Bedrock, Anthropic, LiteLLM, llama.cpp (server-side prompt reuse), and Vercel (through the underlying provider). These rows were checked against each provider’s page in this section and the SDK model sources under strands-py/src/strands/models/ and strands-ts/src/models/.

How this compares to other frameworks

Provider-agnostic access can live at different layers of the stack. LiteLLM provides it at the client layer: one API in front of many model providers. Strands can use a LiteLLM deployment directly through the LiteLLMModel provider, so it becomes one more provider behind the same agent. Pydantic AI is a separate agent framework that, like Strands, runs the same agent code across multiple providers. The practical difference is scope: LiteLLM routes model calls and leaves the agent loop to you, while Pydantic AI and Strands each provide the loop, tool calling, and structured output around the model. For a side-by-side comparison of Strands against Pydantic AI and other frameworks, see Choosing an Agent Foundation.

Supported Providers

The following table shows all model providers supported by Strands Agents SDK and their availability in Python and TypeScript:

Provider	Python Supported	TypeScript Supported
Amazon Bedrock	✅	✅
Amazon Nova	✅	❌
Anthropic	✅	✅
Cohere	✅	❌
Crusoe	✅	✅
Custom Providers	✅	✅
Fireworks AI	✅	✅
Google	✅	✅
LiteLLM	✅	❌
llama.cpp	✅	❌
LlamaAPI	✅	❌
MistralAI	✅	❌
Nebius Token Factory	✅	✅
Ollama	✅	❌
OpenAI	✅	✅
OpenAI Responses API	✅	✅
OpenRouter	✅	✅
OrcaRouter	✅	✅
OVHcloud AI Endpoints	✅	✅
SageMaker	✅	❌
Vercel	❌	✅
Writer	✅	❌

Community providers

The following providers are built and maintained by the Strands community. Browse the integrations page to explore additional community packages.

Provider	Python Supported	TypeScript Supported
CLOVA Studio	✅	❌
MLX	✅	❌
NVIDIA NIM	✅	❌
SGLang	✅	❌
vLLM	✅	❌
xAI	✅	❌

Getting Started

Installation

Most providers are available as optional dependencies. Install the provider you need:

Python

# Install with specific provider
pip install 'strands-agents[bedrock]'
pip install 'strands-agents[openai]'
pip install 'strands-agents[anthropic]'

# Or install with all providers
pip install 'strands-agents[all]'

TypeScript

# Core SDK includes BedrockModel by default
npm install @strands-agents/sdk

# To use OpenAI, install the openai package
npm install openai

Note: All model providers except Bedrock are listed as optional dependencies in the SDK. This means npm will attempt to install them automatically, but won’t fail if they’re unavailable. You can explicitly install them when needed.

Basic Usage

Every provider follows the same initialization pattern, so you switch providers by swapping the model instance:

Python

from strands import Agent
from strands.models.bedrock import BedrockModel
from strands.models.openai import OpenAIModel

# Use Bedrock
bedrock_model = BedrockModel()
agent = Agent(model=bedrock_model)
response = agent("What can you help me with?")

# Alternatively, use OpenAI by just switching model provider
openai_model = OpenAIModel(
    client_args={"api_key": "<KEY>"},
    model_id="gpt-4o"
)
agent = Agent(model=openai_model)
response = agent("What can you help me with?")

TypeScript

import { Agent } from '@strands-agents/sdk'
import { BedrockModel } from '@strands-agents/sdk/models/bedrock'
import { OpenAIModel } from '@strands-agents/sdk/models/openai'

// Use Bedrock
const bedrockModel = new BedrockModel()
let agent = new Agent({ model: bedrockModel })
let response = await agent.invoke('What can you help me with?')

// Alternatively, use OpenAI by just switching model provider
const openaiModel = new OpenAIModel({
  api: 'chat',
  apiKey: process.env.OPENAI_API_KEY,
  modelId: 'gpt-5.4',
})
agent = new Agent({ model: openaiModel })
response = await agent.invoke('What can you help me with?')

Next Steps

Explore Model Providers

• Amazon Bedrock - Wide model selection, enterprise features, and full Python and TypeScript support
• OpenAI - GPT models with streaming support
• Google - Google’s Gemini models with tool calling support
• Custom Providers - Build your own model integration
• Anthropic - Direct Claude API access