Automate enterprise workflows by integrating Salesforce Agentforce with Amazon Bedrock Brokers

AI brokers are quickly reworking enterprise operations. Though a single agent can carry out particular duties successfully, advanced enterprise processes usually span a number of methods, requiring information retrieval, evaluation, decision-making, and motion execution throughout totally different methods. With multi-agent collaboration, specialised AI brokers can work collectively to automate intricate workflows.

This publish explores a sensible collaboration, integrating Salesforce Agentforce with Amazon Bedrock Brokers and Amazon Redshift, to automate enterprise workflows.

Multi-agent collaboration in Enterprise AI

Enterprise environments at this time are advanced, that includes various applied sciences throughout a number of methods. Salesforce and AWS present distinct benefits to clients. Many organizations already keep vital infrastructure on AWS, together with information, AI, and varied enterprise functions reminiscent of ERP, finance, provide chain, HRMS, and workforce administration methods. Agentforce delivers highly effective AI-driven agent capabilities which can be grounded in enterprise context and information. Whereas Salesforce gives a wealthy supply of trusted enterprise information, clients more and more want brokers that may entry and act on data throughout a number of methods. By integrating AWS-powered AI providers into Agentforce, organizations can orchestrate clever brokers that function throughout Salesforce and AWS, unlocking the strengths of each.

Agentforce and Amazon Bedrock Brokers can work collectively in versatile methods, leveraging the distinctive strengths of each platforms to ship smarter, extra complete AI workflows. Instance collaboration fashions embrace:

• Agentforce as the first orchestrator:
  • Manages finish to finish customer-oriented workflows
  • Delegates specialised duties to Amazon Bedrock Brokers as wanted by means of customized actions
  • Coordinates entry to exterior information and providers throughout methods

This integration creates a extra highly effective resolution that maximizes the advantages of each Salesforce and AWS, so you’ll be able to obtain higher enterprise outcomes by means of enhanced AI capabilities and cross-system performance.

Agentforce overview

Agentforce brings digital labor to each worker, division, and enterprise course of, augmenting groups and elevating buyer experiences.It really works seamlessly together with your current functions, information, and enterprise logic to take significant motion throughout the enterprise. And since it’s constructed on the trusted Salesforce platform, your information stays safe, ruled, and in your management. With Agentforce, you’ll be able to:

• Deploy prebuilt brokers designed for particular roles, industries, or use instances
• Allow brokers to take motion with current workflows, code, and APIs
• Join your brokers to enterprise information securely
• Ship correct and grounded outcomes by means of the Atlas Reasoning Engine

Amazon Bedrock Brokers and Amazon Bedrock Data Bases overview

Amazon Bedrock is a totally managed AWS service providing entry to high-performing basis fashions (FMs) from varied AI corporations by means of a single API. On this publish, we focus on the next options:

• Amazon Bedrock Brokers – Managed AI brokers use FMs to grasp consumer requests, break down advanced duties into steps, keep dialog context, and orchestrate actions. They will work together with firm methods and information sources by means of APIs (configured by means of motion teams) and entry data by means of information bases. You present directions in pure language, choose an FM, and configure information sources and instruments (APIs), and Amazon Bedrock handles the orchestration.
• Amazon Bedrock Data Bases – This functionality permits brokers to carry out Retrieval Augmented Technology (RAG) utilizing your organization’s non-public information sources. You join the information base to your information hosted in AWS, reminiscent of in Amazon Easy Storage Service (Amazon S3) or Amazon Redshift, and it robotically handles the vectorization and retrieval course of. When requested a query or given a job, the agent can question the information base to seek out related data, offering extra correct, context-aware responses and choices without having to retrain the underlying FM.

Agentforce and Amazon Bedrock Agent integration patterns

Agentforce can name Amazon Bedrock brokers in numerous methods, permitting flexibility to construct totally different architectures. The next diagram illustrates synchronous and asynchronous patterns.

