Initial commit

app.py

@@ -0,0 +1,42 @@
+import gradio as gr
+import os
+from bedrock_client import get_anthropic_client, claude_stream_response
+
+# Create Claude client via the official SDK
+client = get_anthropic_client()
+
+# Streaming chat handler
+async def chat(user_message, history):
+    messages = history.copy()
+    messages.append({"role": "user", "content": user_message})
+
+    full_response = ""
+
+    def run_generator():
+        for chunk in claude_stream_response(messages, client):
+            yield chunk
+
+    for chunk in run_generator():
+        full_response += chunk
+        yield messages + [{"role": "assistant", "content": full_response}]
+
+    # Append full assistant response to history
+    messages.append({"role": "assistant", "content": full_response})
+    yield messages
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# 🤖 Claude v2.1 Chatbot via Amazon Bedrock (`anthropic[bedrock]`)")
+    chatbot = gr.Chatbot(label="Claude v2.1", type="messages")
+    msg = gr.Textbox(placeholder="Ask Claude anything...", show_label=False)
+    state = gr.State([])  # chat history
+    clear = gr.Button("🧹 Clear Chat")
+
+    def clear_chat():
+        return [], []
+
+    msg.submit(chat, [msg, state], chatbot, queue=True)
+    msg.submit(lambda: "", None, msg)  # clear input
+    clear.click(clear_chat, None, [chatbot, state])
+
+demo.queue().launch()

bedrock_client.py

@@ -0,0 +1,25 @@
+from anthropic import AnthropicBedrock
+import os
+
+def get_anthropic_client():
+    return AnthropicBedrock(
+        aws_access_key=os.environ["AWS_ACCESS_KEY_ID"],
+        aws_secret_key=os.environ["AWS_SECRET_ACCESS_KEY"],
+        aws_region=os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
+    )
+
+def claude_stream_response(messages, client):
+    stream = client.messages.create(
+        model="anthropic.claude-v2:1",
+        max_tokens=1024,
+        temperature=0.7,
+        messages=messages,
+        stream=True
+    )
+
+    for event in stream:
+        # Only yield parts that have actual text deltas
+        if event.type == "content_block_delta":
+            text = getattr(event.delta, "text", None)
+            if text:
+                yield text

bedrock_test.py

