Full-Stack AI with AWS Bedrock in Practice: The Code and Commands That Really Matter

+----------------------------------------------------------+
|  AWS Console                          [N. Virginia v]    |
|                                        ^^^^^^^^^^^^      |
|  Search bar : [ Amazon Bedrock         ]                 |
|                                                          |
+----------------------------------------------------------+

If you see another region, click the dropdown
menu and select “US East (N. Virginia)”.

+----------------------------------------------------------+
|  Search : [ Bedrock                          ]           |
|                                                          |
|  Results :                                               |
|  +------------------------------------------------------+|
|  |  Amazon Bedrock                                      ||
|  |  Build with foundation models                        ||
|  +------------------------------------------------------+|
+----------------------------------------------------------+

+----------------------------+------------------------------+
|  Amazon Bedrock            |                              |
|                            |  Bedrock Dashboard           |
|  Playgrounds               |                              |
|    Chat                    |  Welcome to Amazon           |
|    Text                    |  Bedrock. Access             |
|    Image                   |  cutting-edge foundation     |
|                            |  models via a single API.    |
|  Orchestration             |                              |
|    Agents                  |                              |
|    Knowledge bases         |                              |
|                            |                              |
|  Foundation models         |                              |
|    Base models             |                              |
|    Custom models           |                              |
|                            |                              |
|  Bedrock configurations    |                              |
|  > Model access    <--    |                              |
+----------------------------+------------------------------+

+----------------------------------------------------------+
|  Manage model access                                     |
|                                                          |
|  Provider        Model                   Access Status   |
|  -------------------------------------------------------||
|  [x] Anthropic   Claude 3 Haiku          Available       ||
|  [x] Anthropic   Claude 3.5 Sonnet       Available       ||
|  [ ] Anthropic   Claude 3 Opus           Available       ||
|  [x] Amazon      Titan Text Express      Available       ||
|  [x] Meta        Llama 3 8B Instruct     Available       ||
|  [x] Mistral AI  Mistral 7B Instruct     Available       ||
|  [x] Mistral AI  Mixtral 8x7B Instruct   Available       ||
|                                                          |
|                        [ Save changes ]                  |
+----------------------------------------------------------+

# backend/models/schemas.py
from pydantic import BaseModel, Field
from typing import Optional, List


class Message(BaseModel):
    """Represents a message in the conversation."""
    role: str = Field(
        ...,
        description="Role: 'user' or 'assistant'",
        examples=["user"]
    )
    content: str = Field(
        ...,
        description="Message content",
        examples=["Explain Python loops to me"]
    )


class ChatRequest(BaseModel):
    """Request sent by the frontend to chat with the AI."""
    message: str = Field(
        ...,
        min_length=1,
        max_length=10000,
        description="User message"
    )
    history: Optional[List[Message]] = Field(
        default=[],
        description="Conversation history"
    )
    model_id: Optional[str] = Field(
        default=None,
        description="Bedrock model ID"
    )
    temperature: Optional[float] = Field(
        default=0.7,
        ge=0.0,
        le=1.0,
        description="Model creativity (0 = precise, 1 = creative)"
    )
    max_tokens: Optional[int] = Field(
        default=4096,
        ge=1,
        le=8192,
        description="Maximum number of tokens in the response"
    )


class ChatResponse(BaseModel):
    """Response returned by the API after calling Bedrock."""
    response: str = Field(
        ...,
        description="Response generated by the AI"
    )
    model_id: str = Field(
        ...,
        description="ID of the model used"
    )
    input_tokens: int = Field(
        default=0,
        description="Tokens consumed by the prompt"
    )
    output_tokens: int = Field(
        default=0,
        description="Tokens generated in the response"
    )


class HealthResponse(BaseModel):
    """Health-check endpoint response."""
    status: str
    message: str

{
  "detail": [
    {
      "loc": ["body", "temperature"],
      "msg": "Input should be less than or equal to 1",
      "type": "less_than_equal"
    }
  ]
}

