Feature: Add Amazon Bedrock Agents support

cli/magic-config.ts

@@ -151,6 +151,7 @@ const embeddingModels = [
       options.bedrockRoleArn = config.bedrock?.roleArn;
       options.guardrailsEnable = config.bedrock?.guardrails?.enabled;
       options.guardrails = config.bedrock?.guardrails;
+      options.bedrockAgents = config.bedrock?.agents;
       options.sagemakerModels = config.llms?.sagemaker ?? [];
       options.enableSagemakerModels = config.llms?.sagemaker
         ? config.llms?.sagemaker.length > 0
@@ -343,6 +344,17 @@ async function processCreateOptions(options: any): Promise<void> {
       },
       initial: options.guardrails?.version ?? "DRAFT",
     },
+    {
+      type: "confirm",
+      name: "bedrockAgents",
+      message: "Do you want to deploy a sample Bedrock Agent?",
+      initial: options.bedrockAgents ?? false,
+      skip() {
+        return !["us-east-1", "us-west-2"].includes(
+          (this as any).state.answers.bedrockRegion
+        );
+      },
+    },
     {
       type: "confirm",
       name: "enableSagemakerModels",
@@ -461,8 +473,9 @@ async function processCreateOptions(options: any): Promise<void> {
     {
       type: "input",
       name: "sagemakerCronStopSchedule",
-      hint: "This cron format is using AWS eventbridge cron syntax see docs for more information",
-      message: "Stop schedule for Sagmaker models expressed in AWS cron format",
+      hint: "This cron format is using AWS EventBridge cron syntax see docs for more information",
+      message:
+        "Stop schedule for Sagemaker models expressed in AWS cron format",
       skip(): boolean {
         return !(this as any).state.answers.enableCronFormat.includes("cron");
       },
@@ -1151,6 +1164,7 @@ async function processCreateOptions(options: any): Promise<void> {
             identifier: answers.guardrailsIdentifier,
             version: answers.guardrailsVersion,
           },
+          agents: answers.bedrockAgents,
         }
       : undefined,
     llms: {

lib/agents/index.ts

@@ -0,0 +1,161 @@
+import * as cdk from "aws-cdk-lib";
+import { Construct } from "constructs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as path from "path";
+import * as geo from "aws-cdk-lib/aws-location";
+import { bedrock } from "@cdklabs/generative-ai-cdk-constructs";
+import { Bucket } from "aws-cdk-lib/aws-s3";
+import { BucketDeployment, Source } from "aws-cdk-lib/aws-s3-deployment";
+import { VectorIndex } from "@cdklabs/generative-ai-cdk-constructs/lib/cdk-lib/opensearch-vectorindex";
+import { VectorCollection } from "@cdklabs/generative-ai-cdk-constructs/lib/cdk-lib/opensearchserverless";
+import { NagSuppressions } from "cdk-nag";
+
+export class BedrockWeatherAgent extends Construct {
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    const powertools = lambda.LayerVersion.fromLayerVersionArn(
+      this,
+      "powertools",
+      `arn:aws:lambda:${
+        cdk.Stack.of(this).region
+      }:017000801446:layer:AWSLambdaPowertoolsPythonV2:58`
+    );
+
+    const placeIndex = new geo.CfnPlaceIndex(this, "place-index", {
+      dataSource: "Esri",
+      indexName: "PlaceIndex",
+      pricingPlan: "RequestBasedUsage",
+    });
+
+    const vectorStore = new VectorCollection(this, "vector-collection");
+    const vectorIndex = new VectorIndex(this, "vector-index", {
+      collection: vectorStore,
+      indexName: "weather",
+      vectorField: "vector",
+      vectorDimensions: 1536,
+      mappings: [
+        {
+          mappingField: "AMAZON_BEDROCK_TEXT_CHUNK",
+          dataType: "text",
+          filterable: true,
+        },
+        {
+          mappingField: "AMAZON_BEDROCK_METADATA",
+          dataType: "text",
+          filterable: false,
+        },
+      ],
+    });
+
+    const modulesLayer = new lambda.LayerVersion(this, "modules-layer", {
+      code: lambda.Code.fromDockerBuild(
+        path.join(__dirname, "weather/modules")
+      ),
+      compatibleRuntimes: [lambda.Runtime.PYTHON_3_12],
+      description: "Layer with required modules for the agent",
+    });
+
+    const weather = new lambda.Function(this, "weather", {
+      runtime: lambda.Runtime.PYTHON_3_12,
+      description:
+        "Lambda function that implements APIs to retrieve weather data",
+      code: lambda.Code.fromAsset(path.join(__dirname, "weather")),
+      handler: "lambda.handler",
+      environment: {
+        LOCATION_INDEX: placeIndex.indexName,
+      },
+      memorySize: 512,
+      timeout: cdk.Duration.seconds(10),
+      layers: [powertools, modulesLayer],
+    });
+
+    const policy = new iam.Policy(this, "weather-policy", {
+      statements: [
+        new iam.PolicyStatement({
+          actions: ["geo:SearchPlaceIndexForText"],
+          resources: ["*"],
+        }),
+      ],
+    });
+    weather.role?.attachInlinePolicy(policy);
+
+    const kb = new bedrock.KnowledgeBase(this, "weather-kb", {
+      embeddingsModel: bedrock.BedrockFoundationModel.TITAN_EMBED_TEXT_V1,
+      vectorField: "vector",
+      vectorIndex: vectorIndex,
+      vectorStore: vectorStore,
+      indexName: "weather",
+      instruction: "answers questions about WMO and metereology",
+    });
+
+    const bucket = new Bucket(this, "bedrock-kb-datasource-bucket", {
+      enforceSSL: true,
+    });
+
+    const keyPrefix = "my-docs";
+    new bedrock.S3DataSource(this, "my-docs-datasource", {
+      bucket: bucket,
+      dataSourceName: "my-docs",
+      knowledgeBase: kb,
+      inclusionPrefixes: [keyPrefix],
+    });
+
+    const agent = new bedrock.Agent(this, "weather-agent", {
+      foundationModel:
+        bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_INSTANT_V1_2,
+      instruction: `You are a weather expert and answer user question about weather in different places. 
+If you are asked to provide historical date, you need to answer with a summary of the weather over the period. 
+You answer the questions in the same language they have been asked.`,
+      description: "an agent to interact with a weather api",
+      knowledgeBases: [kb],
+      name: "WeatherTeller",
+    });
+
+    agent.addActionGroup({
+      actionGroupExecutor: weather,
+      apiSchema: bedrock.ApiSchema.fromAsset(
+        path.join(__dirname, "weather", "schema.json")
+      ),
+      actionGroupState: "ENABLED",
+    });
+
+    agent.addActionGroup({
+      parentActionGroupSignature: "AMAZON.UserInput",
+      actionGroupState: "ENABLED",
+      actionGroupName: "UserInputAction",
+    });
+
+    new BucketDeployment(this, "my-docs-files", {
+      destinationBucket: bucket,
+      destinationKeyPrefix: keyPrefix,
+      sources: [Source.asset(path.join(__dirname, "my-documents"))],
+    });
+
+    new cdk.CfnOutput(this, "weather-function-name", {
+      value: weather.functionName,
+    });
+
+    NagSuppressions.addResourceSuppressions(weather.role!, [
+      {
+        id: "AwsSolutions-IAM4",
+        reason: "IAM role implicitly created by CDK.",
+      },
+    ]);
+
+    NagSuppressions.addResourceSuppressions(policy, [
+      {
+        id: "AwsSolutions-IAM5",
+        reason: "IAM role implicitly created by CDK.",
+      },
+    ]);
+
+    NagSuppressions.addResourceSuppressions(bucket, [
+      {
+        id: "AwsSolutions-S1",
+        reason: "Access logs not required",
+      },
+    ]);
+  }
+}

lib/agents/my-documents/README.md

@@ -0,0 +1 @@
+Add your documents to this folder to get them uploaded

lib/agents/weather/event.json

@@ -0,0 +1,34 @@
+{
+  "messageVersion": "1.0",
+  "agent": {
+    "name": "alfa",
+    "id": "beta",
+    "alias": "alfa",
+    "version": "1.2"
+  },
+  "inputText": "any text",
+  "sessionId": "1234",
+  "actionGroup": "mygroup",
+  "apiPath": "/current_weather",
+  "httpMethod": "GET",
+  "parameters": [
+    {
+      "name": "place",
+      "type": "string",
+      "value": "Milan"
+    }
+  ],
+  "requestBody": {
+    "content": {
+      "application/json": {
+        "properties": [
+          {
+            "name": "place",
+            "type": "string",
+            "value": "Milan"
+          }
+        ]
+      }
+    }
+  }
+}

lib/agents/weather/lambda.py

@@ -0,0 +1,140 @@
+from aws_lambda_powertools import Tracer
+from aws_lambda_powertools.event_handler import BedrockAgentResolver
+from aws_lambda_powertools.event_handler.openapi.params import Query
+from pydantic import BaseModel
+from typing import List
+import boto3
+import os
+import requests
+from typing import Annotated
+import pandas as pd
+import datetime
+
+tracer = Tracer()
+
+
+class Weather(BaseModel):
+    time: str
+    temperature: str
+    precipitation: str
+
+
+class Period(BaseModel):
+    start_date: str
+    end_date: str
+
+
+app = BedrockAgentResolver()
+
+
+def get_metric_and_unit(w: dict, name: str) -> str:
+    return f"{w['current'][name]} {w['current_units'][name]}"
+
+
+@app.get("/current_weather", description="get the current weather for a given place")
+def get_current_weather(
+    place: Annotated[str, Query(description="the name of the place")]
+) -> Weather:
+    resp = loc_client.search_place_index_for_text(
+        IndexName=os.environ.get(
+            "LOCATION_INDEX", os.environ.get("PLACE_INDEX", "Test")
+        ),
+        Text=place,
+    )
+    [lon, lat] = resp["Results"][0]["Place"]["Geometry"]["Point"]
+    q = (
+        "https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}"
+        + "&current=temperature_2m,precipitation"
+    )
+    w = requests.get(q.format(lat=lat, lon=lon)).json()
+
+    return Weather(
+        time=w["current"]["time"],
+        temperature=get_metric_and_unit(w, "temperature_2m"),
+        precipitation=get_metric_and_unit(w, "precipitation"),
+    )
+
+
+@app.get(
+    "/absolute_period_dates",
+    description="get the absolute start and end date for a period in YYYY-MM-DD"
+    + " format given the number of day difference from the today",
+)
+def get_absolute_period_dates(
+    startPeriodDeltaDays: Annotated[
+        int,
+        Query(
+            description="the difference in days from the today"
+            + " to the start date of the period"
+        ),
+    ],
+    endPeriodDeltaDays: Annotated[
+        int,
+        Query(
+            description="the difference in days from the today"
+            + " to the end date of the period"
+        ),
+    ],
+) -> Period:
+    today = datetime.date.today()
+    p = Period()
+    p.start_date = (today - datetime.timedelta(startPeriodDeltaDays)).isoformat()
+    p.end_date = (today - datetime.timedelta(endPeriodDeltaDays)).isoformat()
+    return p
+
+
+@app.get(
+    "/historical_weather",
+    description="get the historical daily mean temperature and precipitation"
+    + " for a given place for a range of dates",
+)
+def get_historical_weather(
+    place: Annotated[str, Query(description="the name of the place")],
+    fromDate: Annotated[str, Query(description="starting date in YYYY-MM-DD format")],
+    toDate: Annotated[str, Query(description="ending date in YYYY-MM-DD format")],
+) -> List[Weather]:
+    resp = loc_client.search_place_index_for_text(
+        IndexName=os.environ.get(
+            "LOCATION_INDEX", os.environ.get("PLACE_INDEX", "Test")
+        ),
+        Text=place,
+    )
+    [lon, lat] = resp["Results"][0]["Place"]["Geometry"]["Point"]
+    q = (
+        "https://archive-api.open-meteo.com/v1/archive?latitude={lat}&longitude={lon}"
+        + "&start_date={fromDate}&end_date={toDate}&hourly=temperature_2m,precipitation"
+    )
+    resp = requests.get(
+        q.format(lat=lat, lon=lon, fromDate=fromDate, toDate=toDate)
+    ).json()
+    hourly_values = pd.DataFrame(resp["hourly"])
+    hourly_values["time"] = pd.to_datetime(hourly_values["time"])
+    hourly_values = hourly_values.set_index("time")
+    hourly_values = hourly_values.resample("D").agg(
+        {"temperature_2m": "mean", "precipitation": "sum"}
+    )
+    return [
+        Weather(
+            time=str(hourly_values.iloc[i].name).split(" ")[0],
+            temperature=hourly_values.iloc[i][0],
+            precipitation=hourly_values.iloc[i][1],
+        )
+        for i in range(hourly_values.shape[0])
+    ]
+
+
+def handler(event, context):
+    print(event)
+    resp = app.resolve(event, context)
+    print(resp)
+    return resp
+
+
+if __name__ == "__main__":
+    with open("schema.json", "w") as f:
+        f.write(app.get_openapi_json_schema())
+else:
+    sess = boto3.Session(
+        region_name=os.environ.get("LOCATION_AWS_REGION", os.environ.get("AWS_REGION"))
+    )
+    loc_client = sess.client("location")

lib/agents/weather/modules/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12-slim
+
+RUN apt update -y && apt install zip -y
+
+ADD requirements.txt .
+
+RUN mkdir -p /asset/python && pip install -r requirements.txt -t /asset/python

lib/agents/weather/modules/requirements.txt

@@ -0,0 +1,2 @@
+requests==2.29
+pandas==2.2