Full Stack AI AWS Bedrock en la práctica: el código y los comandos que realmente importan

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

Si ves otra región, haz clic en el menú
desplegable y selecciona « US East (N. Virginia) ».

+----------------------------------------------------------+
|  Búsqueda : [ Bedrock                          ]        |
|                                                          |
|  Resultados :                                              |
|  +------------------------------------------------------+|
|  |  Amazon Bedrock                                      ||
|  |  Build with foundation models                        ||
|  +------------------------------------------------------+|
+----------------------------------------------------------+

+----------------------------+------------------------------+
|  Amazon Bedrock            |                              |
|                            |  Bedrock Dashboard           |
|  Playgrounds               |                              |
|    Chat                    |                              |
|    Text                    |  Bienvenido a Amazon         |
|    Image                   |  Bedrock. Accede a modelos   |
|                            |  fundacionales de vanguardia |
|                            |  mediante una API única.     |
|  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):
    """Representa un mensaje en la conversación."""
    role: str = Field(
        ...,
        description="Rol: 'user' o 'assistant'",
        examples=["user"]
    )
    content: str = Field(
        ...,
        description="Contenido del mensaje",
        examples=["Explícame los bucles Python"]
    )


class ChatRequest(BaseModel):
    """Solicitud enviada por el frontend para chatear con la IA."""
    message: str = Field(
        ...,
        min_length=1,
        max_length=10000,
        description="Mensaje del usuario"
    )
    history: Optional[List[Message]] = Field(
        default=[],
        description="Historial de la conversación"
    )
    model_id: Optional[str] = Field(
        default=None,
        description="ID del modelo Bedrock"
    )
    temperature: Optional[float] = Field(
        default=0.7,
        ge=0.0,
        le=1.0,
        description="Creatividad del modelo (0 = preciso, 1 = creativo)"
    )
    max_tokens: Optional[int] = Field(
        default=4096,
        ge=1,
        le=8192,
        description="Número máximo de tokens en la respuesta"
    )


class ChatResponse(BaseModel):
    """Respuesta devuelta por la API tras la llamada a Bedrock."""
    response: str = Field(
        ...,
        description="Respuesta generada por la IA"
    )
    model_id: str = Field(
        ...,
        description="ID del modelo utilizado"
    )
    input_tokens: int = Field(
        default=0,
        description="Tokens consumidos por el prompt"
    )
    output_tokens: int = Field(
        default=0,
        description="Tokens generados en la respuesta"
    )


class HealthResponse(BaseModel):
    """Respuesta del endpoint de salud."""
    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():
    """Crea y devuelve un cliente Bedrock Runtime."""
    return boto3.client(
        service_name="bedrock-runtime",
        region_name=AWS_REGION
    )


def build_messages(message: str, history: list = None) -> list:
    """Construye la lista de mensajes para la 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:
    """
    Llama a AWS Bedrock con el mensaje y devuelve la respuesta.

    Args:
        message: El mensaje del usuario
        history: El historial de la conversación
        model_id: El identificador del modelo Bedrock
        temperature: La creatividad (0.0 a 1.0)
        max_tokens: El número máximo de tokens de salida

    Returns:
        dict con la respuesta, el modelo utilizado y los 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 interactuar con 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():
    """Verifica que el servidor está operativo."""
    return HealthResponse(
        status="ok",
        message="El servidor funciona correctamente"
    )


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """
    Envía un mensaje a AWS Bedrock y devuelve la respuesta de la IA.

    - **message** : el texto enviado por el usuario
    - **history** : el historial de conversación (opcional)
    - **model_id** : el modelo Bedrock a utilizar (opcional)
    - **temperature** : la creatividad de 0.0 a 1.0 (opcional)
    - **max_tokens** : número máximo de tokens de salida (opcional)
    """
    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 al llamar a Bedrock : {str(e)}"
        )


@app.get("/models")
def list_models():
    """Devuelve la lista de modelos disponibles."""
    return {
        "models": [
            {
                "id": "anthropic.claude-3-sonnet-20240229-v1:0",
                "name": "Claude 3 Sonnet",
                "description": "Buen equilibrio rendimiento/coste"
            },
            {
                "id": "anthropic.claude-3-haiku-20240307-v1:0",
                "name": "Claude 3 Haiku",
                "description": "El más rápido y económico"
            },
            {
                "id": "anthropic.claude-3-5-sonnet-20240620-v1:0",
                "name": "Claude 3.5 Sonnet",
                "description": "El más potente"
            },
        ]
    }