Unlock AWS Price and Utilization insights with generative AI powered by Amazon Bedrock

Managing cloud prices and understanding useful resource utilization could be a daunting process, particularly for organizations with advanced AWS deployments. AWS Price and Utilization Studies (AWS CUR) offers useful knowledge insights, however deciphering and querying the uncooked knowledge could be difficult.

On this submit, we discover an answer that makes use of generative synthetic intelligence (AI) to generate a SQL question from a consumer’s query in pure language. This resolution can simplify the method of querying CUR knowledge saved in an Amazon Athena database utilizing SQL question era, working the question on Athena, and representing it on an internet portal for ease of understanding.

The answer makes use of Amazon Bedrock, a completely managed service that gives a selection of high-performing basis fashions (FMs) from main AI corporations like AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI, and Amazon by means of a single API, together with a broad set of capabilities to construct generative AI functions with safety, privateness, and accountable AI.

Challenges addressed

The next challenges can hinder organizations from successfully analyzing their CUR knowledge, resulting in potential inefficiencies, overspending, and missed alternatives for cost-optimization. We intention to focus on and simplify them utilizing generative AI with Amazon Bedrock.

• Complexity of SQL queries – Writing SQL queries to extract insights from CUR knowledge could be advanced, particularly for non-technical customers or these unfamiliar with the CUR knowledge construction (except you’re a seasoned database administrator)
• Knowledge accessibility – To achieve insights from structured knowledge in databases, customers must get entry to databases, which could be a potential menace to general knowledge safety
• Person-friendliness – Conventional strategies of analyzing CUR knowledge typically lack a user-friendly interface, making it difficult for non-technical customers to reap the benefits of the precious insights hidden inside the knowledge

Resolution overview

The answer that we talk about is an internet utility (chatbot) that permits you to ask questions associated to your AWS prices and utilization in pure language. The appliance generates SQL queries primarily based on the consumer’s enter, runs them towards an Athena database containing CUR knowledge, and presents the leads to a user-friendly format. The answer combines the ability of generative AI, SQL era, database querying, and an intuitive internet interface to offer a seamless expertise for analyzing CUR knowledge.

The answer makes use of the next AWS providers:

 The next diagram illustrates the answer structure.

Determine 1. Structure of Resolution

The info movement consists of the next steps:

1. The CUR knowledge is saved in Amazon S3.
2. Athena is configured to entry and question the CUR knowledge saved in Amazon S3.
3. The consumer interacts with the Streamlit internet utility and submits a pure language query associated to AWS prices and utilization.

Determine 2. Exhibits the Chatbot Dashboard to ask query

4. The Streamlit utility sends the consumer’s enter to Amazon Bedrock, and the LangChain utility facilitates the general orchestration.
5. The LangChain code makes use of the BedrockChat class from LangChain to invoke the FM and work together with Amazon Bedrock to generate a SQL question primarily based on the consumer’s enter.

Determine 3. Exhibits initialization of SQL chain

6. The generated SQL question is run towards the Athena database utilizing the FM on Amazon Bedrock, which queries the CUR knowledge saved in Amazon S3.
7. The question outcomes are returned to the LangChain utility.

Determine 4. Exhibits generated Question within the utility output logs

8. LangChain sends the SQL question and question outcomes again to the Streamlit utility.
9. The Streamlit utility shows the SQL question and question outcomes to the consumer in a formatted and user-friendly method.

Determine 5. Exhibits remaining output introduced on the chat bot webapp together with SQL Question and the Question outcomes

Conditions

To arrange this resolution, you need to have the next stipulations:

Configure the answer

Full the next steps to arrange the answer:

1. Create an Athena database and desk to retailer your CUR knowledge. Make sure that the required permissions and configurations are in place for Athena to entry the CUR knowledge saved in Amazon S3.
2. Arrange your compute setting to name Amazon Bedrock APIs. Be sure you affiliate an IAM function with this setting that has IAM insurance policies that grant entry to Amazon Bedrock.
3. When your occasion is up and working, set up the next libraries which are used for working inside the setting:

pip set up langchain==0.2.0 langchain-experimental==0.0.59 langchain-community==0.2.0 langchain-aws==0.1.4 pyathena==3.8.2 sqlalchemy==2.0.30 streamlit==1.34.0

4. Use the next code to determine a connection to the Athena database utilizing the langchain library and the pyathena Configure the language mannequin to generate SQL queries primarily based on consumer enter utilizing Amazon Bedrock. It can save you this file as cur_lib.py.

from langchain_experimental.sql import SQLDatabaseChain
from langchain_community.utilities import SQLDatabase
from sqlalchemy import create_engine, URL
from langchain_aws import ChatBedrock as BedrockChat
from pyathena.sqlalchemy.relaxation import AthenaRestDialect

class CustomAthenaRestDialect(AthenaRestDialect):
    def import_dbapi(self):
        import pyathena
        return pyathena

# DB Variables
connathena = "athena.us-west-2.amazonaws.com"
portathena="443"
schemaathena="mycur"
s3stagingathena="s3://cur-data-test01/athena-query-result/"
wkgrpathena="major"
connection_string = f"awsathena+relaxation://@{connathena}:{portathena}/{schemaathena}?s3_staging_dir={s3stagingathena}/&work_group={wkgrpathena}"
url = URL.create("awsathena+relaxation", question={"s3_staging_dir": s3stagingathena, "work_group": wkgrpathena})
engine_athena = create_engine(url, dialect=CustomAthenaRestDialect(), echo=False)
db = SQLDatabase(engine_athena)