For a synchronous or request-reply interplay, Agentforce makes use of customized agent actions facilitated by External Services, Apex Invocable Methods, or Flow to name an Amazon Bedrock agent. The authentication to AWS is facilitated utilizing named credentials. Named credentials are designed to securely handle authentication particulars for exterior providers built-in with Salesforce. They alleviate the necessity to hardcode delicate data like consumer names and passwords, minimizing the chance of publicity and potential information breaches. This separation of credentials from the applying code can considerably improve safety posture. Named credentials streamline integration by offering a centralized and constant technique for dealing with authentication, lowering complexity and potential errors. You should use Salesforce Private Connect to supply a safe non-public reference to AWS utilizing AWS PrivateLink. Seek advice from Non-public Integration Between Salesforce and Amazon API Gateway for added particulars.

For asynchronous calls, Agentforce makes use of Salesforce Event Relay and Flow with Amazon EventBridge to name an Amazon Bedrock agent.

On this publish, we focus on the synchronous name sample. We encourage you to discover Salesforce Occasion Relay with EventBridge to construct event-driven agentic AI workflows. Agentforce additionally provides the Agent API, which makes it simple to name an Agentforce agent from an Amazon Bedrock agent, utilizing EventBridge API locations, for bi-directional agentic AI workflows.

Resolution overview

As an instance the multi-agent collaboration between Agentforce and AWS, we use the next structure, which gives entry to Web of Issues (IoT) sensor information to the Agentforce agent and handles probably faulty sensor readings utilizing a multi-agent method.

The instance workflow consists of the next steps:

1. Coral Cloud has geared up their rooms with good air conditioners and temperature sensors. These IoT units seize essential data reminiscent of room temperature and error code and retailer it in Coral Cloud’s AWS database in Amazon Redshift.
2. Agentforce agent calls an Amazon Bedrock agent by means of the Agent Wrapper API with questions reminiscent of “What’s the temperature in room 123” to reply buyer questions associated to the consolation of the room. This API is applied as an AWS Lambda operate, performing because the entry level within the AWS Cloud.
3. The Amazon Bedrock agent, upon receiving the request, wants context. It queries its configured information base by producing the mandatory SQL question.
4. The information base is related to a Redshift database containing historic sensor information or contextual data (just like the sensor’s thresholds and upkeep historical past). It retrieves related data primarily based on the agent’s question and responds again with a solution.
5. With the preliminary information and the context from the information base, the Amazon Bedrock agent makes use of its underlying FM and pure language directions to resolve the suitable motion. On this situation, detecting an error prompts it to create a case when it receives faulty readings from a sensor.
6. The motion group accommodates the Agentforce Agent Wrapper Lambda operate. The Amazon Bedrock agent securely passes the mandatory particulars (like which sensor or room wants a case) to this operate.
7. The Agentforce Agent Wrapper Lambda operate acts as an adapter. It interprets the request from the Amazon Bedrock agent into the precise format required by the Agentforce service‘s API or interface.
8. The Lambda operate calls Agentforce, instructing it to create a case related to the contact or account linked to the sensor that despatched the faulty studying.
9. Agentforce makes use of its inside logic (agent, matters, and actions) to create or escalate the case inside Salesforce.

This workflow demonstrates how Amazon Bedrock Brokers orchestrates duties, utilizing Amazon Bedrock Data Bases for context and motion teams (by means of Lambda) to work together with Agentforce to finish the end-to-end course of.

Conditions

Earlier than constructing this structure, be sure to have the next:

• AWS account – An energetic AWS account with permissions to make use of Amazon Bedrock, Lambda, Amazon Redshift, AWS Id and Entry Administration (IAM), and API Gateway.
• Amazon Bedrock entry – Entry to Amazon Bedrock Brokers and to Anthropic’s Claude 3.5 Haiku v1 enabled in your chosen AWS Area.
• Redshift sources – An operational Redshift cluster or Amazon Redshift Serverless endpoint. The related tables containing sensor information (historic readings, sensor thresholds, and upkeep historical past) have to be created and populated.
• Agentforce system – Entry to and understanding of the Agentforce system, together with the way to configure it. You possibly can sign up for a developer version with Agentforce and Knowledge Cloud.
• Lambda information – Familiarity with creating, deploying, and managing Lambda capabilities (utilizing Python).
• IAM roles and insurance policies – Understanding of the way to create IAM roles with the mandatory permissions for Amazon Bedrock Brokers, Lambda capabilities (to name Amazon Bedrock, Amazon Redshift, and the Agentforce API), and Amazon Bedrock Data Bases.

