1
%pip install --upgrade opik boto3

1
import opik
2
3
opik.configure(use_local=False)

1
import boto3
2
3
REGION = "us-east-1"
4
5
MODEL_ID = "us.meta.llama3-2-3b-instruct-v1:0"
6
7
bedrock = boto3.client(
8
    service_name="bedrock-runtime",
9
    region_name=REGION,
10
    # aws_access_key_id=ACCESS_KEY,
11
    # aws_secret_access_key=SECRET_KEY,
12
    # aws_session_token=SESSION_TOKEN,
13
)

1
import os
2
3
from opik.integrations.bedrock import track_bedrock
4
5
bedrock_client = track_bedrock(bedrock, project_name="bedrock-integration-demo")

1
PROMPT = "Why is it important to use a LLM Monitoring like CometML Opik tool that allows you to log traces and spans when working with LLM Models hosted on AWS Bedrock?"
2
3
response = bedrock_client.converse(
4
    modelId=MODEL_ID,
5
    messages=[{"role": "user", "content": [{"text": PROMPT}]}],
6
    inferenceConfig={"temperature": 0.5, "maxTokens": 512, "topP": 0.9},
7
)
8
print("Response", response["output"]["message"]["content"][0]["text"])

1
def stream_conversation(
2
    bedrock_client,
3
    model_id,
4
    messages,
5
    system_prompts,
6
    inference_config,
7
):
8
    """
9
    Sends messages to a model and streams the response.
10
    Args:
11
        bedrock_client: The Boto3 Bedrock runtime client.
12
        model_id (str): The model ID to use.
13
        messages (JSON) : The messages to send.
14
        system_prompts (JSON) : The system prompts to send.
15
        inference_config (JSON) : The inference configuration to use.
16
        additional_model_fields (JSON) : Additional model fields to use.
17
18
    Returns:
19
        Nothing.
20
21
    """
22
23
    response = bedrock_client.converse_stream(
24
        modelId=model_id,
25
        messages=messages,
26
        system=system_prompts,
27
        inferenceConfig=inference_config,
28
    )
29
30
    stream = response.get("stream")
31
    if stream:
32
        for event in stream:
33
            if "messageStart" in event:
34
                print(f"\nRole: {event['messageStart']['role']}")
35
36
            if "contentBlockDelta" in event:
37
                print(event["contentBlockDelta"]["delta"]["text"], end="")
38
39
            if "messageStop" in event:
40
                print(f"\nStop reason: {event['messageStop']['stopReason']}")
41
42
            if "metadata" in event:
43
                metadata = event["metadata"]
44
                if "usage" in metadata:
45
                    print("\nToken usage")
46
                    print(f"Input tokens: {metadata['usage']['inputTokens']}")
47
                    print(f":Output tokens: {metadata['usage']['outputTokens']}")
48
                    print(f":Total tokens: {metadata['usage']['totalTokens']}")
49
                if "metrics" in event["metadata"]:
50
                    print(f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
51
52
53
system_prompt = """You are an app that creates playlists for a radio station
54
  that plays rock and pop music. Only return song names and the artist."""
55
56
# Message to send to the model.
57
input_text = "Create a list of 3 pop songs."
58
59
60
message = {"role": "user", "content": [{"text": input_text}]}
61
messages = [message]
62
63
# System prompts.
64
system_prompts = [{"text": system_prompt}]
65
66
# inference parameters to use.
67
temperature = 0.5
68
top_p = 0.9
69
# Base inference parameters.
70
inference_config = {"temperature": temperature, "topP": 0.9}
71
72
73
stream_conversation(
74
    bedrock_client,
75
    MODEL_ID,
76
    messages,
77
    system_prompts,
78
    inference_config,
79
)

1
from opik import track
2
from opik.integrations.bedrock import track_bedrock
3
4
bedrock = boto3.client(
5
    service_name="bedrock-runtime",
6
    region_name=REGION,
7
    # aws_access_key_id=ACCESS_KEY,
8
    # aws_secret_access_key=SECRET_KEY,
9
    # aws_session_token=SESSION_TOKEN,
10
)
11
12
os.environ["OPIK_PROJECT_NAME"] = "bedrock-integration-demo"
13
bedrock_client = track_bedrock(bedrock)
14
15
16
@track
17
def generate_story(prompt):
18
    res = bedrock_client.converse(
19
        modelId=MODEL_ID, messages=[{"role": "user", "content": [{"text": prompt}]}]
20
    )
21
    return res["output"]["message"]["content"][0]["text"]
22
23
24
@track
25
def generate_topic():
26
    prompt = "Generate a topic for a story about Opik."
27
    res = bedrock_client.converse(
28
        modelId=MODEL_ID, messages=[{"role": "user", "content": [{"text": prompt}]}]
29
    )
30
    return res["output"]["message"]["content"][0]["text"]
31
32
33
@track
34
def generate_opik_story():
35
    topic = generate_topic()
36
    story = generate_story(topic)
37
    return story
38
39
40
generate_opik_story()