|
|
Functions can seamlessly execute complex tasks across various platforms and data sources using diverse techniques. Several months ago, our team of brokers worked together effectively. Presently, we’re unveiling a sneak peek of two revolutionary, fully managed features:
Brokers can now maintain a comprehensive record of conversations with each customer, enabling them to deliver a seamless, adaptive experience, particularly for complex, multi-step tasks such as user-facing interactions and business automation solutions like booking flights or processing insurance claims?
Brokers can now leverage the power of dynamic code generation within a secure, sandboxed environment, empowering them to tackle complex challenges such as data analysis, information visualization, text processing, equation solving, and optimization problems. We also provided the capability to attach documents to agents for enhanced usability.
These new capabilities show great promise in enhancing our understanding of additional elements.
By leveraging reminiscence retention, you can develop AI-powered brokers that learn and evolve to cater to each customer’s unique needs and preferences over time, fostering personalized experiences and long-term relationships. By maintaining a consistent recall, brokers can seamlessly pick up where clients left off, ensuring a smooth continuity of conversations and workflows, especially for complex, multi-step tasks.
What are your travel dates? We offer flexible booking options to accommodate any schedule changes. Due to its ability to preserve memories, the agent can be trained on user preferences, leveraging this data to efficiently process subsequent booking requests and provide a personalized, eco-friendly experience. By analyzing a customer’s preferences, the system can intuitively recommend a suitable seat or menu option similar to their previous choices.
By leveraging remembrance-based memory retention strategies, businesses can enhance their contextual understanding and streamline process automation with greater ease. With the advent of advanced technology, a dedicated agent empowered by an organization can now seamlessly track and analyze customer feedback across multiple touchpoints, eliminating the need for cumbersome custom integrations.
Each customer’s dialogue history and context are safely stored beneath a unique memory identifier (ID), ensuring complete isolation between consumers. As user engagement and recall increase with effective reminiscence retention, the development of intuitive broker platforms becomes more feasible, enabling the creation of cohesive, adaptive, and personalized experiences that continually improve and refine themselves over time. What’s the original text you’d like me to improve?
I navigate to the “Automation” tab within the Dynamics 365 platform, select the “Process Automation” option from the left-hand side menu, and initiate the process of building a new agent by clicking on the corresponding button.
As a professional editor, I would rewrite the sentence to:
“For the agent, I exploited because they identified with this as a description:”
Assist guide a flight.
Within the AI-driven agent builder, I select the avatar option and input the following instructions:
Knowing the departure airport, destination airport, and exact takeoff time ensures smooth navigation of a flight.
Within my scope, I empower agents to request clarifying questions to ensure prompt receipt of all necessary information. When submitting a request to guide a flight, please ensure that all required information is provided, including the origin and destination, as well as the date and time of departure.
Within the new part, I permit reminiscence to generate and store a session summary at the end of each session, utilizing a default retention period of 30 days.
As a result, I added a motion group to monitor and steer flight trajectories. I improve as “Identify” and this description remains unchanged?
Retrieve and display available air travel options between specified destinations on a specific date, with the option to select a preferred flight.
You then select to outline the motion group with performance details afterwards to create a new Lambda function. The Lambda performs the implementation of enterprise-level logic for all features within this motion group.
Two new features are added to this motion group: a function that searches for available flights, as well as another that provides guidance on navigating through air travel routes.
The core responsibility is to
Obtain flight options for a specific travel day across a defined origin and destination.
All parameters of these programs are mandatory and of a string nature. Parameters named for convenience, with descriptions that clarify their purpose.
Origin IATA airport codeVacation spot IATA airport code 20230112
The performance is strong and makes use of this description effectively.
Please provide the necessary details for guiding a flight at a specific date and time between two locations: departure city and airport, arrival city and airport, desired flight date and time, and any additional requirements or preferences you may have.
Please provide the original text you’d like me to edit in a different style as a professional editor. The revised text reads:
Parameters:
– Origin IATA airport code
– Vacation spot IATA airport code
– 2023-02-15
– 11:45
To complete the development of the agent, I choose.
To access the supply chain code for the Lambda function, I navigate to the motion group and click on settings. Typically, I would leverage this Lambda function to seamlessly integrate with existing systems, mirroring the functionality of a travel booking portal. While developing this reserving system, I utilize this specific code to mimic a booking platform for my agent.
import json
import random
from datetime import datetime, time, timedelta
def convert_params_to_dict(params_list):
params_dict = {}
for param in params_list:
identify = param.get("identify")
worth = param.get("worth")
if identify isn't None:
params_dict[name] = worth
return params_dict
def generate_random_times(date_str, num_flights, min_hours, max_hours):
# Set seed based mostly on enter date
seed = int(date_str)
random.seed(seed)
# Convert min_hours and max_hours to minutes
min_minutes = min_hours * 60
max_minutes = max_hours * 60
# Generate random occasions
random_times = set()
whereas len(random_times) < num_flights:
minutes = random.randint(min_minutes, max_minutes)
hours, minutes = divmod(minutes, 60)
time_str = f"{hours:02d}{minutes:02d}"
random_times.add(time_str)
return sorted(random_times)
def get_flights_for_date(date):
num_flights = random.randint(1, 6) # Between 1 and 6 flights per day
min_hours = 6 # 6am
max_hours = 22 # 10pm
flight_times = generate_random_times(date, num_flights, min_hours, max_hours)
return flight_times
def get_days_between(start_date, end_date):
# Convert string dates to datetime objects
begin = datetime.strptime(start_date, "%Ypercentmpercentd")
finish = datetime.strptime(end_date, "%Ypercentmpercentd")
# Calculate the variety of days between the dates
delta = finish - begin
# Generate a listing of all dates between begin and finish (inclusive)
date_list = [start + timedelta(days=i) for i in range(delta.days + 1)]
# Convert datetime objects again to "YYYYMMDD" string format
return [date.strftime("%Y%m%d") for date in date_list]
def lambda_handler(occasion, context):
print(occasion)
agent = occasion['agent']
actionGroup = occasion['actionGroup']
perform = occasion['function']
param = convert_params_to_dict(occasion.get('parameters', []))
if actionGroup == 'search-and-book-flights':
if perform == 'search-for-flights':
flight_times = get_flights_for_date(param['date'])
physique = f"On {param['date']} (YYYYMMDD), these are the flights from {param['origin_airport']} to {param['destination_airport']}:n{json.dumps(flight_times)}"
elif perform == 'book-flight':
physique = f"Flight from {param['origin_airport']} to {param['destination_airport']} on {param['date']} (YYYYMMDD) at {param['time']} (HHMM) booked and confirmed."
elif perform == 'get-flights-in-date-range':
days = get_days_between(param['start_date'], param['end_date'])
flights = {}
for day in days:
flights[day] = get_flights_for_date(day)
physique = f"These are the occasions (HHMM) for all of the flights from {param['origin_airport']} to {param['destination_airport']} between {param['start_date']} (YYYYMMDD) and {param['end_date']} (YYYYMMDD) in JSON format:n{json.dumps(flights)}"
else:
physique = f"Unknown perform {perform} for motion group {actionGroup}."
else:
physique = f"Unknown motion group {actionGroup}."
# Format the output as anticipated by the agent
responseBody = {
"TEXT": {
"physique": physique
}
}
action_response = {
'actionGroup': actionGroup,
'perform': perform,
'functionResponse': {
'responseBody': responseBody
}
}
function_response = {'response': action_response, 'messageVersion': occasion['messageVersion']}
print(f"Response: {function_response}")
return function_responseThe software developer carefully crafts a program that seamlessly integrates with your system.
What are the available flight options for a journey from London Heathrow Airport (LHR) to Rome Fiumicino Airport (FCO) on July 20th, 2024?
The real estate agent responds with a comprehensive catalog of events. You selected to get extra details about how the agent processed your directions. I would like to know more about how this happened and what kind of information was provided?
As I navigate within the tab, I uncover subtle hints that reveal the agency’s orchestration strategy, providing a window into their thought process. Prior to invoking the Lambda function, the agent had already converted airport names into their corresponding codes (e.g., LHR for London Heathrow and FCO for Rome Fiumicino).
What’s the content of this reminiscence displayed within the newly opened tab? The console employs a specific check reminiscence identifier. To ensure memory isolation for each user in a software application, you can assign a distinct memory identifier to each user.
I would like to review the flight schedule with you?
Guide the one at 6:02pm.
The agent responds with a confirmation of the reservation.
As the conversation concluded and the allotted time elapsed, an abstract of our dialogue was summarily displayed within the tab itself.
You initiate a new conversation by selecting the broom icon, which seems like an unusual starting point. Your inquiry appears unclear, lacking essential context; could you please clarify what’s on your mind?
Can various other air travel options be discovered on the day I am scheduled to depart?
Since you had previously discussed your travel arrangements with us, our agent has a record of the flight reservation you made. The agent requests that I provide confirmation of my flight details. The Lambda performance test is purely simulated, lacking actual data storage; therefore, reserved information remains unrecorded in any database. The flight details were painstakingly extracted from the travel agent’s hazy recollection.
I confirm these values and obtain a list of alternative flights with the same departure and destination points for that day.
Sure, please.
Let’s utilize the agent with the ability to higher display the advantages of reminiscence retention? Before taking action, I need to establish a unique agent alias and model. When invoking an agent, you need to provide the agent’s ID along with its corresponding alias ID, which are both mandatory requirements.
During the agent invocation, a newly created memoryId Harnessing the Power of Reminiscence. When paired with this selection, I gain two distinct benefits:
- The reminiscence retained for that
memoryIdThe AI model (if any) leverages contextual data to refine its output. - An abstract of the dialogue for the present session is retained for that.
memoryIdso that it can be used again in a future session.
Using an AWS SDK, you can retrieve or delete specific memory content. memoryId.
import random
import string
import boto3
import json
DEBUG = False # Allow debug to see all hint steps
DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
AGENT_ID = 'URSVOGLFNX'
AGENT_ALIAS_ID = 'JHLX9ERCMD'
SESSION_ID_LENGTH = 10
SESSION_ID = "".be part of(
random.selections(string.ascii_uppercase + string.digits, ok=SESSION_ID_LENGTH)
)
# A singular identifier for every consumer
MEMORY_ID = 'danilop-92f79781-a3f3-4192-8de6-890b67c63d8b'
bedrock_agent_runtime = boto3.consumer('bedrock-agent-runtime', region_name="us-east-1")
def invoke_agent(immediate, end_session=False):
response = bedrock_agent_runtime.invoke_agent(
agentId=AGENT_ID,
agentAliasId=AGENT_ALIAS_ID,
sessionId=SESSION_ID,
inputText=immediate,
memoryId=MEMORY_ID,
enableTrace=DEBUG,
endSession=end_session,
)
completion = ""
for occasion in response.get('completion'):
if DEBUG:
print(occasion)
if 'chunk' in occasion:
chunk = occasion['chunk']
completion += chunk['bytes'].decode()
return completion
def delete_memory():
attempt:
response = bedrock_agent_runtime.delete_agent_memory(
agentId=AGENT_ID,
agentAliasId=AGENT_ALIAS_ID,
memoryId=MEMORY_ID,
)
besides Exception as e:
print(e)
return None
if DEBUG:
print(response)
def get_memory():
response = bedrock_agent_runtime.get_agent_memory(
agentId=AGENT_ID,
agentAliasId=AGENT_ALIAS_ID,
memoryId=MEMORY_ID,
memoryType="SESSION_SUMMARY",
)
reminiscence = ""
for content material in response['memoryContents']:
if 'sessionSummary' in content material:
s = content material['sessionSummary']
reminiscence += f"Session ID {s['sessionId']} from {s['sessionStartTime'].strftime(DATE_FORMAT)} to {s['sessionExpiryTime'].strftime(DATE_FORMAT)}n"
reminiscence += s['summaryText'] + "n"
if reminiscence == "":
reminiscence = "<no reminiscence>"
return reminiscence
def most important():
print("Delete reminiscence? (y/n)")
if enter() == 'y':
delete_memory()
print("Reminiscence content material:")
print(get_memory())
immediate = enter('> ')
if len(immediate) > 0:
print(invoke_agent(immediate, end_session=False)) # Begin a brand new session
invoke_agent('finish', end_session=True) # Finish the session
if __name__ == "__main__":
most important()I execute the Python script on my personal laptop device. I instruct you to cancel the existing reservation and then schedule a morning flight for a specific date.
Delete reminiscence? (y/n)yReminiscence content material:<no reminiscence>> Guide me on a morning flight on July twentieth, 2024 from LHR to FCO.
You have been booked on a morning flight from London Heathrow Airport (LHR) to Rome's Leonardo da Vinci–Fiumicino Airport (FCO) for July 20th, 2024, departing at 06:44.
After waiting a few minutes, I re-run the script again. The script initiates a fresh session every time it’s executed. This time, I’ll preserve the lingering recollections and peruse the abstract of my earlier dialogue with myself on the very same subject. memoryId. What’s the exact date of your flight? The agent discovers an existing reservation embedded within the memory’s contents, suggesting that this may not be a brand-new session after all.
Delete reminiscence? (y/n)nReminiscence content material:Session ID: MM4YYW0DL2 (July 9, 2024 - 3:35:47 PM to 3:35:58 PM)What was the consumer's intention in booking a morning flight from London Heathrow (LHR) to Rome Fiumicino Airport (FCO) on July 20th, 2024? The travel assistant successfully reserved a morning flight departing London Heathrow (LHR) for Rome's Leonardo da Vinci–Fiumicino Airport (FCO) on July 20th, 2024, at 6:44 am. The efficient assistant promptly secured the desired morning flight for the customer. A passenger booked a morning flight for July 20th, 2024, departing from London Heathrow Airport (LHR) and arriving at Rome Fiumicino Airport (FCO). The travel assistant successfully reserved a 6:44 AM flight for the specified route and date.
> Which date is my flight on? As we previously discussed, I've confirmed the reservation for your morning flight departing from London Heathrow Airport (LHR) to Rome's Leonardo da Vinci–Fiumicino Airport (FCO) on July 20th, 2024. The current status and availability of flights are subject to change. To provide an accurate response, please confirm which specific flight or route you're inquiring about.
Sure, that’s my flight!
By leveraging contextual learning scenarios, recalling prior experiences and habits may enhance monitoring of early interactions and tailor-made solutions for each customer, ultimately delivering a unified experience across all touchpoints.
A concise summary highlights key takeaways from the perspective of both consumers and assistants. While a brief session may occasionally involve some repetition,
Amazon Bedrock brokers now facilitate seamless code interpretation, enabling them to generate and execute code snippets within a secure, sandboxed environment, thereby expanding their capacity to handle complex tasks such as data analysis, visualization, text processing, equation solving, and optimization problems.
Brokers have the ability to process data files of diverse formats, including CSV, XLSX, YAML, JSON, DOCX, HTM, Markdown, TXT, and PDF. Brokers are empowered by code interpretation to create customised charts, thereby enriching the user experience and rendering complex data more comprehensible.
Code interpretation is employed by an agent when the large language model (LLM) detects that it can provide more accurate solutions to a specific issue, as opposed to situations where users intentionally request arbitrary code generation. To ensure safe and secure interactions, each user’s session is equipped with a remote, isolated code execution environment.
Let’s conduct a swift assessment to determine whether this approach could aid agents in navigating complex responsibilities?
I reassign the identical agent from the previous demo session to handle the newly selected opportunity. Within the agent builder, I enable and save.
I quickly assembled the agent and verified its functionality directly in the console. What’s the query?
The sum of the first 10 prime numbers is 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29 = 129.
After a brief pause, I receive a response from the AI assistant.
The sum of the first 10 prime numbers is indeed 129?
That’s correct. Upon examining the remnants, the programmer carefully crafted and executed this Python code to fulfill my inquiry.
import math
def is_prime(n):
if n < 2:
return False
for i in vary(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
primes = []
n = 2
whereas len(primes) < 10:
if is_prime(n):
primes.append(n)
n += 1
print(f"The primary 10 prime numbers are: {primes}")
print(f"The sum of the primary 10 prime numbers is: {sum(primes)}")The agent’s office was a compact space with a desk that took up most of the room. Across an extended period, I aim to gain a comprehensive grasp of the prevailing flight patterns. I initiate the process by adding a fresh task to the same workflow category, ensuring all available flights are aggregated within a specific date range.
What innovative services does the company offer?
Retrieve and display flight schedules for specified origin-destination pairs across various dates within a given time frame, providing users with comprehensive travel options.
Please provide the original text you’d like me to improve, and I’ll do my best to revise it in a different style as a professional editor. PARAMETERS = Names and Descriptions
– Origin IATA airport code
– Vacation spot IATA airport codeThe departure date of the flight is specified in YYYY-MM-DD format. – 20230415
Upon reviewing the Lambda perform code previously shared, you’ll find that it effectively enables this agent’s capabilities.
Now that the agent has developed an approach to extract additional data with a single performer’s name, I request the agent to visualize flight information in a chart. Can they create a concise and clear representation of the essential details?
Flight Schedule Chart: JFK to SEA (Aug 1-10, 2024)
| Day | Morning Flights | Afternoon Flights | Evening Flights |
| --- | --- | --- | --- |
| Aug 1 | 5:30 AM (DL 121), 8:45 AM (UA 211) | 2:15 PM (AS 345), 4:20 PM (AA 901) | 7:00 PM (HA 123), 9:35 PM (WN 567) |
| Aug 2 | 6:10 AM (AA 219), 8:25 AM (DL 134) | 1:50 PM (UA 215), 3:40 PM (AS 341) | 7:30 PM (HA 125), 9:00 PM (WN 571) |
| Aug 3 | 5:15 AM (UA 212), 8:10 AM (DL 131) | 2:30 PM (AS 347), 4:35 PM (AA 905) | 7:20 PM (HA 127), 9:25 PM (WN 575) |
| Aug 4 | 6:40 AM (AA 221), 8:45 AM (DL 138) | 1:15 PM (UA 213), 3:10 PM (AS 343) | 7:50 PM (HA 129), 9:30 PM (WN 579) |
| Aug 5 | 5:00 AM (DL 126), 8:20 AM (UA 214) | 2:45 PM (AS 349), 4:55 PM (AA 907) | 7:40 PM (HA 131), 9:10 PM (WN 583) |
| Aug 6 | 6:50 AM (AA 223), 8:35 AM (DL 142) | 1:30 PM (UA 217), 3:20 PM (AS 345) | 7:25 PM (HA 133), 9:00 PM (WN 587) |
| Aug 7 | 5:45 AM (UA 216), 8:10 AM (DL 137) | 2:15 PM (AS 351), 4:30 PM (AA 909) | 7:35 PM (HA 135), 9:20 PM (WN 591) |
| Aug 8 | 6:20 AM (AA 225), 8:50 AM (DL 144) | 1:45 PM (UA 219), 3:10 PM (AS 347) | 7:15 PM (HA 137), 9:30 PM (WN 595) |
| Aug 9 | 5:20 AM (DL 130), 8:25 AM (UA 218) | 2:40 PM (AS 353), 4:45 PM (AA 911) | 7:50 PM (HA 139), 9:15 PM (WN 599) |
| Aug 10 | 6:35 AM (AA 227), 8:55 AM (DL 148) | 1:20 PM (UA 221), 3:30 PM (AS 349) | 7:40 PM (HA 141), 9:05 PM (WN 603) |
Note: Flight numbers and times are fictional and used only for demonstration purposes.
The agent’s response incorporates an illustrative diagram.
When I click on the link, the image opens directly on my computer.
That’s right. According to the chart, the Lambda simulator produces a daily output of between one and six flights.
Due to the interpretive capabilities of code, permitting brokers to process and extract data from information, we have introduced the ability to integrate documents upon agent invocation. Here is the rewritten text:
I have an Excel file containing a diverse range of flights booked for various dates.
| LHR | FCO | 636 |
| FCO | LHR | 456 |
| JFK | SEA | 921 |
| SEA | JFK | 544 |
When utilizing the clip icon within the check interface, I connect the file and inquire about
What's the hottest route? And the least one?
According to our latest statistics, a total of 5,427 flights have been booked by customers worldwide.
Flight Booking Chart:
Route A 22% | Route B 15%
Route C 30% | Route D 8%
Overall 100% | Overall 100%
Note: The % figures represent the proportion of flights booked for each route, out of a total of 100%.
I can examine the traces to review the Python code employed in extracting information from the file, then correlate it with the agent’s data. I can seamlessly merge multiple files and utilise a wide range of file formats. AWS SDKs offer these options for brokers to leverage record data within their functions.
Anthropic’s Claude offers a preview of reminiscence retention capabilities, showcasing sonnets or haikus (in the styles available through the preview). Code interpretation is provided instantly within the US East (Northern Virginia) region for more efficient development and debugging experiences. The United States, with its major hubs in Virginia, US West (including Oregon), and Europe, centered on Frankfurt.
No additional fees are incurred during the preview process for leveraging memory retention and code interpretation alongside your brokers. When using brokers to access these options, standard model portfolio usage fees are applicable. When reminiscence retention is enabled, you are charged for the AI-powered summarization model utilized during the session. Visit our website for additional details.
To access additional learning resources, visit the… To delve into the intricacies of generative AI and discover how other professionals incorporate this technology into their projects, visit.
—
