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 typically span a number of methods, requiring knowledge 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 put up 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 right this moment are advanced, that includes numerous applied sciences throughout a number of methods. Salesforce and AWS present distinct benefits to prospects. Many organizations already preserve vital infrastructure on AWS, together with knowledge, AI, and varied enterprise functions similar to ERP, finance, provide chain, HRMS, and workforce administration methods. Agentforce delivers highly effective AI-driven agent capabilities which might be grounded in enterprise context and knowledge. Whereas Salesforce gives a wealthy supply of trusted enterprise knowledge, prospects more and more want brokers that may entry and act on info 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 knowledge and providers throughout methods

This integration creates a extra highly effective resolution that maximizes the advantages of each Salesforce and AWS, so you may 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 along with your present functions, knowledge, and enterprise logic to take significant motion throughout the enterprise. And since it’s constructed on the trusted Salesforce platform, your knowledge stays safe, ruled, and in your management. With Agentforce, you may:

• Deploy prebuilt brokers designed for particular roles, industries, or use instances
• Allow brokers to take motion with present workflows, code, and APIs
• Join your brokers to enterprise knowledge 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 put up, we focus on the next options:

• Amazon Bedrock Brokers – Managed AI brokers use FMs to grasp person requests, break down advanced duties into steps, preserve dialog context, and orchestrate actions. They’ll work together with firm methods and knowledge sources by means of APIs (configured by means of motion teams) and entry info by means of data bases. You present directions in pure language, choose an FM, and configure knowledge sources and instruments (APIs), and Amazon Bedrock handles the orchestration.
• Amazon Bedrock Data Bases – This functionality allows brokers to carry out Retrieval Augmented Era (RAG) utilizing your organization’s non-public knowledge sources. You join the data base to your knowledge hosted in AWS, similar to 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 activity, the agent can question the data base to search out related info, offering extra correct, context-aware responses and selections with no need to retrain the underlying FM.

Agentforce and Amazon Bedrock Agent integration patterns

Agentforce can name Amazon Bedrock brokers in several 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 Exterior Companies, Apex Invocable Strategies, or Circulate 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 info like person names and passwords, minimizing the chance of publicity and potential knowledge 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, decreasing complexity and potential errors. You should use Salesforce Non-public Join to offer a safe non-public reference to AWS utilizing AWS PrivateLink. Seek advice from Non-public Integration Between Salesforce and Amazon API Gateway for extra particulars.

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

On this put up, 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 presents 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.

Answer overview

As an example the multi-agent collaboration between Agentforce and AWS, we use the next structure, which gives entry to Web of Issues (IoT) sensor knowledge to the Agentforce agent and handles doubtlessly inaccurate sensor readings utilizing a multi-agent strategy.

The instance workflow consists of the next steps:

1. Coral Cloud has outfitted their rooms with good air conditioners and temperature sensors. These IoT gadgets seize crucial info similar to 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 similar to “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 perform, performing because the entry level within the AWS Cloud.
3. The Amazon Bedrock agent, upon receiving the request, wants context. It queries its configured data base by producing the required SQL question.
4. The data base is related to a Redshift database containing historic sensor knowledge or contextual info (just like the sensor’s thresholds and upkeep historical past). It retrieves related info primarily based on the agent’s question and responds again with a solution.
5. With the preliminary knowledge and the context from the data 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 inaccurate readings from a sensor.
6. The motion group comprises the Agentforce Agent Wrapper Lambda perform. The Amazon Bedrock agent securely passes the required particulars (like which sensor or room wants a case) to this perform.
7. The Agentforce Agent Wrapper Lambda perform 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 perform calls Agentforce, instructing it to create a case related to the contact or account linked to the sensor that despatched the inaccurate studying.
9. Agentforce makes use of its inner 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 you have the next:

• AWS account – An lively 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 assets – An operational Redshift cluster or Amazon Redshift Serverless endpoint. The related tables containing sensor knowledge (historic readings, sensor thresholds, and upkeep historical past) should be created and populated.
• Agentforce system – Entry to and understanding of the Agentforce system, together with how you can configure it. You’ll be able to join for a developer version with Agentforce and Knowledge Cloud.
• Lambda data – Familiarity with creating, deploying, and managing Lambda features (utilizing Python).
• IAM roles and insurance policies – Understanding of how you can create IAM roles with the obligatory permissions for Amazon Bedrock Brokers, Lambda features (to name Amazon Bedrock, Amazon Redshift, and the Agentforce API), and Amazon Bedrock Data Bases.

Put together Amazon Redshift knowledge

Ensure your knowledge is structured and out there in your Redshift occasion. Be aware the database identify, credentials, and desk and column names.

Create IAM roles

For this put up, we create two IAM roles:

• custom_AmazonBedrockExecutionRoleForAgents:
  • Connect the next AWS managed insurance policies to the function:
    • 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 function:
    • 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 data base

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

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

3. On the Present Data Base particulars web page, present the next info:
   1. Enter a reputation and elective description.
   2. For Question engine, choose Amazon Redshift.
   3. For IAM permissions, choose Use an present service function 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 listing.
      4. On the Configure question engine web page, present the next info:
         
      5. Present desk and column descriptions. The next is an instance.
         
      6. Select Create Data Base.
4. After you create the data base, open the Redshift question editor and grant permissions for the function to entry Redshift tables by working 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 info, seek advice from arrange your question engine and permissions for making a data base with structured knowledge retailer.

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

