Amazon Bedrock | Respan Docs

Set up Respan

Sign up — Create an account at platform.respan.ai
Create an API key — Generate one on the API keys page
Add credits or a provider key — Add credits on the Credits page or connect your own provider key on the Integrations page

Use AI

Add the Docs MCP to your AI coding tool to get help building with Respan. No API key needed.

1 {
2   "mcpServers": {
3     "respan-docs": {
4       "url": "https://docs.respan.ai/mcp"
5     }
6   }
7 }

What is Amazon Bedrock?

Amazon Bedrock is a fully managed service that offers foundation models from leading AI providers through a single API. Respan can auto-instrument all Bedrock calls for tracing, route them through the Respan gateway, or both.

Setup

Install packages

Tracing

Gateway

Both

OpenInference (Recommended)

Traceloop

$ pip install respan-ai openinference-instrumentation-bedrock boto3 python-dotenv

Set environment variables

Tracing

Gateway

Both

$ export AWS_ACCESS_KEY_ID="YOUR_AWS_ACCESS_KEY_ID"
$ export AWS_SECRET_ACCESS_KEY="YOUR_AWS_SECRET_ACCESS_KEY"
$ export AWS_REGION="us-east-1"
$ export RESPAN_API_KEY="YOUR_RESPAN_API_KEY"

Initialize and run

Tracing

Gateway

Both

OpenInference (Recommended)

Traceloop

1 import os
2 import json
3 from dotenv import load_dotenv
4 
5 load_dotenv()
6 
7 import boto3
8 from respan import Respan
9 from openinference.instrumentation.bedrock import BedrockInstrumentor
10 
11 # Initialize Respan with Bedrock instrumentation
12 respan = Respan(instrumentations=[BedrockInstrumentor()])
13 
14 # Calls go directly to AWS Bedrock, auto-traced by Respan
15 client = boto3.client("bedrock-runtime", region_name=os.getenv("AWS_REGION", "us-east-1"))
16 
17 response = client.invoke_model(
18     modelId="anthropic.claude-3-sonnet-20240229-v1:0",
19     body=json.dumps({
20         "anthropic_version": "bedrock-2023-05-31",
21         "max_tokens": 1024,
22         "messages": [{"role": "user", "content": "Say hello in three languages."}],
23     }),
24     contentType="application/json",
25 )
26 result = json.loads(response["body"].read())
27 print(result["content"][0]["text"])
28 respan.flush()

View your trace

Open the Traces page to see your auto-instrumented LLM spans.

This step applies to Tracing and Both setups. The Gateway-only setup does not produce traces.

Configuration

Parameter	Type	Default	Description
`api_key`	`str \| None`	`None`	Falls back to `RESPAN_API_KEY` env var.
`base_url`	`str \| None`	`None`	Falls back to `RESPAN_BASE_URL` env var.
`instrumentations`	`list`	`[]`	Plugin instrumentations to activate (e.g. `BedrockInstrumentor()`).
`is_auto_instrument`	`bool \| None`	`False`	Auto-discover and activate all installed instrumentors via OpenTelemetry entry points.
`customer_identifier`	`str \| None`	`None`	Default customer identifier for all spans.
`metadata`	`dict \| None`	`None`	Default metadata attached to all spans.
`environment`	`str \| None`	`None`	Environment tag (e.g. `"production"`).

Attributes

Attach customer identifiers, thread IDs, and metadata to spans.

In Respan()

Set defaults at initialization — these apply to all spans.

1 from respan import Respan
2 from openinference.instrumentation.bedrock import BedrockInstrumentor
3 
4 respan = Respan(
5     instrumentations=[BedrockInstrumentor()],
6     customer_identifier="user_123",
7     metadata={"service": "chat-api", "version": "1.0.0"},
8 )

With propagate_attributes

Override per-request using a context manager.

