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

On this publish, we discover the right way to construct a web based procuring AI agent. We give attention to 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, similar to 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 procuring assistants perceive pure language, context, and procuring intent, making a extra human-like interplay. These assistants deal with advanced procuring necessities, similar to “Discover me a proper costume underneath $200 that’s applicable for a summer time marriage ceremony.” They keep dialog historical past, course of follow-up questions naturally, and supply customized suggestions based mostly on consumer preferences and previous interactions. Prospects can use visible search to add pictures 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 on the spot, related, and customized help at scale, making a extra environment friendly procuring 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 by way of grounded responses.

Resolution overview

The next diagram illustrates the answer structure of an AI-powered on-line procuring 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 by utilizing mechanisms similar to 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 by way of 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 software.
3. OpenSearch Service performs semantic search and returns related product outcomes.
4. The Strands Agent invokes Amazon Bedrock massive language fashions (LLMs) to generate a pure language response.
5. The agent response is returned to the consumer by way of the entrance finish.

Walkthrough

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

Stipulations

To implement this answer, you want an AWS account. You additionally want an OpenSearch Service area with OpenSearch model 2.13 or later. You need to use an current 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 to your knowledge 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 offered on this publish 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 offered code scripts will deploy into your AWS account so be certain your terminal has entry to vital AWS credentials.

Set up AgentCore CLI

Set up the AgentCore CLI globally utilizing npm:

npm set up -g @aws/agentcore

Python Dependencies

You additionally have to 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 by way of 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 position 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 position a reputation and create it. For this publish, we use OpenSearchBedrockEmbeddingRole because the position title. OpenSearch Service makes use of this position 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 publish, we title 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 position that creates the ML connector. This lets the principal operating the Python code cross the OpenSearchBedrockEmbeddingRole to OpenSearch. Change 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 position as a backend position for the ml_full_access position 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. Underneath Backend roles, add the ARN of the IAM position that you just created within the earlier steps.

Step 2: Hook up with the mannequin by utilizing 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. Change , , 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 = {
"title": "Amazon Bedrock Nova multimodal mannequin - textual content embedding",
"description": "Check connector for Amazon Bedrock Nova multimodal mannequin - textual content embedding",
"model": 1,
"protocol": "aws_sigv4",
"credential": {
"roleArn": f"arn:aws:iam::{account_id}:position/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.publish(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 by utilizing the IAM position 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 observe 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
{
  "title": "agent-conversational-search-model-group",
  "description": "A mannequin group for bedrock Nova embedding fashions used for conversational search"
}

4. Register a mannequin by utilizing connector_id and model_group_id.

POST /_plugins/_ml/fashions/_register
{
  "title": "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 knowledge indexing

Use the next code to create an ingest pipeline for knowledge indexing. The pipeline establishes a connection to the embedding mannequin, retrieves the embedding for the title discipline, 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 knowledge

Create an index named product for storing knowledge by utilizing Dev Instruments. This index shops uncooked textual content and 1024-dimensional embeddings of the title discipline, 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": {
          "title": "hnsw",
          "space_type": "cosinesimil",
          "engine": "lucene"
        }
      },
      "worth": {
        "kind": "float"
      },
      "description": {
        "kind": "textual content"
      },
      "class": {
        "kind": "key phrase"
      },
      "image_url": {
        "kind": "textual content"
      },
      "score": {
        "properties": {
          "charge": {
            "kind": "float"
          },
          "rely": {
            "kind": "integer"
          }
        }
      }
    }
  }
}

Step 5: Ingest pattern knowledge

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

POST /_bulk
{"index": {"_index": "product", "_id": "2"}}
{"id":2,"title":"Mens Informal Premium Slim Match T-Shirts","worth":22.3,"description":"Slim-fitting fashion, distinction raglan lengthy sleeve, three-button henley placket, mild weight & comfortable cloth for breathable and cozy sporting.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71-3HjGNDUL._AC_SY879._SX._UX._SY._UY_.jpg","score":{"charge":4.1,"rely":259}}
{"index": {"_index": "product", "_id": "3"}}
{"id":3,"title":"Mens Cotton Jacket","worth":55.99,"description":"nice outerwear jackets for Spring/Autumn/Winter, appropriate for a lot of events, similar to working, mountain climbing, tenting, mountain/mountain climbing, biking, touring or different open air.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71li-ujtlUL._AC_UX679_.jpg","score":{"charge":4.7,"rely":500}}
{"index": {"_index": "product", "_id": "4"}}
{"id":4,"title":"Mens Informal Slim Match","worth":15.99,"description":"The colour may very well be barely totally different between on the display and in apply.","class":"males's clothes","picture":"https://fakestoreapi.com/img/71YXzeOuslL._AC_UY879_.jpg","score":{"charge":2.1,"rely":430}}
{"index": {"_index": "product", "_id": "5"}}
{"id":5,"title":"John Hardy Girls's Legends Naga Gold & Silver Dragon Station Chain Bracelet","worth":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","score":{"charge":4.6,"rely":400}}

Step 6: Question the index

Run the next API name to check semantic search by utilizing the Nova Multimodal Embeddings mannequin.

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

The output of the previous question ought to seem like 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"
          ],
          "worth": [
            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 @software decorator.
• Enhance the invocation perform with the @app.entrypoint decorator.
• Let AgentCore Runtime management the operating of the agent with app.run().

Now, full the next steps:

1. Just be sure you have put in the mandatory dependencies from the Stipulations part of this publish.
2. Create and save a file named search_agent.py with the next code. Change , , and placeholders inside the code.

   from strands import Agent, software
   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()
   @software
   def search_products(question: str, dimension: int = 5):
   strive:
   # OpenSearch configuration
   host="" ## CHANGE THIS, DOMAIN ENDPOINT WITHOUT HTTPS!
   area = '' ##CHANGE THIS
   model_id= '' ##CHANGE THIS together 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 shopper
   shopper = 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"],
   "dimension": dimension,
   "question": {
   "neural": {
   "title_vector": {
   "query_text": question,
   "model_id": model_id,
   "okay": 3
   }
   }
   }
   }
   response = shopper.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 '',
   'worth': fields.get('worth', [''])[0] if fields.get('worth') 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 = "international.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("Consumer 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 operating 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 position agentcore-permissions.