Ensure the standing reveals as Full earlier than shifting to the following steps.

• When the sync is full, select Take a look at Data Base.
• Choose Retrieval and response technology: knowledge sources and mannequin and select Claude 3.5 Haiku for the mannequin.
• Enter a query about your knowledge and be sure you 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 info:
   1. Enter a reputation and elective description.
   2. For Agent useful resource function, choose Use an present service function and select custom_AmazonBedrockExecutionRoleForAgents.

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

You might be an IoT system monitoring and alerting agent. 
You will have entry to the structured knowledge containing studying, upkeep, threshold knowledge for IoT gadgets. 
You reply questions on system studying, upkeep schedule and thresholds. 
You too can create case through Agentforce. 
Once 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 info to agentforce to create case. The data despatched to agentforce ought to embrace system readings similar to system id, error code. 
It also needs to embrace the edge values associated to the product related to the system similar to min temperature, max temperature and connectivity, 
In response to your name to agentforce simply return the abstract of the data supplied with all of the attributes supplied. 
Don't omit any info within the response. Don't embrace the phrase escalated in agent.

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

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

8. Select Save after which select Put together the agent.
9. Take a look at 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 info:
    1. Enter an alias identify 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. Be aware down the agent ID, which you’ll use in subsequent steps.
13. Be aware down the alias ID and agent ID, which you’ll use in subsequent steps.

Create a Lambda perform

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

1. On the Lambda console, select Capabilities within the navigation pane.
2. Select Create perform.
3. Configure the perform 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", # exchange with the area identify out of your account
)
def lambda_handler(occasion, context):
    logger.information(occasion)
    physique = occasion['body']
    input_text = json.hundreds(physique)['inputText']
    agent_id = 'XXXXXXXX' # exchange with the agent id out of your account
    agent_alias_id = 'XXXXXXX' # exchange 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' : 'utility/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 required 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. Be aware 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 aspect. 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 info:
   1. Enter a label and identify.
   2. For Authentication Protocol, select Customized.
   3. Select Save.

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

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

Now you may grant entry to the agent person to entry these credentials.

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

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

You’ll be able to optionally use Salesforce Non-public Join with PrivateLink to offer a safe non-public reference to. This permits crucial knowledge to circulate from the Salesforce surroundings 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 Companies 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 info:
   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:
    put up:
      operationId: call-bedrock-agent
      abstract: Name Bedrock Agent
      description: Name Bedrock Agent
      requestBody:
        description: enter
        required: true
        content material:
          utility/json:
            schema:
              $ref: '#/elements/schemas/enter'
      responses:
        '200':
          description: Profitable response
          content material:
            utility/json:
              schema:
                $ref: '#/elements/schemas/output'
        '500':
          description: Server error
elements:
  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 Hook up with an present motion, present the next info:
   1. For Reference Motion Sort, select API.
   2. For Reference Motion Class, select Exterior Companies.
   3. For Reference Motion, select the Name Bedrock Agent motion that you just configured.
   4. Enter an agent motion label and API identify.
   5. Select Subsequent.

4. Present the next info 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 info.
   2. For Loading Textual content, enter Calling Bedrock Agent.
   3. Below Enter, for Physique, enter Present the enter within the enter Textual content discipline.
   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 info:
   1. For Title, enter Gadget Info.
   2. For Classification Description, enter This subject handles inquiries associated to system and sensor info, together with studying, upkeep, and threshold.
   3. For Scope, enter Your job is simply to offer details about system readings, sensor readings, system upkeep, sensor upkeep, and threshold. Don’t try to handle points exterior of offering system info.
   4. For Directions, enter the next:

If a person asks for system readings or sensor readings, present the data.
If a person asks for system upkeep or sensor upkeep, present the data.
When trying to find system info, 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, similar to “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 data utilizing the Amazon Bedrock agent from the related data base.

Clear up

To keep away from further prices, delete the assets that you just created while you not want them:

1. Delete the Amazon Bedrock data base:
   1. On the Amazon Bedrock console, select Data Bases within the navigation pane.
   2. Choose the data 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 perform:
   1. On the Lambda console, select Capabilities within the navigation pane.
   2. Choose the perform 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 put up, we described an structure that demonstrates the facility of mixing AI providers on AWS with Agentforce. Through the use of Amazon Bedrock Brokers and Amazon Bedrock Data Bases for contextual understanding by means of RAG, and Lambda features and API Gateway to bridge interactions with Agentforce, companies can construct refined, 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 put up, we’ll present you how you can construct the asynchronous integration sample from Agentforce to Amazon Bedrock utilizing Salesforce Occasion Relay.

To get began, see Change into an Agentblazer Innovator and seek advice from How Amazon Bedrock Brokers works.

Concerning the authors

Yogesh Dhimate is a Sr. Associate Options Architect at AWS, main expertise partnership with Salesforce. Previous to becoming a member of AWS, Yogesh labored with main corporations together with Salesforce driving their trade 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 Software Integration and Cloud Migrations throughout A number of Cloud suppliers. He works with AWS Companions to construct options on AWS that our joint prospects 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 Associate Options Architect at AWS. He creates joint options with strategic ISV companions to ship worth to prospects. When not at work, he’s busy exploring NY city and the climbing trails that encompass it, and occurring bike rides.

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

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

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