# Setup LLM
model_kwargs = {"temperature": 0, "top_k": 250, "top_p": 1, "stop_sequences": ["nnHuman:"]}
llm = BedrockChat(model_id="anthropic.claude-3-sonnet-20240229-v1:0", model_kwargs=model_kwargs)

# Create the immediate
QUERY = """
Create a syntactically appropriate athena question for AWS Price and Utilization report back to run on the my_c_u_r desk in mycur database primarily based on the query, then have a look at the outcomes of the question and return the reply as SQLResult like a human
{query}
"""
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

def get_response(user_input):
    query = QUERY.format(query=user_input)
    outcome = db_chain.invoke(query)
    question = outcome["result"].break up("SQLQuery:")[1].strip()
    rows = db.run(question)
    return f"SQLQuery: {question}nSQLResult: {rows}"

5. Create a Streamlit internet utility to offer a UI for interacting with the LangChain utility. Embody the enter fields for customers to enter their pure language questions and show the generated SQL queries and question outcomes. You may identify this file cur_app.py.

import streamlit as st
from cur_lib import get_response
import os

st.set_page_config(page_title="AWS Price and Utilization Chatbot", page_icon="chart_with_upwards_trend", structure="centered", initial_sidebar_state="auto",
menu_items={
        'Get Assist': 'https://docs.aws.amazon.com/cur/newest/userguide/cur-create.html',
        #'Report a bug':,
        'About': "# The aim of this app is that can assist you get higher understanding of your AWS Price and Utilization report!"
    })#HTML title
st.title("_:orange[Simplify] CUR data_ :sun shades:")

def format_result(outcome):
    components = outcome.break up("nSQLResult: ")
    if len(components) > 1:
        sql_query = components[0].substitute("SQLQuery: ", "")
        sql_result = components[1].strip("[]").break up("), (")
        formatted_result = []
        for row in sql_result:
            formatted_result.append(tuple(merchandise.strip("(),'") for merchandise in row.break up(", ")))
        return sql_query, formatted_result
    else:
        return outcome, []

def essential():
    # Get the present listing
    current_dir = os.path.dirname(os.path.abspath(__file__))
    st.markdown("<div class="essential">", unsafe_allow_html=True)
    st.title("AWS Price and Utilization chatbot")
    st.write("Ask a query about your AWS Price and Utilization Report:")

6. Join the LangChain utility and Streamlit internet utility by calling the get_response Format and show the SQL question and outcome within the Streamlit internet utility. Append the next code with the previous utility code:

# Create a session state variable to retailer the chat historical past
    if "chat_history" not in st.session_state:
        st.session_state.chat_history = []

    user_input = st.text_input("You:", key="user_input")

    if user_input:
        strive:
            outcome = get_response(user_input)
            sql_query, sql_result = format_result(outcome)
            st.code(sql_query, language="sql")
            if sql_result:
                st.write("SQLResult:")
                st.desk(sql_result)
            else:
                st.write(outcome)
            st.session_state.chat_history.append({"consumer": user_input, "bot": outcome})
            st.text_area("Dialog:", worth="n".be a part of([f"You: {chat['user']}nBot: {chat['bot']}" for chat in st.session_state.chat_history]), peak=300)
        besides Exception as e:
            st.error(str(e))

    st.markdown("</div>", unsafe_allow_html=True)

if __name__ == "__main__":
    essential()

7. Deploy the Streamlit utility and LangChain utility to your internet hosting setting, resembling Amazon EC2, or a Lambda perform.

Clear up

Except you invoke Amazon Bedrock with this resolution, you received’t incur prices for it. To keep away from ongoing prices for Amazon S3 storage for saving the CUR experiences, you’ll be able to take away the CUR knowledge and S3 bucket. If you happen to arrange the answer utilizing Amazon EC2, be sure to cease or delete the occasion while you’re performed.

Advantages

This resolution presents the next advantages:

• Simplified knowledge evaluation – You may analyze CUR knowledge utilizing pure language utilizing generative AI, eliminating the necessity for superior SQL information
• Elevated accessibility – The online-based interface makes it environment friendly for non-technical customers to entry and acquire insights from CUR knowledge without having credentials for the database
• Time-saving – You may rapidly get solutions to your value and utilization questions with out manually writing advanced SQL queries
• Enhanced visibility – The answer offers visibility into AWS prices and utilization, enabling higher cost-optimization and useful resource administration selections

Abstract

The AWS CUR chatbot resolution makes use of Anthropic Claude on Amazon Bedrock to generate SQL queries, database querying, and a user-friendly internet interface to simplify the evaluation of CUR knowledge. By permitting you to ask pure language questions, the answer removes boundaries and empowers each technical and non-technical customers to realize useful insights into AWS prices and useful resource utilization. With this resolution, organizations could make extra knowledgeable selections, optimize their cloud spending, and enhance general useful resource utilization. We advocate that you simply do due diligence whereas setting this up, particularly for manufacturing; you’ll be able to select different programming languages and frameworks to set it up in response to your choice and wishes.

Amazon Bedrock allows you to construct highly effective generative AI functions with ease. Speed up your journey by following the fast begin information on GitHub and utilizing Amazon Bedrock Information Bases to quickly develop cutting-edge Retrieval Augmented Technology (RAG) options or allow generative AI functions to run multistep duties throughout firm techniques and knowledge sources utilizing Amazon Bedrock Brokers.

Concerning the Creator

Anutosh is a Options Architect at AWS India. He likes to dive deep into his clients’ use circumstances to assist them navigate by means of their journey on AWS. He enjoys constructing options within the cloud to assist clients. He’s keen about migration and modernization, knowledge analytics, resilience, cybersecurity, and machine studying.