7. Underneath cluster permissions, add cluster:admin/opensearch/ml/fashions/get and cluster:admin/opensearch/ml/predict.
8. Underneath index permissions, enter product* because the index sample. Add search and get permissions.
9. Create the position.
10. Select the position you created, change to the Mapped Customers tab, select Handle mapping, and add the position that you just use for operating the Python code as a backend position.
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 start out the procuring agent. The output ought to look much 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 Girls'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 wish 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 software offered by AWS that simplifies deployment of brokers to Amazon Bedrock AgentCore Runtime. If you run the CLI deployment command, it automates the complete deployment workflow: it creates the mandatory IAM execution position 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 guide Dockerfile creation, container builds, or infrastructure administration.

1. Earlier than you begin this step, ensure you have gone by way of part 7 and put in the AgentCore CLI and Python dependencies listed within the Stipulations part.
2. Create a coverage named AgentCoreAccessPolicy with the next permissions and connect it to the position operating the code. Change and placeholders.

{
  "Model": "2012-10-17",
  "Assertion": [
    {
      "Sid": "BedrockAgentCoreServiceAccess",
      "Effect": "Allow",
      "Action": [
        "bedrock-agentcore:*"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "ECRAuthorizationToken",
      "Impact": "Enable",
      "Motion": [
        "ecr:GetAuthorizationToken"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "ECRRepositoryAccess",
      "Impact": "Enable",
      "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": "Enable",
      "Motion": [
        "codebuild:CreateProject",
        "codebuild:UpdateProject",
        "codebuild:StartBuild",
        "codebuild:BatchGetBuilds",
        "codebuild:DeleteProject"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "IAMRoleManagement",
      "Impact": "Enable",
      "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": "Enable",
      "Motion": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents",
        "logs:PutResourcePolicy"
      ],
      "Useful resource": "arn:aws:logs:::log-group:/aws/bedrock-agentcore/*"
    },
    {
      "Sid": "CloudWatchLogsResourcePolicy",
      "Impact": "Enable",
      "Motion": [
        "logs:PutResourcePolicy"
      ],
      "Useful resource": "*"
    },
    {
      "Sid": "S3BucketManagement",
      "Impact": "Enable",
      "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 venture listing with the next configuration. Change , , and placeholders:

# AgentCore Runtime Configuration
  runtime:
    title: 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
      title: BedrockAgentCoreExecutionRole-shopping-agent
      insurance policies:
        - policy_name: BedrockAndOpenSearchAccess
          policy_document:
            Model: "2012-10-17"
            Assertion:
              - Sid: BedrockModelAccess
                Impact: Enable
                Motion:
                  - bedrock:InvokeModel
                  - bedrock:InvokeModelWithResponseStream
                Useful resource:
                  - arn:aws:bedrock:*::foundation-model/*
                  - arn:aws:bedrock:::inference-profile/*  # CHANGE THIS - Change  and 
              - Sid: OpenSearchAccess
                Impact: Enable
                Motion:
                  - es:ESHttpGet
                  - es:ESHttpPost
                  - es:ESHttpPut
                Useful resource: arn:aws:es:::area//*  # CHANGE THIS - Change all three placeholders
              - Sid: CloudWatchLogsAccess
                Impact: Enable
                Motion:
                  - logs:CreateLogGroup
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Useful resource: arn:aws:logs:::log-group:/aws/bedrock-agentcore/runtimes/*  # CHANGE THIS - Change  and 
              - Sid: ECRImageAccess
                Impact: Enable
                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 venture and change together with your search agent.

     agentcore create --name ShoppingAgent --defaults
     cd ShoppingAgent
     cp ../search_agent.py app/ShoppingAgent/important.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:

     It’s best to 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 position to an OpenSearch backend position so the agent can entry your knowledge.

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

Step 10: Invoke the Bedrock AgentCore Runtime

You may 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 may add AgentCore Reminiscence, which supplies your AI brokers the power to recollect previous interactions and supply extra context-aware, customized conversations.

Cleanup

To keep away from incurring future fees, delete the assets created whereas constructing this answer:

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

Conclusion

On this publish, 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 may additional improve this procuring agent by utilizing different AgentCore capabilities. For instance, AgentCore Reminiscence retains consumer preferences and previous interactions throughout periods, AgentCore Id manages shopper authentication and entry management, and AgentCore Observability helps you monitor and debug agent habits in manufacturing. Collectively, these providers enable you to construct procuring experiences that ship on the spot, related help at scale.

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

Concerning the authors