In the rapidly evolving landscape of AI-driven automation, serverless computing stands as a transformative force, enabling developers to craft scalable and efficient applications without the constraints of managing infrastructure. Amazon Bedrock, a fully managed service from AWS, unlocks the potential of serverless computing
and advanced AI models, empowering the creation of intelligent workflows led by AI agents. In this blog, we will delve into the course on Serverless Agentic Workflows with Amazon Bedrock and share coding examples to inspire your journey.

What is Amazon Bedrock?

Unlock the potential of Amazon Bedrock, a fully managed service that connects developers to a diverse range of foundation models (FMs) from top AI providers like AI21 Labs, Anthropic, Stability AI, and Amazon Titan. Thanks to its serverless environment, Bedrock allows you to effortlessly build and scale AI-driven applications without the hassle of infrastructure management. Focus on innovation and creativity while Bedrock takes care of the technical complexities.

Enhance your workflows with Serverless Agentic workflow, allowing you to automate intricate tasks using intelligent AI agents. These versatile agents can seamlessly interact with external systems, make informed decisions, invoke APIs, and pull data when necessary. Experience the future of productivity by harnessing the power of AI to elevate your projects.

Key Concepts from the Course

The course "Serverless Agentic Workflows with Amazon Bedrock" focuses on building intelligent workflows using Amazon Bedrock. Here are the main lessons covered in the course:

Creating Your First Serverless Agent:

Learn to initialize an AI agent and integrate it with your workflows.

Connecting to External Services:

Make the agent interact with real-world systems, such as CRMs or databases.

Equipping the Agent with a Code Interpreter:

Enable the agent to perform complex calculations and make data-driven decisions.

Implementing Guardrails:

Add security and ethical guardrails to control the agent’s behavior.

Connecting to Support Documents:

Use Retrieval-Augmented Generation (RAG) to allow your agent to query documents and resolve issues autonomously.
Let’s break down these lessons with coding examples!

1. Creating Your First Serverless Agent

In this section, we’ll initialize an AI agent using Amazon Bedrock. The agent can be used to handle tasks like customer support, product recommendation, or simple Q&A.

Here’s how you can set up your first serverless agent;

Prerequisites

• AWS account
• Amazon Bedrock service access
• Basic knowledge of Python Let's initialize an AI Agent

import boto3

# Initialize the Amazon Bedrock client
client = boto3.client('bedrock')

# Set up the parameters for the agent
parameters = {
    'modelId': 'AmazonTitan',
    'input': 'Hello, how can I assist you today?'
}

# Call the model to initialize the agent
response = client.invoke_model(**parameters)

# Output the agent's response
print(response['output'])

This code effectively initializes an Amazon Titan model by utilizing the invoke_model function. It sends a straightforward query: "Hello, how can I assist you today?" The printed response from the agent illustrates its capability to generate dynamic and relevant answers, which showcases the model's potential for providing useful interactions.

2. Connecting to External Services

To make the AI agent more powerful, we can integrate it with external services like a CRM or ticketing system. For example, we can connect to a database to fetch customer records.

Fetching Data from a Database

import boto3

# Set up DynamoDB client
dynamodb = boto3.client('dynamodb')

def fetch_customer_info(customer_id):
    response = dynamodb.get_item(
        TableName='CustomerRecords',
        Key={'customer_id': {'S': customer_id}}
    )
    return response.get('Item', {})

# Fetch customer info
customer_id = '12345'
customer_info = fetch_customer_info(customer_id)

print(customer_info)

In this example, the code connects to a DynamoDB table called CustomerRecords and fetches information for a specific customer. This integration allows the agent to retrieve and use real-time customer data to make informed decisions.

3. Equipping the Agent with a Code Interpreter

The agent can be equipped to execute code or perform calculations, which helps it make data-driven decisions.

# Initialize the Bedrock client
client = boto3.client('bedrock')

# Code for calculating product prices
def calculate_price(base_price, discount):
    return base_price - (base_price * discount / 100)

# Implement logic with agent
def agent_with_code_interpreter():
    base_price = 100  # Sample base price
    discount = 10     # Sample discount percentage
    final_price = calculate_price(base_price, discount)
    return f"The final price after a {discount}% discount is: ${final_price}"

# Call the agent
response = client.invoke_model(
    modelId='AmazonTitan',
    input=agent_with_code_interpreter()
)

print(response['output'])

Here, the agent performs a simple price calculation, reducing a base price by a specified discount percentage. This demonstrates how agents can use custom code logic to enhance their decision-making ability.

4. Implementing Guardrails

Guardrails ensure that the AI agent behaves responsibly. For example, you can add logic to prevent the agent from revealing sensitive information or making unethical decisions.

def guardrails(agent_output):
    prohibited_keywords = ['password', 'credit card']
    for keyword in prohibited_keywords:
        if keyword in agent_output:
            return "Sorry, I cannot provide that information."
    return agent_output

# Example agent output
agent_output = "Here is your password: 12345"

# Apply guardrails
safe_output = guardrails(agent_output)
print(safe_output)

In this code, the agent’s output is filtered for sensitive information like passwords. If any such information is detected, the agent responds with a safe message.

5. Connecting to Support Documents with Retrieval-Augmented Generation (RAG)

Using RAG, your agent can query a database of support documents to retrieve the most relevant information when a customer asks a question.

# Initialize the Bedrock client
client = boto3.client('bedrock')

# Define a function to query support documents
def query_support_documents(query):
    response = client.retrieve_documents(
        query=query,
        document_store='SupportDocsStore'
    )
    return response['documents'][0]  # Return the first relevant document

# Query the support documents
query = "How do I reset my password?"
document = query_support_documents(query)

print(document)

In this code, the agent queries a document store (e.g., a collection of FAQ articles) to find the best document that answers the user's question about resetting a password.

Conclusion

This blog discusses building a Serverless Agentic workflow with Amazon Bedrock. We highlight key course lessons and provide coding examples showing how AI agents can interact with external services, perform calculations, and retrieve information. Amazon Bedrock combines serverless architecture with AI models, making creating scalable applications for customer support and document processing easier.

For those wanting to learn more, the Serverless Agentic Workflows with Amazon Bedrock course offers a step-by-step guide on creating and managing these workflows. It covers automating customer interactions, integrating with external services, and establishing ethical guidelines for AI agents.

References:

• Serverless Agentic Workflows with Amazon Bedrock Course: https://learn.deeplearning.ai/courses/serverless-agentic-workflows-with-amazon-bedrock/lesson/1/introduction. -Amazon bedrock agents: https://aws.amazon.com/bedrock/agents/