Put together Amazon Redshift information

Be sure that your information is structured and out there in your Redshift occasion. Word the database title, credentials, and desk and column names.

Create IAM roles

For this publish, we create two IAM roles:

• custom_AmazonBedrockExecutionRoleForAgents:
  • Connect the next AWS managed insurance policies to the position:
    • AmazonBedrockFullAccess
    • AmazonRedshiftDataFullAccess
  • Within the belief relationship, present the next belief coverage (present your AWS account ID):

{
    "Model": "2012-10-17",
    "Assertion": [
        {
            "Sid": "AmazonBedrockAgentBedrockFoundationModelPolicyProd",
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "YOUR_ACCOUNT_ID"
                }
            }
        }
    ]
}

• custom_AWSLambdaExecutionRole:
  • Connect the next AWS managed insurance policies to the position:
    • AmazonBedrockFullAccess
    • AmazonLambdaBasicExecutionRole
  • Within the belief relationship, present the next belief coverage (present your AWS account ID):

{
    "Model": "2012-10-17",
   "Assertion": [
       {
           "Effect": "Allow",
           "Principal": {
               "Service": "lambda.amazonaws.com"
           },
           "Action": "sts:AssumeRole",
           "Condition": {
               "StringEquals": {
                   "aws:SourceAccount": "YOUR_ACCOUNT_ID"
               }
           }
       }
   ]
}

Create an Amazon Bedrock information base

Full the next steps to create an Amazon Bedrock information base:

1. On the Amazon Bedrock console, select Data Bases within the navigation pane.
2. Select Create and Data Base with structured information retailer.

3. On the Present Data Base particulars web page, present the next data:
   1. Enter a reputation and elective description.
   2. For Question engine, choose Amazon Redshift.
   3. For IAM permissions, choose Use an current service position and select custom_AmazonBedrockExecutionRoleForAgents.
   4. Select Subsequent.
      
      1. For Question engine connection particulars, choose Redshift provisioned and select your cluster.
      2. For Authentication, choose IAM Position.
      3. For Storage configuration, choose Amazon Redshift database and Redshift database checklist.
      4. On the Configure question engine web page, present the next data:
         
      5. Present desk and column descriptions. The next is an instance.
         
      6. Select Create Data Base.
4. After you create the information base, open the Redshift question editor and grant permissions for the position to entry Redshift tables by operating the next queries:

CREATE USER "IAMR:custom_AmazonBedrockExecutionRoleForAgents" WITH PASSWORD DISABLE; 

GRANT SELECT ON ALL TABLES IN SCHEMA dev.knowledgebase TO "IAMR:custom_AmazonBedrockExecutionRoleForAgents"; 

GRANT USAGE ON SCHEMA dev.knowledgebase TO "IAMR:custom_AmazonBedrockExecutionRoleForAgents";

For extra data, consult with arrange your question engine and permissions for making a information base with structured information retailer.

1. 5. Select Sync to sync the question engine.

Be sure that the standing exhibits as Full earlier than transferring to the following steps.

• When the sync is full, select Check Data Base.
• Choose Retrieval and response technology: information sources and mannequin and select Claude 3.5 Haiku for the mannequin.
• Enter a query about your information and be sure to get a sound reply.

Create an Amazon Bedrock agent

Full the next steps to create an Amazon Bedrock agent:

1. On the Amazon Bedrock console, select Brokers within the navigation pane.
2. Select Create agent.
3. On the Agent particulars web page, present the next data:
   1. Enter a reputation and elective description.
   2. For Agent useful resource position, choose Use an current service position and select custom_AmazonBedrockExecutionRoleForAgents.

4. Present detailed directions on your agent. The next is an instance:

