Constructing AI buying agent utilizing Amazon Bedrock AgentCore Runtime and Amazon OpenSearch Service

On this put up, we discover the right way to construct a web based buying AI agent. We concentrate on its structure and implementation with Amazon OpenSearch Service, Amazon Bedrock AgentCore, and Strands Brokers. Amazon Bedrock AgentCore is an agentic platform for deploying and working these brokers and instruments securely at scale with out managing infrastructure. AgentCore Runtime is the safe, serverless runtime that hosts your Strands Brokers and instruments as containerized purposes. Strands Brokers is an open supply SDK for constructing AI brokers. On this SDK, an agent is outlined by a mannequin, instruments, and a immediate. Instruments are callable capabilities that enable brokers to carry out actions past textual content era, reminiscent of API calls, database queries, and file operations. The framework lets the mannequin autonomously plan steps and invoke instruments to finish duties.

Right this moment’s AI buying assistants perceive pure language, context, and buying intent, making a extra human-like interplay. These assistants deal with advanced buying necessities, reminiscent of “Discover me a proper gown underneath $200 that’s acceptable for a summer season wedding ceremony.” They preserve dialog historical past, course of follow-up questions naturally, and supply personalised suggestions primarily based on consumer preferences and previous interactions. Prospects can use visible search to add photographs of things that they need, and the AI finds comparable merchandise throughout a number of retailers, matching kinds and patterns. The purpose is to supply immediate, related, and personalised help at scale, making a extra environment friendly buying journey for customers worldwide.

AI brokers mixed with Retrieval Augmented Technology (RAG) on Amazon OpenSearch Service symbolize an evolution in conversational search. This integration builds AI brokers on enriched catalogs, supporting context-aware and autonomous search experiences whereas sustaining accuracy and relevance via grounded responses.

Resolution overview

The next diagram illustrates the answer structure of an AI-powered on-line buying agent constructed utilizing Strands Brokers, Amazon Bedrock AgentCore Runtime, and Amazon OpenSearch Service. For simplicity, the diagram doesn’t present authentication and authorization. In a manufacturing setup, safe entry to the backend through the use of mechanisms reminiscent of Amazon API Gateway, AWS Id and Entry Administration (IAM) roles, or OAuth-based authentication.

The next is a walkthrough of the reference structure:

1. The consumer submits a query via the front-end utility. AgentCore Runtime receives the request and routes it to the Strands Retail Agent.
2. The Strands Agent processes the duty and invokes the search_product_catalog instrument.
3. OpenSearch Service performs semantic search and returns related product outcomes.
4. The Strands Agent invokes Amazon Bedrock giant language fashions (LLMs) to generate a pure language response.
5. The agent response is returned to the consumer via the entrance finish.

Walkthrough

The next part walks you thru the right way to construct a web based buying AI agent.

Conditions

To implement this resolution, you want an AWS account. You additionally want an OpenSearch Service area with OpenSearch model 2.13 or later. You should use an present area or create a brand new area.

To make use of the vector search capabilities of OpenSearch Service with Strands Brokers on AgentCore, you utilize ingest pipelines. These ingestion pipelines apply built-in processors to pre-process your paperwork earlier than you index them in OpenSearch Service.

You employ the text_embedding processor, which depends on the ML Commons plugin and a registered embedding mannequin—Amazon Nova Multimodal Embeddings on Amazon Bedrock. OpenSearch Service makes use of the ML Commons plugin to generate vector embedding on your information and makes use of the identical mannequin to transform incoming queries into vectors. This helps semantic search throughout your listed content material.

You prolong your semantic search backend by including an agent constructed with Strands Brokers and deployed on Amazon Bedrock AgentCore.

Code samples supplied on this put up are examined in Python 3.11. You solely want to put in Python 3.11 in your surroundings to execute the python scripts. You additionally want Node.js 18 or later put in to make use of the AgentCore CLI. The supplied code scripts will deploy into your AWS account so be sure your terminal has entry to obligatory AWS credentials.

Set up AgentCore CLI

Set up the AgentCore CLI globally utilizing npm:

npm set up -g @aws/agentcore