@@ -0,0 +1,208 @@
+
+
+
+#%%
+import boto3
+import json
+import logging
+aws_access_key_id='AKIA2UC26WDCAFOF7X64'
+aws_secret_access_key='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'
+aws_region = "eu-central-1"
+#%%
+from anthropic import AnthropicBedrock
+
+client = AnthropicBedrock(
+    # Authenticate by either providing the keys below or use the default AWS credential providers, such as
+    # using ~/.aws/credentials or the "AWS_SECRET_ACCESS_KEY" and "AWS_ACCESS_KEY_ID" environment variables.
+    aws_access_key=aws_access_key_id,
+    aws_secret_key=aws_secret_access_key,
+    # Temporary credentials can be used with aws_session_token.
+    # Read more at https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
+    aws_session_token=None,
+    # aws_region changes the aws region to which the request is made. By default, we read AWS_REGION,
+    # and if that's not present, we default to us-east-1. Note that we do not read ~/.aws/config for the region.
+    aws_region=aws_region,
+)
+modelid='anthropic.claude-v2:1'
+message = client.messages.create(
+    model=modelid,
+    max_tokens=256,
+    messages=[{"role": "user", "content": "Hello, world"}]
+)
+print(message.content)
+#%%
+
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""
+Shows how to generate a message with Anthropic Claude (on demand).
+"""
+import boto3
+import json
+import logging
+
+from botocore.exceptions import ClientError
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
+
+    body=json.dumps(
+        {
+            "anthropic_version": "bedrock-2023-05-31",
+            "max_tokens": max_tokens,
+            "system": system_prompt,
+            "messages": messages
+        }  
+    )  
+
+    
+    response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
+    response_body = json.loads(response.get('body').read())
+   
+    return response_body
+
+def main():
+    """
+    Entrypoint for Anthropic Claude message example.
+    """
+
+    try:
+        # Define your credentials here (temporary for dev/testing only)
+
+        aws_region = "eu-central-1"  # or the correct region
+
+        # Use boto3 session to inject credentials
+        session = boto3.Session(
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+            region_name=aws_region
+        )
+
+        bedrock_runtime = session.client(service_name='bedrock-runtime')
+
+        model_id = 'anthropic.claude-v2:1'
+        system_prompt = "Please respond only with emoji."
+        max_tokens = 1000
+
+        # Prompt with user turn only.
+        user_message = {"role": "user", "content": "Hello World"}
+        messages = [user_message]
+
+        response = generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens)
+        print("User turn only.")
+        print(json.dumps(response, indent=4))
+
+        # Prompt with both user and assistant messages
+        assistant_message = {"role": "assistant", "content": "<emoji>"}
+        messages = [user_message, assistant_message]
+        response = generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens)
+        print("User turn and prefilled assistant response.")
+        print(json.dumps(response, indent=4))
+
+    except ClientError as err:
+        message = err.response["Error"]["Message"]
+        logger.error("A client error occurred: %s", message)
+        print("A client error occurred: " + format(message))
+
+
+main()
+
+#%%
+from botocore.exceptions import ClientError
+session = boto3.Session(
+    aws_access_key_id=aws_access_key_id,
+    aws_secret_access_key=aws_secret_access_key,
+    region_name=aws_region
+)
+
+bedrock_runtime = session.client("bedrock-runtime")
+
+model_id = "anthropic.claude-v2:1"
+
+payload = {
+    "anthropic_version": "bedrock-2023-05-31",
+    "max_tokens": 100,
+    "messages": [{"role": "user", "content": "Hello!"}]
+}
+
+try:
+    response = bedrock_runtime.invoke_model_with_response_stream(
+        modelId=model_id,
+        body=json.dumps(payload),
+        contentType="application/json",
+        accept="application/json"
+    )
+
+    print("✅ Streaming appears to be enabled for Claude v2.1.")
+    for event in response['body']:
+        chunk = event['chunk']['bytes']
+        print(chunk.decode(), end="")
+
+except ClientError as e:
+    code = e.response['Error']['Code']
+    if code == "AccessDeniedException":
+        print("❌ Streaming is NOT enabled for Claude v2.1: Access denied.")
+    elif code == "ValidationException":
+        print("⚠️ Model does not support streaming or bad payload.")
+    else:
+        print(f"❌ Unexpected error: {e}")
+except Exception as e:
+    print(f"❌ General error: {e}")
+#%%
+messages = [
+    {"role": "user", "content": "Can you tell me a fun fact about llamas?"}
+]
+
+payload = {
+    "anthropic_version": "bedrock-2023-05-31",
+    "max_tokens": 256,
+    "messages": messages
+}
+
+# ✅ 1. Test NON-streaming (invoke_model)
+print("🧪 Testing invoke_model (non-streaming)...")
+try:
+    response = client.invoke_model(
+        modelId=model_id,
+        body=json.dumps(payload),
+        contentType="application/json",
+        accept="application/json"
+    )
+    result = json.loads(response["body"].read().decode("utf-8"))
+    print("✅ invoke_model succeeded.")
+    print("🧠 Claude's reply:", result["content"][0]["text"])
+except ClientError as e:
+    print("❌ invoke_model failed:", e)
+
+# ❌ 2. Test Streaming (invoke_model_with_response_stream)
+print("\n🧪 Testing invoke_model_with_response_stream (streaming)...")
+try:
+    stream_response = client.invoke_model_with_response_stream(
+        modelId=model_id,
+        body=json.dumps(payload),
+        contentType="application/json",
+        accept="application/json"
+    )
+
+    print("✅ Streaming supported. Response:")
+    for event in stream_response["body"]:
+        chunk = event.get("chunk", {}).get("bytes", b"")
+        if chunk:
+            decoded = json.loads(chunk.decode("utf-8"))
+            delta = decoded.get("delta", {}).get("content", "")
+            print(delta, end="", flush=True)
+
+except ClientError as e:
+    code = e.response["Error"]["Code"]
+    if code == "AccessDeniedException":
+        print("❌ AccessDeniedException: Streaming is not enabled for your role.")
+    elif code == "ValidationException":
+        print("⚠️ ValidationException: Model might not support streaming or payload is malformed.")
+    else:
+        print(f"❌ Unexpected error: {e}")
+except Exception as e:
+    print(f"❌ General error: {e}")
+#%%

bedrock_test_Pixtral.py

@@ -0,0 +1,58 @@
+
+
+
+#%%
+aws_access_key_id='AKIA2UC26WDCAFOF7X64'
+aws_secret_access_key='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'
+aws_region = "eu-central-1"
+#%%
+
+import boto3
+import json
+
+from botocore.exceptions import ClientError
+
+
+bedrock_runtime = session.client(service_name='bedrock-runtime')
+
+# 🏷️ Model ID for Pixtral
+model_id = 'mistral.pixtral-large-2502-v1:0'
+
+# ✏️ Define your prompt
+prompt = "Describe the purpose of a 'hello world' program in one line."
+
+# 🧾 Format the request payload
+native_request = {
+    "inputText": prompt,
+    "textGenerationConfig": {
+        "maxTokenCount": 512,
+        "temperature": 0.5,
+        "topP": 0.9
+    }
+}
+
+# 🔄 Convert to JSON
+request = json.dumps(native_request)
+
+try:
+    # 🚀 Invoke the model
+    response = bedrock_runtime.invoke_model(
+        modelId=model_id,
+        body=request,
+        contentType="application/json",
+        accept="application/json"
+    )
+
+    # 📦 Decode the response body
+    model_response = json.loads(response["body"].read())
+
+    # 🗨️ Extract and print output text
+    response_text = model_response["results"][0]["outputText"]
+    print("✅ Model response:")
+    print(response_text)
+
+except ClientError as e:
+    print(f"❌ ClientError: {e.response['Error']['Message']}")
+except Exception as e:
+    print(f"❌ ERROR: Can't invoke '{model_id}'. Reason: {e}")
+#%%

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.20.0
+boto3>=1.34.0
+botocore