You're an IoT system monitoring and alerting agent. 
You will have entry to the structured information containing studying, upkeep, threshold information for IoT units. 
You reply questions on system studying, upkeep schedule and thresholds. 
You may as well create case by way of Agentforce. 
Whenever you obtain comma separated values parse them as device_id, temperature, voltage, connectivity and error_code. 
First test if the temperature is lower than min temperature, greater than max temperature and connectivity is greater than the connectivity threshold for the product related to the system id. 
If there's an error code, ship data to agentforce to create case. The knowledge despatched to agentforce ought to embrace system readings reminiscent of system id, error code. 
It must also embrace the brink values associated to the product related to the system reminiscent of min temperature, max temperature and connectivity, 
In response to your name to agentforce simply return the abstract of the knowledge supplied with all of the attributes offered. 
Don't omit any data within the response. Don't embrace the phrase escalated in agent.

5. Select Save to save lots of the agent.
6. Add the information base you created in earlier step to this agent.

7. Present detailed directions concerning the information base for the agent.

8. Select Save after which select Put together the agent.
9. Check the agent by asking a query (within the following instance, we ask about sensor readings).

10. Select Create alias.
11. On the Create alias web page, present the next data:
    1. Enter an alias title and elective description.
    2. For Affiliate model, choose Create a brand new model and affiliate it to this alias.
    3. For Choose throughput, choose On-demand.
    4. Select Create alias.

12. Word down the agent ID, which you’ll use in subsequent steps.
13. Word down the alias ID and agent ID, which you’ll use in subsequent steps.

Create a Lambda operate

Full the next steps to create a Lambda operate to obtain requests from Agentforce:

1. On the Lambda console, select Features within the navigation pane.
2. Select Create operate.
3. Configure the operate with the next logic to obtain requests by means of API Gateway and name Amazon Bedrock brokers:

import boto3
import uuid
import json
import pprint
import traceback
import time
import logging
from agent_utils import invoke_agent_generate_response
logger = logging.getLogger()
logger.setLevel(logging.INFO)
bedrock_agent_runtime_client = boto3.consumer(
service_name="bedrock-agent-runtime",
region_name="REGION_NAME", # substitute with the area title out of your account
)
def lambda_handler(occasion, context):
    logger.information(occasion)
    physique = occasion['body']
    input_text = json.masses(physique)['inputText']
    agent_id = 'XXXXXXXX' # substitute with the agent id out of your account
    agent_alias_id = 'XXXXXXX' # substitute with the alias id out of your account
    session_id:str = str(uuid.uuid1()) # random identifier
    enable_trace:bool = False
    end_session:bool = False
    final_answer = None
    response = call_agent(input_text, agent_id, agent_alias_id)
    print("response : ")
    print(response)
 
    return {
        'headers': {
            'Content material-Sort' : 'software/json',
            'Entry-Management-Permit-Headers': '*',
            'Entry-Management-Permit-Origin': '*',
            'Entry-Management-Permit-Strategies': '*'
        },
        
        'statusCode': 200,
        'physique': json.dumps({"outputText" :  response  })
    }
def call_agent(inputText, agentId, agentAliasId): 
    session_id = str(uuid.uuid1())
    enable_trace = False
    end_session = False
    whereas True:
        strive:
            agent_response = bedrock_agent_runtime_client.invoke_agent(
                inputText=inputText,
                agentId=agentId,
                agentAliasId=agentAliasId,                
                sessionId=session_id,
                enableTrace=enable_trace,
                endSession=end_session
            )
            logger.information("Agent uncooked response:")
            pprint.pprint(agent_response)
            if 'completion' not in agent_response:
                increase ValueError("Lacking 'completion' in agent response")
            for occasion in agent_response['completion']:
                chunk = occasion.get('chunk')
                # print('chunk: ', chunk)
                if chunk:
                    decoded_bytes = chunk.get("bytes").decode()
                    # print('bytes: ', decoded_bytes)
                    return decoded_bytes
        besides Exception as e:
            print(traceback.format_exc())
            return f"Error: {str(e)}"

4. Outline the mandatory IAM permissions by assigning custom_AWSLambdaExecutionRole.

Create a REST API

Full the next steps to create a REST API in API Gateway:

1. On the API Gateway console, create a REST API with proxy integration.

2. Allow API key required to guard the API from unauthenticated entry.

