BedrockAI
Amazon Bedrock for Blueprints and C++

Overview

BedrockAI connects Unreal Engine 4.27 and 5.8 to Amazon Bedrock. Characters keep a memory of what the player said, answer in their own voice, and can ask the game to run actions such as giving an item or opening a door. Requests run on background worker threads with automatic retries; every result arrives on the game thread.

• Send Message and Send Message Stream: whole replies or typewriter-style pieces, remembered by the conversation.
• Tool calls: Add Tool registers a game action with a JSON schema, Submit Tool Results returns what happened.
• Memory limited to the last messages, saved and restored with Get History As JSON and Load History From JSON.
• Ask and Ask Stream for one-shot text, Generate Image for images, Embed Text for vector search, Moderate Text for guardrails, Invoke Model Raw for any model-native API.
• You choose the model: any Bedrock model or inference profile with Converse support, per conversation or in the settings.
• Amazon Cognito identity pools for guests and signed-in players; static keys and the default AWS chain for development and servers.

Requirements

Installation

1. Install BedrockAI from Fab into your engine, or copy the BedrockAI folder into your project's Plugins folder.
2. Enable BedrockAI in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > BedrockAI and set Region, Identity Pool Id and Default Model Id.
4. C++ only: add PublicDependencyModuleNames.Add("BedrockAI"); to your Build.cs.

Setting up AWS

1. Enable model access. In the Amazon Bedrock console of your region open Model access and request access to each model you use (for example Amazon Nova Lite, Nova Canvas and Titan Text Embeddings V2). Requests to a model without access fail with AccessDeniedException.
2. Pick the model ids. Copy the model id (or, for models that require it, the cross-region inference profile id such as us.amazon.nova-pro-v1:0) into the settings or a conversation's Model Id.
3. Create an identity pool. In Amazon Cognito create an identity pool. Enable guest access if players may talk to NPCs before signing in, and add your identity providers.
4. Limit the pool's role. Give the IAM role of the pool (authenticated and/or guest) access only to the models and the guardrail your game uses. The Converse and ConverseStream APIs are authorized by bedrock:InvokeModel and bedrock:InvokeModelWithResponseStream:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "BedrockAIModels",
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-lite-v1:0",
        "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-canvas-v1:0",
        "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v2:0"
      ]
    },
    {
      "Sid": "BedrockAIGuardrail",
      "Effect": "Allow",
      "Action": "bedrock:ApplyGuardrail",
      "Resource": "arn:aws:bedrock:us-east-1:123456789012:guardrail/abc123example"
    }
  ]
}

Inference profiles need the profile ARN (arn:aws:bedrock:us-east-1:123456789012:inference-profile/us.amazon.nova-pro-v1:0) plus the foundation-model ARNs of every region the profile routes to.

5. Optional guardrail. Create a guardrail in the Bedrock console (content filters, denied topics, word filters, PII masking), publish a version and enter its id and version in the settings. BedrockAI then applies it to every conversation and Ask request, and Moderate Text can check player names and chat.

Cost and abuse

• Use a guardrail (Guardrail Id in the settings) for every player-facing conversation; check player names and chat with Moderate Text.
• Keep Max Tokens and Max History Messages low, and choose a small model where it is good enough.
• Allow only the models you need in the identity pool role, and set AWS budgets and Bedrock quotas with alarms.
• Rate-limit in your game (for example one message per NPC every few seconds) and never let tool calls do more than the player could do anyway: validate every tool input in game code.
• For public games, prefer routing requests through your own backend (for example a Lambda function behind authenticated API Gateway) where you can enforce per-player limits, instead of giving every client direct model access.

Quick start

One question

1. Add Ask to an Event Graph with Prompt Describe a rusty old key in one sentence.
2. From On Response, print Text. Usage shows the tokens billed.
3. From On Failure, print Error > Message; Error > Code says why.

Images and embeddings

Generate Image returns a texture you can put on a widget brush or material, plus the PNG bytes to save. Embed Text turns text into a vector; store the vectors of your lore entries once, embed the player's question, and pick the entry with the highest Cosine Similarity.

NPC with memory and a tool

1. On BeginPlay call Create Conversation with System Prompt You are Mira, a blacksmith in Oakvale. You may give the player one free item, and only once. Store the result in a variable MiraChat.
2. Call Add Tool on MiraChat: Name give_item, Description Gives an item to the player. Use only when Mira decides to hand something over., Input Schema Json:

{"type":"object","properties":{"item":{"type":"string","enum":["iron_sword","health_potion"]}},"required":["item"]}

3. When the player talks, call Send Message Stream with MiraChat and the player's text; append each On Delta piece to the dialogue box.
4. On Tool Use: loop over Tool Calls. For Name give_item, parse Input Json (for example with your JSON plugin or a string search for the item), check that the player has not received an item yet, add it to the inventory and build a Tool Result with the same Tool Use Id and Result Json {"given":true,"item":"iron_sword"} (or {"given":false,"reason":"already received"} with Is Error off, so Mira can explain).
5. Call Submit Tool Results with MiraChat and the results. Its On Response carries Mira's in-character answer ("Here, take this sword...").
6. On save, store Get History As JSON in the save game; on load, call Load History From JSON.

Latent nodes

All latent nodes run in the background, can be stopped with Cancel on their return value and fire exactly one final pin on the game thread. A conversation runs one request at a time.

Stop Reason is the Bedrock value: end_turn, tool_use, max_tokens, stop_sequence, guardrail_intervened or content_filtered. Exchanges stopped by a guardrail or content filter are not added to the memory.

Conversations

Properties

Requests copy the conversation on the game thread before they start, and the reply is added on the game thread when it arrives, so a conversation is never touched by a worker thread.

Functions

Credentials

Signed-in players: for a Cognito user pool call Set Login Token with Provider = Make User Pool Provider Name and Token = the ID token. Other providers use their pool login keys (accounts.google.com, appleid.apple.com, graph.facebook.com).

C++ API

// Build.cs: PublicDependencyModuleNames.Add("BedrockAI");
#include "BedrockAILibrary.h"

UBedrockAILibrary::AskNative(TEXT("Name a cursed sword."), FString(), FString(),
    FBedrockAINativeDelegate::CreateLambda([](const FString& Text, const FBedrockAIUsage& Usage, const FBedrockAIError& Error)
    {
        // runs on the game thread; Error.Code is empty on success
    }));

// Latent nodes from C++: create the action, bind its delegates, then Activate().
UBedrockAIChatAction* Action = UBedrockAIChatAction::SendConversationMessage(this, Conversation, TEXT("Hello"));
Action->OnResponse.AddDynamic(this, &AMyNpc::HandleReply);
Action->Activate();

UBedrockAIConversation also offers GetMessages(), GetTools(), IsBusy() and GetPendingToolCalls() for game code.

Types

Settings

Project Settings > Plugins > BedrockAI (saved to DefaultGame.ini). Changes apply to the next request.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Amazon Bedrock, Amazon Nova, Amazon Titan and Amazon Cognito are services of Amazon Web Services; model use is subject to the AWS terms and each model's own terms. Built for Unreal Engine 4.27 and 5.8.