Python Dependencies

You additionally must create a necessities.txt file with following dependencies in your workspace to deploy the brokers.

boto3
uv
opensearch-py
requests-aws4auth
strands-agents
strands-agents-tools
bedrock-agentcore

Run pip set up -r necessities.txt in your terminal to put in the required dependencies. To keep away from conflicts with different dependencies in your system, you should use a digital surroundings.

Now, stroll via every step.

Step 1: Configure IAM permissions

Full the next steps to register the Nova Multimodal Embeddings mannequin with OpenSearch Service and confirm that your OpenSearch Service area has permission to invoke the Amazon Bedrock API.

1. Go to the IAM console and create a brand new function with a {custom} belief coverage. Add the next belief coverage.

   {
     "Model": "2012-10-17",
     "Assertion": [
       {
         "Sid": "Statement1",
         "Effect": "Allow",
         "Principal": {
           "Service": "opensearchservice.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }

2. Skip including a permission coverage.
3. Give your function a reputation and create it. For this put up, we use OpenSearchBedrockEmbeddingRole because the function identify. OpenSearch Service makes use of this function to invoke the Nova Multimodal Embeddings mannequin on Amazon Bedrock.
4. On the Permissions tab, connect an inline coverage with the next permissions. For this put up, we identify this coverage OpenSearchBedrockEmbeddingPolicy.

   {
     "Model": "2012-10-17",
     "Assertion": [
       {
         "Sid": "Statement1",
         "Effect": "Allow",
         "Action": [
           "bedrock:InvokeAgent",
           "bedrock:InvokeModel"
         ],
         "Useful resource": [
           "arn:aws:bedrock:us-east-1::foundation-model/*"
         ]
       }
     ]
   }

5. Create a passRole coverage with the next JSON doc and assign it to the IAM function that creates the ML connector. This lets the principal working the Python code cross the OpenSearchBedrockEmbeddingRole to OpenSearch. Exchange with your personal AWS account ID.

   {
     "Model": "2012-10-17",
     "Assertion": [
       {
         "Effect": "Allow",
         "Action": "iam:PassRole",
         "Resource": "arn:aws:iam::$:role/OpenSearchBedrockEmbeddingRole"
       }
     ]
   }

6. Through the use of fine-grained entry management (FGAC), map the IAM function as a backend function for the ml_full_access function within the OpenSearch Dashboards Safety plugin. This mapping lets the consumer create ML connectors:
   1. Log in to OpenSearch Dashboards and open the Safety web page from the navigation menu.
   2. Select Roles and choose ml_full_access.
   3. Select Mapped Customers and Handle Mapping.
   4. Below Backend roles, add the ARN of the IAM function that you just created within the earlier steps.

Step 2: Hook up with the mannequin through the use of OpenSearch ML Connectors

On this part, you create an ML connector to hyperlink OpenSearch Service with the Bedrock Nova Multimodal Embeddings mannequin. You then register and deploy the mannequin so you should use it for neural search queries.

1. Create a file named create-connector.py with the next code. Exchange , , and placeholders inside the code.

import boto3
import requests
from requests_aws4auth import AWS4Auth
host=""##CHANGE THIS
area = '' ##CHANGE THIS
account_id = '' ##CHANGE THIS
service="es"
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, area, service, session_token=credentials.token)
path="/_plugins/_ml/connectors/_create"
url = host + path
payload = {
"identify": "Amazon Bedrock Nova multimodal mannequin - textual content embedding",
"description": "Take a look at connector for Amazon Bedrock Nova multimodal mannequin - textual content embedding",
"model": 1,
"protocol": "aws_sigv4",
"credential": {
"roleArn": f"arn:aws:iam::{account_id}:function/OpenSearchBedrockEmbeddingRole"
},
"parameters": {
"area": area,
"service_name": "bedrock",
"mannequin": "amazon.nova-2-multimodal-embeddings-v1:0",
"input_docs_processed_step_size": 1,
"dimensions": 1024,
"embeddingTypes": [
"float"
],
"truncationMode": "NONE"
},
"actions": [
{
"action_type": "predict",
"method": "POST",
"headers": {
"content-type": "application/json",
"x-amz-content-sha256": "required"
},
"url": "https://bedrock-runtime.${parameters.region}.amazonaws.com/model/${parameters.model}/invoke",
"request_body": "{n "taskType": "SINGLE_EMBEDDING",n "singleEmbeddingParams": {n "embeddingPurpose": "GENERIC_INDEX",n "embeddingDimension": ${parameters.dimensions},n "text": {n "truncationMode": "${parameters.truncationMode}",n "value": "${parameters.inputText}"n }n }n}",
"pre_process_function": "connector.pre_process.bedrock.nova.text_embedding",
"post_process_function": "connector.post_process.bedrock.nova.embedding"
}
]
}
headers = {"Content material-Kind": "utility/json"}
r = requests.put up(url, auth=awsauth, json=payload, headers=headers, timeout=15)
print(r.status_code)
print(r.textual content)

2. Run python create-connector.py in your terminal through the use of the IAM function with ml_full_access and passRole permissions created within the earlier step. This script creates a connector between OpenSearch Service and the Bedrock Nova Multimodal Embeddings mannequin.
3. This system responds with connector_id. Take a be aware of it. Then, navigate to OpenSearch Dashboards and open Dev Instruments. Create a mannequin group towards which to register this mannequin within the OpenSearch Service area.

POST /_plugins/_ml/model_groups/_register
{
  "identify": "agent-conversational-search-model-group",
  "description": "A mannequin group for bedrock Nova embedding fashions used for conversational search"
}

4. Register a mannequin through the use of connector_id and model_group_id.

POST /_plugins/_ml/fashions/_register
{
  "identify": "nova-2-multimodal-embedding-v1",
  "function_name": "distant",
  "model_group_id": "",
  "description": "Nova 2 Multimodal Embeddings Mannequin",
  "connector_id": "",
  "interface": {}
}

5. Run the next API name to deploy the mannequin. Use the registered mannequin ID from the earlier step.

POST /_plugins/_ml/fashions//_deploy

Step 3: Create an ingest pipeline for information indexing

Use the next code to create an ingest pipeline for information indexing. The pipeline establishes a connection to the embedding mannequin, retrieves the embedding for the title area, and shops it within the OpenSearch index.

PUT /_ingest/pipeline/nova_multimodal_embedding
{
  "description": "Textual content embedding pipeline utilizing nova_multimodal_embedding",
  "processors": [
    {
      "text_embedding": {
        "model_id": "",
        "field_map": {
          "title": "title_vector"
        }
      }
    }
  ]
}

Step 4: Create an index for storing information

Create an index named product for storing information through the use of Dev Instruments. This index shops uncooked textual content and 1024-dimensional embeddings of the title area, and makes use of the ingest pipeline you created within the earlier step.

PUT /product
{
  "settings": {
    "index": {
      "default_pipeline": "nova_multimodal_embedding",
      "knn": true
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "kind": "textual content",
        "analyzer": "customary"
      },
      "title_vector": {
        "kind": "knn_vector",
        "dimension": 1024,
        "methodology": {
          "identify": "hnsw",
          "space_type": "cosinesimil",
          "engine": "lucene"
        }
      },
      "value": {
        "kind": "float"
      },
      "description": {
        "kind": "textual content"
      },
      "class": {
        "kind": "key phrase"
      },
      "image_url": {
        "kind": "textual content"
      },
      "ranking": {
        "properties": {
          "charge": {
            "kind": "float"
          },
          "depend": {
            "kind": "integer"
          }
        }
      }
    }
  }
}

Step 5: Ingest pattern information

Use the next code to ingest the pattern product information in Dev Instruments.

POST /_bulk
{"index": {"_index": "product", "_id": "2"}}
{"id":2,"title":"Mens Informal Premium Slim Match T-Shirts","value":22.3,"description":"Slim-fitting fashion, distinction raglan lengthy sleeve, three-button henley placket, gentle weight & gentle material for breathable and comfy sporting.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71-3HjGNDUL._AC_SY879._SX._UX._SY._UY_.jpg","ranking":{"charge":4.1,"depend":259}}
{"index": {"_index": "product", "_id": "3"}}
{"id":3,"title":"Mens Cotton Jacket","value":55.99,"description":"nice outerwear jackets for Spring/Autumn/Winter, appropriate for a lot of events, reminiscent of working, climbing, tenting, mountain/mountaineering, biking, touring or different outside.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71li-ujtlUL._AC_UX679_.jpg","ranking":{"charge":4.7,"depend":500}}
{"index": {"_index": "product", "_id": "4"}}
{"id":4,"title":"Mens Informal Slim Match","value":15.99,"description":"The colour could possibly be barely totally different between on the display screen and in follow.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71YXzeOuslL._AC_UY879_.jpg","ranking":{"charge":2.1,"depend":430}}
{"index": {"_index": "product", "_id": "5"}}
{"id":5,"title":"John Hardy Ladies's Legends Naga Gold & Silver Dragon Station Chain Bracelet","value":695,"description":"From our Legends Assortment, the Naga was impressed by the legendary water dragon that protects the ocean's pearl.","class":"jewelery","picture":"https://fakestoreapi.com/img/71pWzhdJNwL._AC_UL640_QL65_ML3_.jpg","ranking":{"charge":4.6,"depend":400}}

Step 6: Question the index

Run the next API name to check semantic search through the use of the Nova Multimodal Embeddings mannequin.

GET /product/_search
{
  "_source": false,
  "fields": [
    "title",
    "price",
    "category",
    "image"
  ],
  "measurement": 3,
  "question": {
    "neural": {
      "title_vector": {
        "query_text": "jacket",
        "model_id": "",
        "okay": 5
      }
    }
  }
}

The output of the previous question ought to appear to be the next.

{
  ...
  "hits": {
    "whole": {
      "worth": 4,
      "relation": "eq"
    },
    "max_score": 0.8333229,
    "hits": [
      {
        "_index": "product",
        "_id": "3",
        "_score": 0.8333229,
        "fields": {
          "image": [
            "https://fakestoreapi.com/img/71li-ujtlUL._AC_UX679_.jpg"
          ],
          "title": [
            "Mens Cotton Jacket"
          ],
          "class": [
            "men's clothing"
          ],
          "value": [
            55.99
          ]
        }
      }
      ...
    ]
  }
}

Step 7: Create an agent with Strands and Bedrock AgentCore Runtime

Now, create the Strands Agent that makes use of Anthropic Claude Sonnet 4.6 on Amazon Bedrock to go looking merchandise from the OpenSearch Service index. To take action:

• Import the Runtime app with from bedrock_agentcore.runtime import BedrockAgentCoreApp.
• Initialize the app in your code with app = BedrockAgentCoreApp().
• Create the OpenSearch Service connection and search question with the @instrument decorator.
• Enhance the invocation operate with the @app.entrypoint decorator.
• Let AgentCore Runtime management the working of the agent with app.run().

Now, full the next steps:

1. Just remember to have put in the mandatory dependencies from the Conditions part of this put up.
2. Create and save a file named search_agent.py with the next code. Exchange , , and placeholders inside the code.

   from strands import Agent, instrument
   import argparse
   import json
   from bedrock_agentcore.runtime import BedrockAgentCoreApp
   from strands.fashions import BedrockModel
   import boto3
   from opensearchpy import OpenSearch, RequestsHttpConnection
   from requests_aws4auth import AWS4Auth
   app = BedrockAgentCoreApp()
   @instrument
   def search_products(question: str, measurement: int = 5):
   attempt:
   # OpenSearch configuration
   host="" ## CHANGE THIS, DOMAIN ENDPOINT WITHOUT HTTPS!
   area = '' ##CHANGE THIS
   model_id= '' ##CHANGE THIS along with your deployed mannequin id in OpenSearch
   service="es"
   credentials = boto3.Session().get_credentials()
   awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, area, service, session_token=credentials.token)
   # Create OpenSearch consumer
   consumer = OpenSearch(
   hosts=[{'host': host, 'port': 443}],
   http_auth=awsauth,
   use_ssl=True,
   verify_certs=True,
   connection_class=RequestsHttpConnection
   )
   """Search merchandise in OpenSearch utilizing neural search"""
   search_body = {
   "_source": False,
   "fields": ["title", "price", "category", "image"],
   "measurement": measurement,
   "question": {
   "neural": {
   "title_vector": {
   "query_text": question,
   "model_id": model_id,
   "okay": 3
   }
   }
   }
   }
   response = consumer.search(
   physique=search_body,
   index="product"
   )
   merchandise = []
   for hit in response['hits']['hits']:
   fields = hit.get('fields', {})
   product = {
   'title': fields.get('title', [''])[0] if fields.get('title') else '',
   'value': fields.get('value', [''])[0] if fields.get('value') else '',
   'class': fields.get('class', [''])[0] if fields.get('class') else '',
   'picture': fields.get('picture', [''])[0] if fields.get('picture') else ''
   }
   merchandise.append(product)
   return f"Discovered {len(merchandise)} merchandise: {json.dumps(merchandise, indent=2)}"
   besides Exception as e:
   return f"Search error: {str(e)}"
   model_id = "world.anthropic.claude-haiku-4-5-20251001-v1:0"
   mannequin = BedrockModel(
   model_id=model_id,
   )
   agent = Agent(
   mannequin=mannequin,
   instruments=[search_products],
   system_prompt="You are a useful assistant. You are able to do product search, and inform the product particulars."
   )
   @app.entrypoint
   def strands_agent_bedrock(payload):
   """
   Invoke the agent with a payload
   """
   user_input = payload.get("immediate")
   print("Person enter:", user_input)
   response = agent(user_input)
   return response.message['content'][0]['text']
   if __name__ == "__main__":
   #strands_agent_bedrock({"immediate": "Search jacket"}) ##UNCOMMENT THIS FOR TESTING
   #app.run() ##UNCOMMENT THIS FOR DEPLOYMENT, MAKE SURE THE ABOVE LINE IS COMMENTED WHEN YOU ARE DEPLOYING TO AGENTCORE

   This deploys your agent domestically for testing functions.

3. Navigate to the IAM console and add the AmazonBedrockLimitedAccess permission coverage to the principal working the code.
4. Navigate to OpenSearch Dashboards and, from the left menu, select Safety plugin, then select Roles.
5. Select Create Function.
6. Identify the function agentcore-permissions.
7. Below cluster permissions, add cluster:admin/opensearch/ml/fashions/get and cluster:admin/opensearch/ml/predict.
8. Below index permissions, enter product* because the index sample. Add search and get permissions.
9. Create the function.
10. Select the function you created, swap to the Mapped Customers tab, select Handle mapping, and add the function that you just use for working the Python code as a backend function.
11. Uncomment the road strands_agent_bedrock({"immediate": "Search jacket"}) and ensure the app.run() line is commented within the code.
12. Run python search_agent.py in your terminal to begin the buying agent. The output ought to look just like the next.

    "Listed here are the jacket search outcomes:nn1. **Mens Cotton Jacket** - $55.99n2. **Mens Informal Slim Match** - $15.99n3. **Mens Informal Premium Slim Match T-Shirts** - $22.30n4. **John Hardy Ladies's Legends Naga Gold & Silver Dragon Station Chain Bracelet** - $695.00nnThe most related jacket possibility is the **Mens Cotton Jacket** at $55.99. Would you prefer to know extra about any of those merchandise?

13. Remark strands_agent_bedrock({"immediate": "Search jacket"}) and uncomment the app.run() line within the code earlier than going into the subsequent step.

Step 8: Configure and launch your agent to Bedrock AgentCore Runtime

The AgentCore CLI is a command-line instrument supplied by AWS that simplifies deployment of brokers to Amazon Bedrock AgentCore Runtime. Whenever you run the CLI deployment command, it automates your entire deployment workflow: it creates the mandatory IAM execution function with correct permissions, packages your Python utility code together with its dependencies, makes use of AWS CodeBuild to construct an optimized Docker container picture, pushes that container picture to Amazon Elastic Container Registry (ECR), and at last provisions the AgentCore Runtime surroundings that hosts your containerized agent. This eliminates the necessity for handbook Dockerfile creation, container builds, or infrastructure administration.

1. Earlier than you begin this step, be sure to have gone via part 7 and put in the AgentCore CLI and Python dependencies listed within the Conditions part.
2. Create a coverage named AgentCoreAccessPolicy with the next permissions and fix it to the function working the code. Exchange and placeholders.

{
  "Model": "2012-10-17",
  "Assertion": [
    {
      "Sid": "BedrockAgentCoreServiceAccess",
      "Effect": "Allow",
      "Action": [
        "bedrock-agentcore:*"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "ECRAuthorizationToken",
      "Impact": "Permit",
      "Motion": [
        "ecr:GetAuthorizationToken"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "ECRRepositoryAccess",
      "Impact": "Permit",
      "Motion": [
        "ecr:BatchCheckLayerAvailability",
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage",
        "ecr:PutImage",
        "ecr:InitiateLayerUpload",
        "ecr:UploadLayerPart",
        "ecr:CompleteLayerUpload",
        "ecr:DescribeRepositories",
        "ecr:CreateRepository",
        "ecr:ListImages",
        "ecr:DescribeImages"
      ],
      "Useful resource": [
        "arn:aws:ecr:::repository/bedrock-agentcore-*"
      ]
    },
    {
      "Sid": "CodeBuildProjectAccess",
      "Impact": "Permit",
      "Motion": [
        "codebuild:CreateProject",
        "codebuild:UpdateProject",
        "codebuild:StartBuild",
        "codebuild:BatchGetBuilds",
        "codebuild:DeleteProject"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "IAMRoleManagement",
      "Impact": "Permit",
      "Motion": [
        "iam:CreateRole",
        "iam:AttachRolePolicy",
        "iam:PutRolePolicy",
        "iam:GetRole",
        "iam:GetRolePolicy",
        "iam:PassRole",
        "iam:DeleteRole",
        "iam:DeleteRolePolicy",
        "iam:DetachRolePolicy",
        "iam:CreateServiceLinkedRole"
      ],
      "Useful resource": [
        "arn:aws:iam:::role/BedrockAgentCoreExecutionRole-*",
        "arn:aws:iam:::role/AmazonBedrockAgentCoreSDKCodeBuild-*",
        "arn:aws:iam:::role/aws-service-role/runtime-identity.bedrock-agentcore.amazonaws.com/AWSServiceRoleForBedrockAgentCoreRuntimeIdentity"
      ]
    },
    {
      "Sid": "CloudWatchLogsAccess",
      "Impact": "Permit",
      "Motion": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents",
        "logs:PutResourcePolicy"
      ],
      "Useful resource": "arn:aws:logs:::log-group:/aws/bedrock-agentcore/*"
    },
    {
      "Sid": "CloudWatchLogsResourcePolicy",
      "Impact": "Permit",
      "Motion": [
        "logs:PutResourcePolicy"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "S3BucketManagement",
      "Impact": "Permit",
      "Motion": [
        "s3:CreateBucket",
        "s3:PutBucketPolicy",
        "s3:PutBucketVersioning",
        "s3:PutBucketPublicAccessBlock",
        "s3:PutLifecycleConfiguration",
        "s3:PutObject",
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Useful resource": [
        "arn:aws:s3:::bedrock-agentcore-codebuild-sources--*",
        "arn:aws:s3:::bedrock-agentcore-codebuild-sources--*/*"
      ]
    }
  ]
}

3. Create a file named agentcore.yaml in your challenge listing with the next configuration. Exchange , , and placeholders:

# AgentCore Runtime Configuration
  runtime:
    identify: shopping-search-agent-runtime
    entrypoint: search_agent.py:strands_agent_bedrock
    area:   # CHANGE THIS - Your AWS area (e.g., us-east-1)

    execution_role:
      create: true
      identify: BedrockAgentCoreExecutionRole-shopping-agent
      insurance policies:
        - policy_name: BedrockAndOpenSearchAccess
          policy_document:
            Model: "2012-10-17"
            Assertion:
              - Sid: BedrockModelAccess
                Impact: Permit
                Motion:
                  - bedrock:InvokeModel
                  - bedrock:InvokeModelWithResponseStream
                Useful resource:
                  - arn:aws:bedrock:*::foundation-model/*
                  - arn:aws:bedrock:::inference-profile/*  # CHANGE THIS - Exchange  and 
              - Sid: OpenSearchAccess
                Impact: Permit
                Motion:
                  - es:ESHttpGet
                  - es:ESHttpPost
                  - es:ESHttpPut
                Useful resource: arn:aws:es:::area//*  # CHANGE THIS - Exchange all three placeholders
              - Sid: CloudWatchLogsAccess
                Impact: Permit
                Motion:
                  - logs:CreateLogGroup
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Useful resource: arn:aws:logs:::log-group:/aws/bedrock-agentcore/runtimes/*  # CHANGE THIS - Exchange  and 
              - Sid: ECRImageAccess
                Impact: Permit
                Motion:
                  - ecr:GetAuthorizationToken
                  - ecr:BatchGetImage
                  - ecr:GetDownloadUrlForLayer
                Useful resource: "*"

    container:
      structure: arm64  # Choices: arm64 or x86_64
      requirements_file: necessities.txt

    ecr:
      auto_create: true

4. Run the next command in your terminal to deploy the agent to AgentCore Runtime:
   • Create the AgentCore challenge and exchange along with your search agent.

     agentcore create --name ShoppingAgent --defaults
     cd ShoppingAgent
     cp ../search_agent.py app/ShoppingAgent/major.py

   • Add OpenSearch and different dependencies:

     cd app/ShoppingAgent
     uv add opensearch-py requests-aws4auth boto3
     cd ../..

   • Deploy the agent to Agentcore Runtime. This course of takes roughly 5-10 minutes.
   • As soon as deployment completes, confirm the runtime standing:

     You must see:

     ShoppingAgent: Deployed - Runtime: READY (arn:aws:bedrock-agentcore:::runtime/ShoppingAgent_...)
     
     URL: https://bedrock-agentcore..amazonaws.com/runtimes/.../invocations

Step 9: Configure OpenSearch Service entry

Map your AgentCore execution function to an OpenSearch backend function so the agent can entry your information.

1. Navigate to OpenSearch Dashboards. From the left menu, select the Safety plugin, then select Roles.
2. Seek for agentcore-permissions and select the function. Then, navigate to the Mapped Customers tab, select Handle mapping, and add arn:aws:iam:::function/AmazonBedrockAgentCoreSDKRuntime-us-east-1-custom as a backend function. Exchange the placeholder along with your account ID.

Step 10: Invoke the Bedrock AgentCore Runtime

You’ll be able to check the agent in Agent Sandbox. Enter the immediate Search jacket lower than 50$, and the agent returns the related outcome from the OpenSearch Service index with a abstract.

In real-world eventualities, you may design a search utility with a Strands Agent deployed in AgentCore Runtime. You’ll be able to add AgentCore Reminiscence, which provides your AI brokers the flexibility to recollect previous interactions and supply extra context-aware, personalised conversations.

Cleanup

To keep away from incurring future prices, delete the assets created whereas constructing this resolution:

1. Delete the OpenSearch Service area.
2. Delete the Amazon Bedrock AgentCore Runtime assets.

Conclusion

On this put up, you noticed the right way to create a conversational search with Amazon OpenSearch Service and Strands Brokers. You additionally discovered the right way to deploy the agent on Amazon Bedrock AgentCore Runtime. You’ll be able to additional improve this buying agent through the use of different AgentCore capabilities. For instance, AgentCore Reminiscence retains consumer preferences and previous interactions throughout classes, AgentCore Id manages shopper authentication and entry management, and AgentCore Observability helps you monitor and debug agent conduct in manufacturing. Collectively, these providers aid you construct buying experiences that ship immediate, related help at scale.

Now it’s your flip. Construct your personal conversational search expertise by integrating OpenSearch Service and Strands Brokers along with your product catalog. To be taught extra, see the Amazon OpenSearch Service and Amazon Bedrock AgentCore element pages.

In regards to the authors