3. Configure the utilization plan and API key. For extra particulars, see Arrange API keys for REST APIs in API Gateway.
4. Deploy the API.
5. Word down the Invoke URL to make use of in subsequent steps.

Create named credentials in Salesforce

Now that you’ve created an Amazon Bedrock agent with an API Gateway endpoint and Lambda wrapper, let’s full the configuration on the Salesforce facet. Full the next steps:

1. Log in to Salesforce.
2. Navigate to Setup, Safety, Named Credentials.
3. On the Exterior Credentials tab, select New.

4. Present the next data:
   1. Enter a label and title.
   2. For Authentication Protocol, select Customized.
   3. Select Save.

5. Open the Exterior Credentials entry to supply further particulars:
   1. Below Principals, create a brand new principal and supply the parameter title and worth.

• 1. Below Customized Headers, create a brand new entry and supply a reputation and worth.
  2. Select Save.

Now you’ll be able to grant entry to the agent consumer to entry these credentials.

1. Navigate to Setup, Customers, Person Profile, Enabled Exterior Credential Principal Entry and add the exterior credential principal you created to the enable checklist.

2. Select New to create a named credentials entry.
3. Present particulars reminiscent of label, title, the URL of the API Gateway endpoint, and authentication protocol, then select Save.

You possibly can optionally use Salesforce Non-public Join with PrivateLink to supply a safe non-public reference to. This permits essential information to stream from the Salesforce atmosphere to AWS with out utilizing the general public web.

Add an exterior service in Salesforce

Full the next steps so as to add an exterior service in Salesforce:

1. In Salesforce, navigate to Setup, Integrations, Exterior Providers and select Add an Exterior Service.
2. For Choose an API supply, select From API Specification.

3. On the Edit an Exterior Service web page, present the next data:
   1. Enter a reputation and elective description.
   2. For Service Schema, select Add from native.
   3. For Choose a Named Credential, select the named credential you created.

4. Add an Open API specification for the API Gateway endpoint. See the next instance:

openapi: 3.0.0
information:
  title: Bedrock Agent Wrapper API
  model: 1.0.0
  description: Bedrock Agent Wrapper API
paths:
  /proxy:
    publish:
      operationId: call-bedrock-agent
      abstract: Name Bedrock Agent
      description: Name Bedrock Agent
      requestBody:
        description: enter
        required: true
        content material:
          software/json:
            schema:
              $ref: '#/parts/schemas/enter'
      responses:
        '200':
          description: Profitable response
          content material:
            software/json:
              schema:
                $ref: '#/parts/schemas/output'
        '500':
          description: Server error
parts:
  schemas:
    enter:
      sort: object
      properties:
        inputText:
          sort: string
        agentId:
          sort: string
        agentAlias:
          sort: string
    output:
      sort: object
      properties:
        outputText:
          sort: string

5. Select Save and Subsequent.
6. Allow the operation to make it out there for Agentforce to invoke.
7. Select End.

Create an Agentforce agent motion to make use of the exterior service

Full the next steps to create an Agentforce agent motion:

1. In Salesforce, navigate to Setup, Agentforce, Einstein Generative AI, Agentforce Studio, Agentforce Belongings.
2. On the Actions tab, select New Agent Motion.
3. Below Connect with an current motion, present the next data:
   1. For Reference Motion Sort, select API.
   2. For Reference Motion Class, select Exterior Providers.
   3. For Reference Motion, select the Name Bedrock Agent motion that you simply configured.
   4. Enter an agent motion label and API title.
   5. Select Subsequent.

4. Present the next data to finish the agent motion configuration:
   1. For Agent Motion Directions, enter Name Bedrock Agent to get the details about system readings, sensor readings, upkeep or threshold data.
   2. For Loading Textual content, enter Calling Bedrock Agent.
   3. Below Enter, for Physique, enter Present the enter within the enter Textual content area.
   4. Below Outputs, for 200, enter Profitable response.

5. Save the agent motion.

Configure the Agentforce agent to make use of the agent motion

Full the next steps to configure the Agentforce agent to make use of the agent motion:

1. In Salesforce, navigate to Setup, Agentforce, Einstein Generative AI, Agentforce Studio, Agentforce Brokers and open the agent in Agent Builder.
2. Create a brand new subject.
3. On the Matter Configuration tab, present the next data:
   1. For Title, enter Machine Data.
   2. For Classification Description, enter This subject handles inquiries associated to system and sensor data, together with studying, upkeep, and threshold.
   3. For Scope, enter Your job is simply to supply details about system readings, sensor readings, system upkeep, sensor upkeep, and threshold. Don’t try to deal with points outdoors of offering system data.
   4. For Directions, enter the next:

If a consumer asks for system readings or sensor readings, present the knowledge.
If a consumer asks for system upkeep or sensor upkeep, present the knowledge.
When looking for system data, embrace the system or sensor id and any related key phrases in your search question.

4. On the This Matter’s Actions tab, select New and Add from Asset Library.

5. Select the Name Bedrock Agent motion.

6. Activate the agent and enter a query, reminiscent of “What’s the newest studying for sensor with system id CITDEV003.”

The agent will point out that it’s calling the Amazon Bedrock agent, as proven within the following screenshot.

The agent will fetch the knowledge utilizing the Amazon Bedrock agent from the related information base.

Clear up

To keep away from further prices, delete the sources that you simply created if you not want them:

1. Delete the Amazon Bedrock information base:
   1. On the Amazon Bedrock console, select Data Bases within the navigation pane.
   2. Choose the information base you created and select Delete.
2. Delete the Amazon Bedrock agent:
   1. On the Amazon Bedrock console, select Brokers within the navigation pane.
   2. Choose the agent you created and select Delete.
3. Delete the Lambda operate:
   1. On the Lambda console, select Features within the navigation pane.
   2. Choose the operate you created and select Delete.
4. Delete the REST API:
   1. On the API Gateway console, select APIs within the navigation pane.
   2. Choose the REST API you created and select Delete.

Conclusion

On this publish, we described an structure that demonstrates the facility of mixing AI providers on AWS with Agentforce. By utilizing Amazon Bedrock Brokers and Amazon Bedrock Data Bases for contextual understanding by means of RAG, and Lambda capabilities and API Gateway to bridge interactions with Agentforce, companies can construct subtle, automated workflows. As AI capabilities proceed to develop, such collaborative multi-agent methods will turn into more and more central to enterprise automation methods. In an upcoming publish, we’ll present you the way to construct the asynchronous integration sample from Agentforce to Amazon Bedrock utilizing Salesforce Occasion Relay.

To get began, see Become an Agentblazer Innovator and consult with How Amazon Bedrock Brokers works.

Concerning the authors

Yogesh Dhimate is a Sr. Accomplice Options Architect at AWS, main know-how partnership with Salesforce. Previous to becoming a member of AWS, Yogesh labored with main corporations together with Salesforce driving their business resolution initiatives. With over 20 years of expertise in product administration and options structure Yogesh brings distinctive perspective in cloud computing and synthetic intelligence.

Kranthi Pullagurla has over 20+ years’ expertise throughout Utility Integration and Cloud Migrations throughout A number of Cloud suppliers. He works with AWS Companions to construct options on AWS that our joint clients can use. Previous to becoming a member of AWS, Kranthi was a strategic advisor at MuleSoft (now Salesforce). Kranthi has expertise advising C-level buyer executives on their digital transformation journey within the cloud.

Shitij Agarwal is a Accomplice Options Architect at AWS. He creates joint options with strategic ISV companions to ship worth to clients. When not at work, he’s busy exploring NY city and the mountaineering trails that encompass it, and happening bike rides.

Ross Belmont is a Senior Director of Product Administration at Salesforce protecting Platform Knowledge Providers. He has greater than 15 years of expertise with the Salesforce ecosystem.

Sharda Rao is a Senior Director of Product Administration at Salesforce protecting Agentforce Go To Market technique

Hunter Reh is an AI Architect at Salesforce and a passionate builder who has developed over 100 brokers because the launch of Agentforce. Exterior of labor, he enjoys exploring new trails on his bike or getting misplaced in an excellent ebook.