# How to Configure Provider-Specific Clients (Anthropic, Ollama, Bedrock) in Agent Framework

> Learn to configure provider-specific clients Anthropic Ollama and Bedrock in Agent Framework using constructor arguments or environment variables for seamless LLM integration.

- Repository: [Microsoft/agent-framework](https://github.com/microsoft/agent-framework)
- Tags: how-to-guide
- Published: 2026-04-05

---

**Configure Anthropic, Ollama, and AWS Bedrock clients in Agent Framework by importing their respective client classes from lazy-import namespaces, passing explicit constructor arguments or environment variables with provider-specific prefixes (ANTHROPIC_, OLLAMA_, BEDROCK_), and invoking the standard `await client.get_response()` method.**

Microsoft Agent Framework isolates each LLM provider behind a thin, typed client built on the common *BaseChatClient* abstraction. When configuring **provider-specific clients like Anthropic, Ollama, and Bedrock**, the framework uses a three-layer architecture that combines lazy-import namespaces, environment-based typed settings, and declarative configuration through provider-specific prefixes. This design ensures optional dependencies load only when accessed, while supporting both explicit parameters and portable `.env` files across deployment environments.

## Understanding the Three-Layer Architecture

Agent Framework's provider configuration follows three distinct architectural layers that separate import mechanics from runtime initialization.

### Lazy-Import Namespaces

Core packages expose provider classes without pulling in optional dependencies until actual use. In [`python/packages/core/agent_framework/anthropic/__init__.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/core/agent_framework/anthropic/__init__.py), the framework re-exports `AnthropicClient` from the *agent-framework-anthropic* package via a lightweight mapping at lines 27-33:

```python
from agent_framework_anthropic import AnthropicClient

__all__ = ["AnthropicClient"]

```

This pattern allows you to write `from agent_framework.anthropic import AnthropicClient` without installing Anthropic-specific dependencies until instantiation occurs. Similar namespaces exist for `agent_framework.ollama` and `agent_framework.amazon`.

### Typed Settings with Environment Prefixes

Each provider defines a `TypedDict` describing configuration keys read from environment variables or `.env` files. The `load_settings` helper extracts values using provider-specific prefixes:

- **Anthropic**: `AnthropicSettings` (keys `api_key`, `chat_model`) in [`python/packages/anthropic/agent_framework_anthropic/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/anthropic/agent_framework_anthropic/_chat_client.py) lines 9-23
- **Ollama**: `OllamaSettings` (keys `host`, `model`) in [`python/packages/ollama/agent_framework_ollama/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/ollama/agent_framework_ollama/_chat_client.py) lines 76-81  
- **Bedrock**: `BedrockSettings` (keys `region`, `chat_model`, `access_key`, `secret_key`, `session_token`) in [`python/packages/bedrock/agent_framework_bedrock/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/bedrock/agent_framework_bedrock/_chat_client.py) lines 8-16

### Provider Client Implementation

Concrete client classes compose common middleware, telemetry, and function-invocation layers before wiring provider-specific HTTP/SDK calls:

- `AnthropicClient` inherits the full stack at line 1396 in [`_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/_chat_client.py)
- `OllamaChatClient` handles local server connections at line 86 in [`_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/_chat_client.py)
- `BedrockChatClient` wraps the AWS Bedrock Converse API at line 18 in [`_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/_chat_client.py)

## Configuring the Anthropic Client

The **Anthropic client** accepts explicit arguments or environment variables prefixed with `ANTHROPIC_`.

```python
from agent_framework.anthropic import AnthropicClient

anthropic = AnthropicClient(
    api_key="sk-ant‑mykey",
    model="claude-sonnet-4-5-20250929",
)
response = await anthropic.get_response("Explain quantum tunnelling.")
print(response.text)

```

When instantiating, the constructor calls `load_settings` with the `ANTHROPIC_` prefix, merges explicit arguments, and falls back to environment variables or `.env` files.

## Configuring the Ollama Client

For **Ollama local server** connections, use the `OLLAMA_` prefix or pass parameters directly via `OllamaChatClient`.

Create a `.env` file:

```bash
OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama2:13b

```

Then initialize:

```python
from agent_framework.ollama import OllamaChatClient

ollama = OllamaChatClient(env_file_path=".env")
resp = await ollama.get_response("Summarise the plot of *The Matrix*.")
print(resp.text)

```

The `OllamaSettings` TypedDict in [`python/packages/ollama/agent_framework_ollama/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/ollama/agent_framework_ollama/_chat_client.py) lines 76-81 validates `host` and `model` keys automatically.

## Configuring the AWS Bedrock Client

The **Bedrock client** supports AWS credential chains or explicit keys via `BEDROCK_` prefixed variables.

Environment configuration:

```bash
BEDROCK_REGION=us-west-2
BEDROCK_CHAT_MODEL=anthropic.claude-v2
BEDROCK_ACCESS_KEY=AKIA…
BEDROCK_SECRET_KEY=…

```

Implementation:

```python
from agent_framework.amazon import BedrockChatClient

bedrock = BedrockChatClient(
    model="anthropic.claude-v2",       # overrides BEDROCK_CHAT_MODEL

    # access_key="AKIA…",               # optional explicit injection

    # secret_key="…",

)
msg = await bedrock.get_response(
    "Write a short poem about sunrise.",
    options={"temperature": 0.7},
)
print(msg.text)

```

The `BedrockChatClient` at line 18 in [`python/packages/bedrock/agent_framework_bedrock/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/bedrock/agent_framework_bedrock/_chat_client.py) wraps the AWS Bedrock Converse API while maintaining the same high-level interface.

## Adding Middleware and Call Options

All three clients share the same API surface. Pass a `middleware=` sequence to the constructor to enable function tools, tracing, or logging:

```python
client = AnthropicClient(
    api_key="sk-ant…",
    middleware=[tracing_middleware, logging_middleware]
)

```

Pass provider-specific options like `temperature` via the `options` parameter in `get_response()`.

## Summary

- **Lazy imports**: Import from `agent_framework.anthropic`, `agent_framework.ollama`, or `agent_framework.amazon` without loading heavy dependencies until use.
- **Environment prefixes**: Use `ANTHROPIC_`, `OLLAMA_`, and `BEDROCK_` prefixes in environment variables or `.env` files to populate TypedDict settings.
- **Explicit overrides**: Constructor arguments merge with and override environment settings via `load_settings`.
- **Unified API**: All clients implement `await client.get_response(prompt, options=...)` returning a `ChatResponse` object.
- **Middleware support**: Pass `middleware=` sequences to add telemetry, function calling, or custom processing layers.

## Frequently Asked Questions

### How does Agent Framework handle optional dependencies for different providers?

The framework uses **lazy-import namespaces** in files like [`python/packages/core/agent_framework/anthropic/__init__.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/core/agent_framework/anthropic/__init__.py) to re-export classes without importing heavy SDKs until instantiation. This keeps startup times fast and prevents dependency conflicts when you only need one provider.

### Can I override environment variables with explicit constructor arguments?

Yes. When a client is instantiated, the constructor calls `load_settings` with the appropriate provider prefix, merges values from explicit arguments, and applies them as overrides. Explicit parameters always take precedence over environment variables or `.env` file entries.

### What environment variables are required for AWS Bedrock configuration?

According to the `BedrockSettings` TypedDict in [`python/packages/bedrock/agent_framework_bedrock/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/bedrock/agent_framework_bedrock/_chat_client.py) lines 8-16, the framework recognizes `BEDROCK_REGION`, `BEDROCK_CHAT_MODEL`, `BEDROCK_ACCESS_KEY`, `BEDROCK_SECRET_KEY`, and `BEDROCK_SESSION_TOKEN`. Only `region` and `chat_model` are typically required if using AWS credential chains.

### How do I configure Ollama to use a remote host instead of localhost?

Set the `OLLAMA_HOST` environment variable or pass the `host` parameter explicitly to `OllamaChatClient`. The `OllamaSettings` TypedDict in [`python/packages/ollama/agent_framework_ollama/_chat_client.py`](https://github.com/microsoft/agent-framework/blob/main/python/packages/ollama/agent_framework_ollama/_chat_client.py) lines 76-81 reads this value to connect to remote Ollama instances.