1 from respan import Respan, workflow, propagate_attributes
2 from openinference.instrumentation.bedrock import BedrockInstrumentor
3 
4 respan = Respan(
5     instrumentations=[BedrockInstrumentor()],
6     metadata={"service": "chat-api", "version": "1.0.0"},
7 )
8 
9 @workflow(name="handle_request")
10 def handle_request(user_id: str, question: str):
11     with propagate_attributes(
12         customer_identifier=user_id,
13         thread_identifier="conv_001",
14         metadata={"plan": "pro"},
15     ):
16         response = client.invoke_model(
17             modelId="anthropic.claude-3-sonnet-20240229-v1:0",
18             body=json.dumps({
19                 "anthropic_version": "bedrock-2023-05-31",
20                 "max_tokens": 1024,
21                 "messages": [{"role": "user", "content": question}],
22             }),
23             contentType="application/json",
24         )
25         result = json.loads(response["body"].read())
26         print(result["content"][0]["text"])

Attribute	Type	Description
`customer_identifier`	`str`	Identifies the end user in Respan analytics.
`thread_identifier`	`str`	Groups related messages into a conversation.
`metadata`	`dict`	Custom key-value pairs. Merged with default metadata.

Decorators

Use @workflow and @task to create structured trace hierarchies.

1 import json
2 import boto3
3 from respan import Respan, workflow, task
4 from openinference.instrumentation.bedrock import BedrockInstrumentor
5 
6 respan = Respan(instrumentations=[BedrockInstrumentor()])
7 client = boto3.client("bedrock-runtime", region_name="us-east-1")
8 
9 @task(name="generate_outline")
10 def outline(topic: str) -> str:
11     response = client.invoke_model(
12         modelId="anthropic.claude-3-sonnet-20240229-v1:0",
13         body=json.dumps({
14             "anthropic_version": "bedrock-2023-05-31",
15             "max_tokens": 1024,
16             "messages": [{"role": "user", "content": f"Create a brief outline about: {topic}"}],
17         }),
18         contentType="application/json",
19     )
20     return json.loads(response["body"].read())["content"][0]["text"]
21 
22 @workflow(name="content_pipeline")
23 def pipeline(topic: str):
24     plan = outline(topic)
25     response = client.invoke_model(
26         modelId="anthropic.claude-3-sonnet-20240229-v1:0",
27         body=json.dumps({
28             "anthropic_version": "bedrock-2023-05-31",
29             "max_tokens": 2048,
30             "messages": [{"role": "user", "content": f"Write content from this outline: {plan}"}],
31         }),
32         contentType="application/json",
33     )
34     print(json.loads(response["body"].read())["content"][0]["text"])
35 
36 pipeline("Benefits of API gateways")
37 respan.flush()

Examples

Basic invoke

1 import json
2 
3 response = client.invoke_model(
4     modelId="anthropic.claude-3-sonnet-20240229-v1:0",
5     body=json.dumps({
6         "anthropic_version": "bedrock-2023-05-31",
7         "max_tokens": 1024,
8         "messages": [{"role": "user", "content": "Say hello in three languages."}],
9     }),
10     contentType="application/json",
11 )
12 result = json.loads(response["body"].read())
13 print(result["content"][0]["text"])

Gateway features

The features below require the Gateway or Both setup from Step 3.

Switch models

Change the model parameter to use 250+ models from different providers through the same gateway.

1 # Bedrock (Claude)
2 response = client.chat.completions.create(model="bedrock/anthropic.claude-3-sonnet", messages=messages)
3 
4 # OpenAI
5 response = client.chat.completions.create(model="gpt-4.1-nano", messages=messages)
6 
7 # Google
8 response = client.chat.completions.create(model="gemini-2.5-flash", messages=messages)

See the full model list.

Respan parameters

Pass additional Respan parameters via extra_body for gateway features.

1 response = client.chat.completions.create(
2     model="bedrock/anthropic.claude-3-sonnet",
3     messages=[{"role": "user", "content": "Hello"}],
4     extra_body={
5         "customer_identifier": "user_123",
6         "fallback_models": ["gpt-4.1-nano"],
7         "metadata": {"session_id": "abc123"},
8         "thread_identifier": "conversation_456",
9     },
10 )

See Respan parameters for the full list.