Full Stack AI AWS Bedrock na prática: o código e os comandos que realmente importam

+----------------------------------------------------------+
|  AWS Console                          [N. Virginia v]    |
|                                        ^^^^^^^^^^^^      |
|  Barra de pesquisa : [ Amazon Bedrock         ]         |
|                                                          |
+----------------------------------------------------------+

Se você vir outra região, clique no menu
suspenso e selecione « US East (N. Virginia) ».

+----------------------------------------------------------+
|  Pesquisa : [ Bedrock                          ]        |
|                                                          |
|  Resultados :                                              |
|  +------------------------------------------------------+|
|  |  Amazon Bedrock                                      ||
|  |  Build with foundation models                        ||
|  +------------------------------------------------------+|
+----------------------------------------------------------+

+----------------------------+------------------------------+
|  Amazon Bedrock            |                              |
|                            |  Bedrock Dashboard           |
|  Playgrounds               |                              |
|    Chat                    |  Bem-vindo ao Amazon        |
|    Text                    |  Bedrock. Acesse modelos     |
|    Image                   |  foundation de ponta         |
|                            |  via uma única 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):
    """Représente um message dans la conversation."""
    role: str = Field(
        ...,
        description="Rôle : 'user' ou 'assistant'",
        examples=["user"]
    )
    content: str = Field(
        ...,
        description="Contenu du message",
        examples=["Explique-moi les boucles Python"]
    )


class ChatRequest(BaseModel):
    """Requête envoyée par le frontend pour chatter avec l'IA."""
    message: str = Field(
        ...,
        min_length=1,
        max_length=10000,
        description="Message de l'utilisateur"
    )
    history: Optional[List[Message]] = Field(
        default=[],
        description="Historique de la conversation"
    )
    model_id: Optional[str] = Field(
        default=None,
        description="ID du modèle Bedrock"
    )
    temperature: Optional[float] = Field(
        default=0.7,
        ge=0.0,
        le=1.0,
        description="Créativité du modèle (0 = précis, 1 = créatif)"
    )
    max_tokens: Optional[int] = Field(
        default=4096,
        ge=1,
        le=8192,
        description="Nombre maximum de tokens dans la réponse"
    )


class ChatResponse(BaseModel):
    """Réponse retournée par l'API après appel à Bedrock."""
    response: str = Field(
        ...,
        description="Réponse générée par l'IA"
    )
    model_id: str = Field(
        ...,
        description="ID du modèle utilisé"
    )
    input_tokens: int = Field(
        default=0,
        description="Tokens consommés par le prompt"
    )
    output_tokens: int = Field(
        default=0,
        description="Tokens générés dans la réponse"
    )


class HealthResponse(BaseModel):
    """Réponse du endpoint de santé."""
    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():
    """Crée et retourne un client Bedrock Runtime."""
    return boto3.client(
        service_name="bedrock-runtime",
        region_name=AWS_REGION
    )


def build_messages(message: str, history: list = None) -> list:
    """Construit la liste de messages pour l'API Bedrock."""
    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:
    """
    Appelle AWS Bedrock avec le message et retourne la réponse.

    Args:
        message: Le message de l'utilisateur
        history: L'historique de la conversation
        model_id: L'identifiant du modèle Bedrock
        temperature: La créativité (0.0 à 1.0)
        max_tokens: Le nombre max de tokens en sortie

    Returns:
        dict avec la réponse, le modèle utilisé et les tokens
    """
    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 para interagir com AWS Bedrock (Claude)",
    version="1.0.0",
)

# --- Middleware CORS ---
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():
    """Vérifie que le serveur est opérationnel."""
    return HealthResponse(
        status="ok",
        message="Le serveur fonctionne correctement"
    )


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """
    Envoie un message à AWS Bedrock et retourne la réponse de l'IA.

    - **message** : le texte envoyé par l'utilisateur
    - **history** : l'historique de conversation (optionnel)
    - **model_id** : le modèle Bedrock à utiliser (optionnel)
    - **temperature** : la créativité de 0.0 à 1.0 (optionnel)
    - **max_tokens** : nombre max de tokens en sortie (optionnel)
    """
    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"Erreur lors de l'appel à Bedrock : {str(e)}"
        )


@app.get("/models")
def list_models():
    """Retourne la liste des modèles disponibles."""
    return {
        "models": [
            {
                "id": "anthropic.claude-3-sonnet-20240229-v1:0",
                "name": "Claude 3 Sonnet",
                "description": "Bon équilibre performance/coût"
            },
            {
                "id": "anthropic.claude-3-haiku-20240307-v1:0",
                "name": "Claude 3 Haiku",
                "description": "Le plus rapide et économique"
            },
            {
                "id": "anthropic.claude-3-5-sonnet-20240620-v1:0",
                "name": "Claude 3.5 Sonnet",
                "description": "Le plus performant"
            },
        ]
    }