# backend/services/bedrock_service.py
import json
import boto3
from config import AWS_REGION, BEDROCK_MODEL_ID, MAX_TOKENS, TEMPERATURE


def get_bedrock_client():
    """Create and return a Bedrock Runtime client."""
    return boto3.client(
        service_name="bedrock-runtime",
        region_name=AWS_REGION
    )


def build_messages(message: str, history: list = None) -> list:
    """Build the list of messages for the Bedrock API."""
    messages = []
    if history:
        for msg in history:
            messages.append({
                "role": msg.role,
                "content": [{"type": "text", "text": msg.content}]
            })
    messages.append({
        "role": "user",
        "content": [{"type": "text", "text": message}]
    })
    return messages


def invoke_bedrock(
    message: str,
    history: list = None,
    model_id: str = None,
    temperature: float = None,
    max_tokens: int = None
) -> dict:
    """
    Call AWS Bedrock with the message and return the response.

    Args:
        message: The user message
        history: The conversation history
        model_id: The Bedrock model identifier
        temperature: The creativity (0.0 to 1.0)
        max_tokens: The maximum number of output tokens

    Returns:
        dict with the response, the model used and token counts
    """
    client = get_bedrock_client()
    model = model_id or BEDROCK_MODEL_ID
    temp = temperature if temperature is not None else TEMPERATURE
    tokens = max_tokens or MAX_TOKENS

    messages = build_messages(message, history)

    body = json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": tokens,
        "temperature": temp,
        "messages": messages
    })

    response = client.invoke_model(
        modelId=model,
        contentType="application/json",
        accept="application/json",
        body=body
    )

    response_body = json.loads(response["body"].read())

    return {
        "response": response_body["content"][0]["text"],
        "model_id": model,
        "input_tokens": response_body.get("usage", {}).get(
            "input_tokens", 0
        ),
        "output_tokens": response_body.get("usage", {}).get(
            "output_tokens", 0
        ),
    }

# backend/main.py
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from dotenv import load_dotenv

from config import CORS_ORIGINS
from models.schemas import (
    ChatRequest,
    ChatResponse,
    HealthResponse,
)
from services.bedrock_service import invoke_bedrock

load_dotenv()

app = FastAPI(
    title="Full Stack AI - Backend Bedrock",
    description="API to interact with AWS Bedrock (Claude)",
    version="1.0.0",
)

# --- CORS Middleware ---
app.add_middleware(
    CORSMiddleware,
    allow_origins=CORS_ORIGINS,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


# --- Endpoints ---

@app.get("/health", response_model=HealthResponse)
def health_check():
    """Check that the server is operational."""
    return HealthResponse(
        status="ok",
        message="Server is running correctly"
    )


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """
    Send a message to AWS Bedrock and return the AI response.

    - **message** : text sent by the user
    - **history** : conversation history (optional)
    - **model_id** : Bedrock model to use (optional)
    - **temperature** : creativity from 0.0 to 1.0 (optional)
    - **max_tokens** : maximum number of output tokens (optional)
    """
    try:
        result = invoke_bedrock(
            message=request.message,
            history=request.history,
            model_id=request.model_id,
            temperature=request.temperature,
            max_tokens=request.max_tokens,
        )
        return ChatResponse(**result)

    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Error calling Bedrock: {str(e)}"
        )


@app.get("/models")
def list_models():
    """Return the list of available models."""
    return {
        "models": [
            {
                "id": "anthropic.claude-3-sonnet-20240229-v1:0",
                "name": "Claude 3 Sonnet",
                "description": "Good performance/cost balance"
            },
            {
                "id": "anthropic.claude-3-haiku-20240307-v1:0",
                "name": "Claude 3 Haiku",
                "description": "Fastest and most economical"
            },
            {
                "id": "anthropic.claude-3-5-sonnet-20240620-v1:0",
                "name": "Claude 3.5 Sonnet",
                "description": "Highest performance"
            },
        ]
    }