Why ChatGPT Won’t Replace the Need for Data Analysts in the Future


Artificial Intelligence (AI) has come a long way in recent years, thanks to groundbreaking research and technological advancements. One of the most notable AI innovations is ChatGPT, a large language model developed by OpenAI. With its advanced capabilities in natural language processing and understanding, ChatGPT has significantly influenced many industries, including data analysis.

However, despite the impressive performance of ChatGPT, it is crucial to understand that it will not replace the need for data analysts in the future. In this blog post, we will explore the reasons behind this assertion and discuss the unique value that data analysts bring to the table.

  1. Human Insight and Intuition

While ChatGPT is highly proficient in understanding and processing language, it lacks the human intuition and insight that data analysts possess. Data analysts are not only trained to interpret complex patterns and trends but also to provide context and reasoning behind the data. This level of understanding goes beyond simply recognizing patterns and requires a deep knowledge of the domain and the ability to make informed decisions based on that understanding. ChatGPT, as powerful as it is, cannot replicate the human touch that data analysts provide.

  1. The Art of Asking the Right Questions

Data analysts are experts in asking the right questions to drive actionable insights. They know how to tailor their approach to suit the specific needs of their clients, and they understand the importance of asking probing questions to uncover hidden trends and opportunities. ChatGPT, as an AI language model, is inherently limited in this regard, as it can only respond to the questions it is given, rather than proactively identifying areas of interest or potential pitfalls.

  1. Domain-Specific Expertise

Data analysts often specialize in specific industries or domains, bringing a wealth of knowledge and expertise to their work. They are familiar with the unique challenges and trends that characterize their chosen fields and are well-equipped to provide tailored solutions to these problems. While ChatGPT can process and analyze vast amounts of information, it lacks the domain-specific expertise that makes data analysts invaluable assets to their organizations.

  1. Data Quality and Data Preparation

A large part of a data analyst’s job involves cleaning, preparing, and transforming raw data into a format that can be easily analyzed. This process requires a deep understanding of the data, its sources, and its limitations, as well as the ability to identify and address any inconsistencies or inaccuracies. ChatGPT, on the other hand, is not designed to handle this crucial aspect of data analysis. It is, therefore, necessary to have data analysts in place to ensure that the data being used is accurate, relevant, and reliable.

  1. Ethical Considerations

Data analysts are trained to consider the ethical implications of their work, ensuring that data is collected, analyzed, and presented in a responsible and unbiased manner. This ethical awareness is particularly important given the increasing concerns surrounding data privacy and the potential for misuse of information. ChatGPT, while an impressive tool, is not equipped to navigate these complex ethical issues and cannot replace the thoughtful, human-driven approach that data analysts bring to their work.


Although ChatGPT has undoubtedly revolutionized the way we interact with and process data, it is essential to recognize that it cannot replace the need for data analysts in the future. Data analysts offer a unique blend of human insight, domain-specific expertise, and ethical awareness that simply cannot be replicated by an AI language model. By working together, ChatGPT and data analysts can complement each other’s strengths and drive more efficient and effective data-driven decision-making processes.

This blogpost was created with help from ChatGPT Pro.

Empowering Individuals with ADHD: The Benefits of ChatGPT


Attention Deficit Hyperactivity Disorder (ADHD) is a neurodevelopmental disorder that affects millions of people worldwide. Characterized by difficulty paying attention, impulsivity, and hyperactivity, it can make everyday tasks and routines a challenge. In today’s fast-paced world, where there is an abundance of information and distractions, managing ADHD symptoms can be even more daunting.

Enter ChatGPT, an artificial intelligence language model developed by OpenAI. This cutting-edge technology has the potential to assist people with ADHD in a variety of ways. In this blog post, we will explore how ChatGPT can empower individuals with ADHD by enhancing organization, improving focus, and facilitating communication.

  1. Enhancing Organization

One of the most common challenges faced by people with ADHD is staying organized. ChatGPT can help in several ways:

  • Task management: ChatGPT can serve as a digital assistant, helping users create and manage to-do lists, set reminders, and prioritize tasks.
  • Structuring information: By providing clear and concise summaries of lengthy articles or documents, ChatGPT can make it easier for individuals with ADHD to process and retain information.
  • Habit formation: ChatGPT can be programmed to provide consistent reminders and positive reinforcement, assisting users in establishing and maintaining healthy habits and routines.
  1. Improving Focus

Maintaining focus can be difficult for individuals with ADHD, but ChatGPT can help users stay on track:

  • Filtering distractions: ChatGPT can be used to monitor incoming messages and notifications, only alerting users to high-priority items, allowing them to remain focused on the task at hand.
  • Mindfulness and relaxation techniques: ChatGPT can provide guided meditation and breathing exercises to help users reduce anxiety, improve focus, and achieve a calmer state of mind.
  • Customized focus strategies: ChatGPT can offer personalized suggestions and techniques for improving focus based on users’ preferences and needs.
  1. Facilitating Communication

People with ADHD may struggle with communication, whether it’s expressing themselves clearly or interpreting complex information. ChatGPT can help bridge these gaps:

  • Clear expression: ChatGPT can assist users in organizing their thoughts and presenting them in a clear, coherent manner, making communication more effective.
  • Active listening: By summarizing conversations, ChatGPT can help users maintain focus during discussions, ensuring they are better able to engage and respond.
  • Emotional support: ChatGPT can offer non-judgmental listening and encouragement, providing emotional support to users who may feel overwhelmed or isolated due to their ADHD.
  1. Capturing Creativity and Overcoming “Blank Page Syndrome”

People with ADHD often experience bursts of creativity, but may struggle to capture and develop these ideas due to challenges with focus and organization. Additionally, facing a blank page can be daunting for anyone, but particularly for individuals with ADHD who might struggle with initiating tasks. ChatGPT can support users in these areas:

  • Idea capturing: ChatGPT can serve as a readily available tool to record and store creative ideas as they arise. Users can easily input their thoughts, knowing that ChatGPT will save and organize them for future reference.
  • Idea development: ChatGPT can help users expand on their creative ideas by offering suggestions, asking thought-provoking questions, and providing relevant information or resources to fuel their brainstorming process.
  • Overcoming “blank page syndrome”: ChatGPT can help users break through the initial barrier of starting a project by providing writing prompts, outlines, or even drafting a brief introduction. By giving users a starting point, ChatGPT helps mitigate the anxiety and procrastination often associated with beginning a task.


ChatGPT offers valuable tools that can help individuals with ADHD better manage their symptoms and improve their daily lives. By enhancing organization, improving focus, facilitating communication, capturing creativity, and overcoming the challenges of starting with a blank page, this AI-powered technology can empower people with ADHD to thrive in today’s fast-paced world. As we continue to refine and develop ChatGPT, the potential applications and benefits for individuals with ADHD and other neurodevelopmental disorders will only continue to grow.

This blogpost was created with help from ChatGPT Pro.

Integrating OpenAI with Power BI Paginated Reports using Azure Functions

Introduction: Power BI Paginated Reports are ideal for creating highly formatted, pixel-perfect layouts optimized for printing or PDF generation. By integrating OpenAI with Power BI Paginated Reports using Azure Functions, you can enhance your reports with AI-generated insights and content. This blog post provides a step-by-step guide on how to integrate OpenAI with Power BI Paginated Reports using Azure Functions and an intermediary SQL Server database.


  • An OpenAI API key
  • An Azure account
  • Power BI Report Builder
  • Basic knowledge of Power BI Paginated Reports, Azure Functions, and C#

Step 1: Create a SQL Server database

  1. Set up a SQL Server database or use an existing one.
  2. Create a new table to store the AI-generated content:
CREATE TABLE OpenAI_Responses (
GeneratedText NVARCHAR(MAX),
DateGenerated DATETIME

Step 2: Create an Azure Function to call the OpenAI API and store the AI-generated content in the SQL Server database

  1. Set up an Azure Function App with an HTTP trigger and follow the instructions to create a new function.
  2. Add the necessary NuGet packages to call the OpenAI API (e.g., OpenAI) and connect to SQL Server (e.g., System.Data.SqlClient).
  3. Modify the Azure Function code to call the OpenAI API, and insert the AI-generated content into the SQL Server table.
using System.Data.SqlClient;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using OpenAI;

public static class OpenAIIntegrationFunction
public static async Task<IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
log.LogInformation("C# HTTP trigger function processed a request.");

// Get the 'prompt' parameter from the query string
string prompt = req.Query["prompt"];

// Use OpenAI API Key
string openaiApiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");

// Initialize the OpenAI API client
var apiClient = new OpenAIApiClient(apiKey: openaiApiKey);

// Set up the completion request
var completions = await apiClient.Completions.CreateAsync(
engine: "text-davinci-002",
new CompletionRequest
Prompt = prompt,
MaxTokens = 50,
N = 1,
Stop = null,
Temperature = 0.7,

string generated_text = completions.Choices[0].Text.Trim();

// Replace with your SQL Server connection string
string connectionString = "your_sql_server_connection_string";

using (SqlConnection connection = new SqlConnection(connectionString))
using (SqlCommand command = new SqlCommand("INSERT INTO OpenAI_Responses (Prompt, GeneratedText, DateGenerated) VALUES (@Prompt, @GeneratedText, @DateGenerated)", connection))
command.Parameters.AddWithValue("@Prompt", prompt);
command.Parameters.AddWithValue("@GeneratedText", generated_text);
command.Parameters.AddWithValue("@DateGenerated", DateTime.UtcNow);

await command.ExecuteNonQueryAsync();

return new OkObjectResult("Data saved to the database.");

Copy and paste this code into your Azure Function App. Replace the your_sql_server_connection_string placeholder with your actual SQL Server connection string. This code assumes you have already set up an OpenAI API key as an environment variable within your Azure Function App.

  1. Save the function and test it to ensure it inserts the AI-generated content into the SQL Server table.

Step 3: Create a Power BI Paginated Report

  1. Open Power BI Report Builder.
  2. Create a new report or open an existing one.
  3. Add a new “Parameter” to the report:
    • In the “Report Data” pane, right-click “Parameters” and click “Add Parameter.”
    • Name the parameter “Prompt.”
    • Set the data type to “Text.”
    • Provide a default value or leave it blank.
  4. Add a “Textbox” to the report and set its value to the “Prompt” parameter: =Parameters!Prompt.Value

Step 4: Connect the Power BI Paginated Report to the SQL Server database

  1. In the “Report Data” pane, right-click “Data Sources” and click “Add Data Source.”
  2. Choose “Microsoft SQL Server” as the connection type and provide a name for the data source.
  3. In the “Connection string” field, enter your SQL Server connection string.
  4. Click “OK” to add the data source.
  5. In the “Report Data” pane, right-click “Datasets” and click “Add Dataset.”
  6. Choose the SQL Server data source you just created and click “Query Designer.”
  7. In the “Query Designer,” enter a SQL query to fetch the latest AI-generated content for the given prompt:
SELECT TOP 1 GeneratedText
FROM OpenAI_Responses
WHERE Prompt = @Prompt
ORDER BY DateGenerated DESC

8. Add the “Prompt” parameter to the query by clicking

“Add Parameter” in the “Query Designer.” 9. Close the “Query Designer” and click “OK” to add the dataset.

  1. Add a “Textbox” to the report and set its value to the AI-generated text: =First(Fields!GeneratedText.Value, "Dataset1")

Conclusion: You now have a Power BI Paginated Report that displays AI-generated content based on the prompt parameter. When the report is run, it will retrieve the latest AI-generated content for the given prompt from the SQL Server database and display it in the report. To update the AI-generated content in the SQL Server database, you can manually call the Azure Function with the specified prompt, or you can create a separate application to automate this process. The Azure Function will then call the OpenAI API, generate the text, and insert it into the SQL Server table.

This approach allows you to leverage the Power BI Paginated Report’s native support for SQL Server as a data source while still incorporating AI-generated content from the OpenAI API. It involves additional steps and requires an intermediary database, but it provides a viable solution for integrating OpenAI with Power BI Paginated Reports

This blogpost was created with help from ChatGPT Pro and Paginated Report Bear.

Leveraging OpenAI for Automated Data Storytelling in Power BI


Automated data storytelling is a powerful way to transform complex data visualizations into meaningful narratives. By leveraging OpenAI’s natural language generation capabilities, you can create engaging and informative stories based on your Power BI data visualizations. In this blog post, we’ll discuss the importance of automated data storytelling and guide you through the process of using OpenAI to generate narratives and summaries for your Power BI reports.

Note – Please be aware that this solution involves interacting with OpenAI’s API. I encourage users to familiarize themselves with OpenAI’s data usage policy (https://platform.openai.com/docs/data-usage-policy) and take necessary precautions to ensure the privacy and security of their data.

  1. The Importance of Automated Data Storytelling

Data visualizations in Power BI enable users to analyze and gain insights from their data. However, interpreting these visualizations can be challenging, especially for users without a background in data analysis. Automated data storytelling bridges this gap by:

  • Making data insights accessible: Narratives help users understand the context and significance of the data, making insights more accessible to a broader audience.
  • Enhancing decision-making: Clear and concise narratives can help users grasp the implications of the data, leading to better-informed decisions.
  • Saving time and resources: Generating data stories automatically reduces the time and effort required to create manual reports and analyses.
  1. Prerequisites and Setup

Before we begin, you’ll need the following:

  • Power BI data visualizations: Ensure that you have a Power BI report or dashboard with data visualizations that you’d like to generate narratives for.
  • OpenAI API key: Sign up for an OpenAI API key if you haven’t already. You’ll use this to access OpenAI’s natural language generation capabilities. Visit https://beta.openai.com/signup/ to sign up.
  • A development environment: You can use any programming language and environment that supports HTTP requests. For this tutorial, we’ll use Python and the requests library.
  1. Accessing Power BI Data

In order to generate narratives based on your Power BI data visualizations, you’ll first need to extract the data from the visualizations. You can do this using the Power BI API. Follow the instructions in the “Accessing Power BI Data” section of our previous blog post on creating a Power BI chatbot to set up the necessary API access and create a Python function to query the Power BI API: https://christopherfinlan.com/?p=1921

  1. Generating Narratives with OpenAI

Once you have access to your Power BI data, you can use OpenAI’s API to generate narratives based on the data. Create a Python function to send data to the OpenAI API, as demonstrated in the “Building the Chatbot with OpenAI” section of our previous blog post: https://christopherfinlan.com/?p=1921

  1. Crafting Data Stories

To create data stories, you’ll need to design prompts for the OpenAI API that effectively convey the context and purpose of the data visualizations. The prompts should include relevant data points, visualization types, and any specific insights you’d like the narrative to highlight. Here’s an example of a prompt for a sales report:

openai_prompt = f"""
Create a narrative based on the following sales data visualization:

- Data: {sales_data}
- Visualization type: Bar chart
- Time period: Last 12 months
- Key insights: Top 3 products, monthly growth rate, and seasonal trends

narrative = chat_with_openai(openai_prompt)

Remember to replace {sales_data} with the actual data you’ve extracted from your Power BI visualization.

  1. Integrating Narratives into Power BI Reports

With the generated narratives, you can enhance your Power BI reports by embedding the narratives as text boxes or tooltips. Although Power BI doesn’t currently support direct integration with OpenAI, you can use the following workaround:

  • Manually copy the generated narrative and paste it into a text box or tooltip within your Power BI report.

For a more automated approach, you can build a custom web application that combines both Power BI data visualizations and generated narratives. To achieve this, follow these steps:

  1. Embed Power BI visuals using Power BI Embedded: Power BI Embedded allows you to integrate Power BI visuals into custom web applications. Follow the official documentation to learn how to embed Power BI reports and dashboards in your web application: https://docs.microsoft.com/en-us/power-bi/developer/embedded/embedding
  2. Create a web application with a user interface: Design a user interface for your web application that displays Power BI visuals alongside the generated narratives. You can use HTML, CSS, and JavaScript to create the user interface.
  3. Fetch narratives using JavaScript: When a user interacts with your Power BI visuals or requests a narrative, use JavaScript to send a request to your OpenAI-powered Python backend. The backend should return the generated narrative, which can then be displayed in your web application.

Here’s a simple example using JavaScript to fetch a narrative from your Python backend:

async function getNarrative() {
    const response = await fetch('http://localhost:5000/narrative', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        body: JSON.stringify({ data: yourData }),

    const responseData = await response.json();
    document.getElementById('narrative-container').innerText = responseData.narrative;

Remember to replace yourData with the data you’ve extracted from your Power BI visualization.


Automated data storytelling enhances the value of Power BI data visualizations by providing users with engaging narratives that help them better understand their data. By leveraging OpenAI’s natural language generation capabilities, you can automatically generate insightful narratives and summaries based on your Power BI visuals. Although direct integration with Power BI is not currently available, you can still utilize OpenAI-generated narratives in your reports or create custom web applications to combine Power BI visuals with automated storytelling.

This blogpost was created with help from ChatGPT Pro.

Excel-based Chatbots Powered by OpenAI API: A Game Changer for Business Automation


The integration of the OpenAI API with Microsoft Excel is revolutionizing the way businesses interact with their data. One of the most exciting developments is the creation of Excel-based chatbots, which have the potential to automate various functions such as:

  1. Customer Service: Automate customer support by creating a chatbot that can handle frequently asked questions, troubleshoot issues, and provide guidance on product usage.
  2. Sales: Develop a sales chatbot that can assist customers in finding the right product, offer personalized recommendations, and even process orders directly from Excel.
  3. HR and Recruitment: Design a chatbot to automate the screening process, answer candidate queries, and schedule interviews.
  4. Inventory Management: Build a chatbot to help users track inventory levels, place orders for restocking, and provide real-time updates on product availability.
  5. Knowledge Management: Create a chatbot that can quickly retrieve information from internal databases, streamlining the process of accessing company data.

In this blog post, we will provide a detailed, step-by-step walkthrough for creating a chatbot within Excel using the OpenAI API. This guide is designed for novice Excel users, with easy-to-follow instructions and ready-to-use code snippets.

Note – Please be aware that this solution involves interacting with OpenAI’s API. I encourage users to familiarize themselves with OpenAI’s data usage policy (https://platform.openai.com/docs/data-usage-policy) and take necessary precautions to ensure the privacy and security of their data.

Step 1: Setting up the OpenAI API

First, sign up for an API key on the OpenAI website (https://beta.openai.com/signup/) and follow the instructions to get started.

Step 2: Creating a Chatbot Interface in Excel

  1. Open a new Excel workbook.
  2. In cell A1, type “User Input”.
  3. In cell B1, type “Chatbot Response”.
  4. Format the cells as desired for better readability.

Step 3: Enable Excel Developer Tab

  1. Click on “File” > “Options” > “Customize Ribbon”.
  2. Check the box next to “Developer” in the right column and click “OK”.

Step 4: Add a Button to Trigger Chatbot

  1. Click the “Developer” tab.
  2. Click “Insert” and select “Button (Form Control)”.
  3. Draw the button below the “User Input” and “Chatbot Response” cells.
  4. Right-click the button, select “Edit Text,” and type “Submit”.

Step 5: Write VBA Code for OpenAI API Integration

  1. Right-click the “Submit” button and click “Assign Macro”.
  2. In the “Assign Macro” window, click “New”.
  3. Copy and paste the following code into the VBA editor:
Option Explicit

Private Sub Submit_Click()
    Dim userInput As String
    Dim chatbotResponse As String
    ' Get user input from cell A2
    userInput = Range("A2").Value
    ' Call OpenAI API to get chatbot response
    chatbotResponse = GetOpenAIResponse(userInput)
    ' Display chatbot response in cell B2
    Range("B2").Value = chatbotResponse
End Sub

Function GetOpenAIResponse(userInput As String) As String
    Dim objHTTP As Object
    Dim apiKey As String
    Dim apiUrl As String
    Dim jsonBody As String
    Dim jsonResponse As String
    Dim json As Object
    ' Set your OpenAI API key here
    apiKey = "your_openai_api_key"
    ' Set OpenAI API endpoint URL
    apiUrl = "https://api.openai.com/v1/chat/completions"
    ' Create JSON request body
    jsonBody = "{""messages"": [{""role"": ""system"", ""content"": ""You are a helpful assistant.""}, {""role"": ""user"", ""content"": """ & userInput & """}], ""max_tokens"": 50, ""n"": 1, ""stop"": ""\n"", ""temperature"": 0.7}"
    ' Create an HTTP object
    Set objHTTP = CreateObject("MSXML2.ServerXMLHTTP.6.0")
    ' Send the request to OpenAI API
    With objHTTP
        .Open "POST", apiUrl, False
        .setRequestHeader "Content-Type", "application/json"
        .setRequestHeader "Authorization", "Bearer " & apiKey
        .send jsonBody
        jsonResponse = .responseText
    End With
    ' Create a JSON parser object
    Set json = CreateObject("MSXML2.DOMDocument.6.0")
    json.LoadXML jsonResponse
    ' Extract chatbot response from JSON and return it
    GetOpenAIResponse = json.SelectSingleNode("//content").Text
End Function

  1. Replace your_openai_api_key with your actual OpenAI API key.
  2. Save the VBA code by clicking the floppy disk icon or pressing Ctrl+S.
  3. Close the VBA editor by clicking the “X” in the top-right corner.

Step 6: Add Microsoft XML Reference for JSON Parsing

  1. Press Alt+F11 to open the VBA editor.
  2. Click “Tools” > “References” in the menu.
  3. Scroll down and check the box next to “Microsoft XML, v6.0” (or the latest version available).
  4. Click “OK” to close the “References” window.

Step 7: Test Your Excel Chatbot

  1. In cell A2, type a question or statement for your chatbot (e.g., “What is the capital of France?”).
  2. Click the “Submit” button.
  3. The chatbot’s response should appear in cell B2.

(Optional) Step 8: Add Context Awareness to Your Excel Chatbot

  1. In your Excel workbook, create a new sheet and rename it to “ConversationHistory”.
  2. In the VBA editor, modify the Submit_Click() subroutine by adding the following lines of code before the line chatbotResponse = GetOpenAIResponse(userInput):
    ' Save user input to ConversationHistory sheet
With Sheets("ConversationHistory")
.Cells(.Cells(.Rows.Count, 1).End(xlUp).Row + 1, 1).Value = "User: " & userInput
End With

3. Modify the GetOpenAIResponse() function by adding a new argument called conversationHistory:

Function GetOpenAIResponse(userInput As String, conversationHistory As String) As String

4. Update the Submit_Click() subroutine to pass the conversation history when calling the GetOpenAIResponse() function. Replace the line chatbotResponse = GetOpenAIResponse(userInput) with the following code:

    ' Get conversation history
Dim conversationHistory As String
conversationHistory = Join(Application.Transpose(Sheets("ConversationHistory").UsedRange.Value), " ")

' Call OpenAI API to get chatbot response
chatbotResponse = GetOpenAIResponse(userInput, conversationHistory)

5. Modify the JSON request body in the GetOpenAIResponse() function to include the conversation history. Replace the line jsonBody = "{""prompt"": ""Chatbot: " & userInput & "\", ""max_tokens"": 50, ""n"": 1, ""stop"": ""\n"", ""temperature"": 0.7}" with the following code:

    ' Create JSON request body with conversation history
jsonBody = "{""prompt"": """ & conversationHistory & " Chatbot: " & userInput & "\", ""max_tokens"": 50, ""n"": 1, ""stop"": ""\n"", ""temperature"": 0.7}"

6. Finally, update the Submit_Click() subroutine to save the chatbot’s response in the “ConversationHistory” sheet. Add the following lines of code after the line Range("B2").Value = chatbotResponse:

    ' Save chatbot response to ConversationHistory sheet
With Sheets("ConversationHistory")
.Cells(.Cells(.Rows.Count, 1).End(xlUp).Row + 1, 1).Value = "Chatbot: " & chatbotResponse
End With

With this optional modification in place, your Excel chatbot will now maintain a conversation history in the “ConversationHistory” sheet, which will be used to provide context-aware responses. The chatbot will be able to give more accurate and relevant answers based on the user’s previous interactions.


You now have a working Excel-based chatbot powered by the OpenAI API. This guide has provided you with a simple, step-by-step approach to creating a chatbot interface within Excel and integrating it with the OpenAI API using VBA code. While this example uses basic functionality, you can expand and adapt the code to create chatbots for various applications, such as customer service, sales, HR, inventory management, and knowledge management. With the power of the OpenAI API and the familiar Excel interface, businesses can create powerful, user-friendly tools to enhance operations and boost productivity.

This blogpost was created with help from ChatGPT Pro.

The Ethics of Utilizing ChatGPT-4 to Write Blog Posts for You

Want to listen to this post instead of reading it? Listen to Virtual Christopher Finlan read this post in its entirety!


As artificial intelligence (AI) continues to advance and integrate itself into our everyday lives, it’s essential to examine the ethical implications that come with using such technology. One of these AI applications, ChatGPT-4, has become increasingly popular for its ability to write coherent and well-structured content on a variety of subjects. This raises several questions regarding the ethics of using ChatGPT-4 to write blog posts for individuals or businesses. In this post, we’ll explore some of the ethical concerns surrounding the use of ChatGPT-4 and discuss potential ways to address these issues.

  1. Authenticity and Honesty

One of the primary ethical concerns when using ChatGPT-4 to write blog posts is the question of authenticity. While AI-generated content can be informative and well-written, it lacks the personal touch that comes from a human author. As readers, we appreciate the unique perspectives and experiences that individuals bring to their writing. By using AI-generated content, we risk losing this sense of authenticity.

To address this concern, it is crucial for users of ChatGPT-4 to be transparent about the authorship of their content. Clearly stating that a blog post is AI-generated maintains honesty with readers and allows them to make informed decisions about the content they consume.

  1. Intellectual Property and Credit

Another ethical concern surrounding the use of ChatGPT-4 is intellectual property and giving credit where it is due. AI-generated content is created by an algorithm and doesn’t have a human author to attribute credit to. This can create confusion regarding who should be credited for the work and may inadvertently lead to plagiarism or misattribution.

It is essential to give proper credit to the AI tool used and acknowledge its role in the content creation process. This not only promotes transparency but also ensures that intellectual property is respected.

  1. Bias and Discrimination

AI algorithms like ChatGPT-4 learn from vast amounts of data, including text that may contain biases or discriminatory language. Consequently, the content generated by ChatGPT-4 might unintentionally perpetuate these biases or discriminatory ideas, leading to ethical concerns.

To address this issue, developers of AI algorithms should work to reduce bias and discrimination in their models. Users of ChatGPT-4 should also review the generated content carefully, ensuring that it does not perpetuate harmful stereotypes or discrimination.

  1. Job Displacement

The use of AI-generated content also raises concerns about job displacement. As ChatGPT-4 becomes more capable of producing quality content, it may lead to a reduction in demand for human writers, resulting in job loss for some individuals.

While AI-generated content can be a valuable tool to assist writers, it should not be seen as a replacement for human creativity and expertise. Maintaining a balance between AI-generated and human-written content can help address job displacement concerns.


In conclusion, the use of ChatGPT-4 to write blog posts presents various ethical challenges that need to be considered. To ensure that AI-generated content is utilized responsibly, it is crucial to be transparent about authorship, give proper credit, actively work to reduce bias, and find a balance between AI-generated and human-written content. By considering these ethical concerns, we can make informed decisions on how to use AI tools like ChatGPT-4 while maintaining our values and commitment to responsible technology use.

This blogpost was created with help from ChatGPT Pro.

Building a Power BI Chatbot with OpenAI: Enhancing Business Intelligence through Conversational AI


Power BI is a widely-used data visualization and business intelligence tool that enables users to analyze and gain insights from their data. By integrating a chatbot powered by OpenAI’s conversational AI capabilities, users can interact with Power BI more intuitively, asking questions, and receiving insights through a conversational interface. In this blog post, we’ll guide you through the process of creating a Power BI chatbot using OpenAI’s API, from setting up the necessary tools to deploying the chatbot for use.

Note – Please be aware that this solution involves interacting with OpenAI’s API. I encourage users to familiarize themselves with OpenAI’s data usage policy (https://platform.openai.com/docs/data-usage-policy) and take necessary precautions to ensure the privacy and security of their data.

  1. Prerequisites and Setup

To start building your Power BI chatbot, you’ll need the following:

  1. Accessing Power BI Data

With your Power BI API access set up, you can now interact with your data. To simplify the process, create a Python function to query the Power BI API:

import requests

def query_power_bi_data(api_url, headers, query):
    response = requests.post(api_url, headers=headers, json=query)
    return response.json()

Replace api_url with the URL of your Power BI report or dataset, and headers with the authentication headers containing your API key.

  1. Building the Chatbot with OpenAI

To create a chatbot using OpenAI’s conversational AI, you’ll use the OpenAI API. First, install the OpenAI Python library:

pip install openai

Next, create a Python function to send user input to the OpenAI API:

import openai

openai.api_key = "your_openai_api_key"

def chat_with_openai(prompt, model="text-davinci-002"):
    response = openai.Completion.create(

    message = response.choices[0].text.strip()
    return message

Replace your_openai_api_key with your OpenAI API key.

  1. Processing User Input and Generating Responses

Now that you have functions for interacting with both Power BI and OpenAI, you can create a function to process user input, generate responses, and return data from Power BI:

def process_user_input(user_input):
    openai_prompt = f"Create a Power BI query for the following user question: {user_input}"
    power_bi_query = chat_with_openai(openai_prompt)

    power_bi_data = query_power_bi_data(api_url, headers, power_bi_query)

    openai_prompt = f"Generate a response to the user's question based on the following Power BI data: {power_bi_data}"
    chatbot_response = chat_with_openai(openai_prompt)

    return chatbot_response
  1. Deploying the Chatbot

With the core functionality in place, you can now deploy your chatbot using a platform like Flask or Django for Python, or

using Node.js with Express, depending on your preferred environment. We’ll use Flask for this example.

First, install Flask:

pip install Flask

Create a simple Flask application to handle user input and return chatbot responses:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/chat', methods=['POST'])
def chat():
    user_input = request.json.get('user_input', '')
    response = process_user_input(user_input)
    return jsonify({'response': response})

if __name__ == '__main__':

Now, run your Flask application:

python app.py

Your Power BI chatbot is now accessible through a RESTful API at the /chat endpoint. You can send POST requests containing user input as JSON, and the chatbot will respond with insights based on your Power BI data.

  1. Integrating the Chatbot with a User Interface

To create a more interactive experience for your users, you can integrate the chatbot with a user interface, such as a web application or a messaging platform like Microsoft Teams or Slack.

For a web application, you can use HTML, CSS, and JavaScript to create a simple chat interface that sends user input to your Flask chatbot endpoint and displays the chatbot’s responses.

Web Application Chat Interface

To create a chat interface for a web application, you’ll need to use HTML, CSS, and JavaScript. Here’s a simple example:

  1. Create an HTML file (e.g., index.html) with the following structure:
<!DOCTYPE html>
<html lang="en">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Power BI Chatbot</title>
    <link rel="stylesheet" href="styles.css">
    <div class="chat-container">
        <div id="chat-output"></div>
        <div class="input-container">
            <input type="text" id="user-input" placeholder="Type your question...">
            <button id="send-button">Send</button>

2. Create a CSS file (e.g., styles.css) to style the chat interface:

body {
    font-family: Arial, sans-serif;
    display: flex;
    justify-content: center;
    align-items: center;
    height: 100vh;
    margin: 0;
    padding: 0;
    background-color: #f5f5f5;

.chat-container {
    width: 500px;
    height: 600px;
    border: 1px solid #ccc;
    background-color: white;
    display: flex;
    flex-direction: column;

#chat-output {
    flex: 1;
    padding: 1rem;
    overflow-y: auto;

.input-container {
    display: flex;
    padding: 1rem;
    border-top: 1px solid #ccc;

#user-input {
    flex: 1;
    border: 1px solid #ccc;
    border-radius: 5px;
    padding: 0.5rem;
    outline: none;

#send-button {
    margin-left: 1rem;
    padding: 0.5rem 1rem;
    background-color: #007bff;
    color: white;
    border: none;
    border-radius: 5px;
    cursor: pointer;

3. Create a JavaScript file (e.g., script.js) to handle user input and communicate with your Flask chatbot API:

const chatOutput = document.getElementById('chat-output');
const userInput = document.getElementById('user-input');
const sendButton = document.getElementById('send-button');

sendButton.addEventListener('click', async () => {
    const userText = userInput.value.trim();

    if (userText.length === 0) {

    chatOutput.innerHTML += `<p><strong>You:</strong> ${userText}</p>`;
    userInput.value = '';

    const response = await fetch('http://localhost:5000/chat', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        body: JSON.stringify({ user_input: userText }),

    const responseData = await response.json();
    chatOutput.innerHTML += `<p><strong>Chatbot:</strong> ${responseData.response}</p>`;
    chatOutput.scrollTop = chatOutput.scrollHeight;

userInput.addEventListener('keyup', (event) => {
    if (event.key === 'Enter') {

There are several options for deploying your web application to, including Microsoft Azure or Heroku. Be sure to check the documentation for the vendor of your choice on how to deploy a web application to their platform.

Integrating the Chatbot with Microsoft Teams

To integrate the chatbot with Microsoft Teams, you can create a custom Microsoft Teams bot using the Microsoft Bot Framework. Here’s a high-level overview of the steps involved:

  1. Register a new bot with Microsoft Bot Framework:
    • Go to the Azure Portal (https://portal.azure.com/) and sign in with your account.
    • Click “Create a resource” and search for “Bot Channels Registration.”
    • Complete the form, providing the necessary information such as bot name, subscription, and resource group. For the “Messaging endpoint,” enter a placeholder URL (e.g., https://your-bot.example.com/api/messages)—you’ll update this later.
  2. Set up a development environment:
  3. Create a simple Microsoft Teams bot:
    • Create a new folder for your bot, navigate to it in your terminal, and run npm init to create a package.json file.
    • Install the necessary dependencies by running npm install botbuilder botbuilder-teams.
    • Create a new file (e.g., index.js) and add the following code to set up a basic bot:
const { BotFrameworkAdapter, MemoryStorage, ConversationState } = require('botbuilder');
const { TeamsActivityHandler } = require('botbuilder-teams');
const restify = require('restify');

const adapter = new BotFrameworkAdapter({
    appId: process.env.MicrosoftAppId,
    appPassword: process.env.MicrosoftAppPassword,

const storage = new MemoryStorage();
const conversationState = new ConversationState(storage);

class TeamsBot extends TeamsActivityHandler {
    constructor(conversationState) {
        this.conversationState = conversationState;

    async onMessage(context) {
        // Process user input and communicate with your Flask chatbot API here.

const bot = new TeamsBot(conversationState);

const server = restify.createServer();
server.listen(process.env.port || process.env.PORT || 3978, () => {
    console.log(`\n${server.name} listening to ${server.url}`);
    console.log('\nGet Bot Framework Emulator: https://aka.ms/botframework-emulator');
    console.log('\nTo talk to your bot, open the emulator select "Open Bot"');

server.post('/api/messages', (req, res) => {
    adapter.processActivity(req, res, async (context) => {
        await bot.run(context);
  1. Update the messaging endpoint in the Azure Portal:
    • Deploy your bot to a hosting provider of your choice (e.g., Azure, Heroku, etc.), and obtain the public URL.
    • Update the “Messaging endpoint” in your bot’s “Bot Channels Registration” in the Azure Portal to point to the /api/messages endpoint on your bot’s public URL.
  2. Add the Microsoft Teams channel:
    • In your bot’s “Bot Channels Registration” in the Azure Portal, navigate to the “Channels” tab.
    • Click “Add a featured channel” and select “Microsoft Teams.”
    • Configure the settings as needed, and save the changes.

Your custom Microsoft Teams bot is now connected to your Flask chatbot API. Users can interact with the bot in Microsoft Teams, and the bot will communicate with your Flask API to provide insights based on your Power BI data.


By integrating OpenAI’s conversational AI capabilities with Power BI, you can create a powerful chatbot that allows users to explore their data and gain insights through a conversational interface. This blog post has demonstrated the steps necessary to build such a chatbot using Python, Flask, and OpenAI’s API. With your chatbot in place, you can enhance your organization’s business intelligence efforts and empower your users to interact with data more intuitively.

This blogpost was created with a LOT of help from ChatGPT Pro.

Enhancing Power BI Data Analysis with OpenAI API: A Follow-Up Guide


In our previous blog post, we walked you through the process of integrating Power BI with OpenAI’s GPT-4 to generate textual insights. This time, we will dive deeper into leveraging the OpenAI API to analyze data in Power BI and enhance your data-driven decision-making process. By incorporating OpenAI’s natural language processing capabilities, you can extract valuable information from textual data and make informed decisions based on your Power BI analysis.


  1. Familiarity with the previous blog post on integrating Power BI with OpenAI
  2. A Power BI Pro or Premium account
  3. OpenAI API Key
  4. Python and required libraries installed (openai, pandas, powerbiclient)

Note – Please be aware that this solution involves interacting with OpenAI’s API. I encourage users to familiarize themselves with OpenAI’s data usage policy (https://platform.openai.com/docs/data-usage-policy) and take necessary precautions to ensure the privacy and security of their data.

Step 1: Fetch and Process Textual Data

Before analyzing textual data with the OpenAI API, you need to fetch and preprocess it. In this example, we will work with customer reviews data. You can import this data into Power BI from various sources like a CSV file, Excel file, or a database.

  1. Import customer reviews data into Power BI and create a dataset.
  2. Clean and preprocess the data as necessary (e.g., removing duplicates, handling missing values, etc.).

Step 2: Update the Python Script to Analyze Textual Data with OpenAI

  1. Open the Python script you created in the previous blog post (e.g., ‘openai_powerbi_integration.py’) and locate the fetch_openai_data function.
  2. Modify the function to accept the text to be analyzed as an input parameter:
def fetch_openai_data(text):

3. Update the OpenAI API call within the function to perform the desired analysis task. For example, you can modify the prompt to perform sentiment analysis:

def fetch_openai_data(text):
    prompt = f"Analyze the sentiment of the following customer review: '{text}'. Is it positive, negative, or neutral?"
    response = openai.Completion.create(
    generated_text = response.choices[0].text.strip()
    return generated_text

Step 3: Analyze Textual Data in Power BI Using the Updated Python Script

  1. In Power BI, create a new column in the customer reviews dataset to store the sentiment analysis results.
  2. Iterate through the customer reviews and call the fetch_openai_data function for each review. Store the sentiment analysis result in the new column:
for index, row in customer_reviews.iterrows():
    text = row["Review_Text"]
    sentiment = fetch_openai_data(text)
    customer_reviews.loc[index, "Sentiment"] = sentiment

Step 4: Visualize the Analyzed Data in Power BI

  1. In Power BI, create a new report using the updated customer reviews dataset.
  2. Design visualizations to display the sentiment analysis results, such as pie charts, bar charts, or word clouds. You can also create filters to allow users to interact with the data and explore specific segments, such as reviews with positive or negative sentiment.
  3. Save and publish the report to share the AI-enhanced insights with your team.


In this follow-up blog post, we demonstrated how to use the OpenAI API to analyze textual data in Power BI, enhancing your data analysis capabilities. By incorporating the power of OpenAI’s natural language

processing into your Power BI dashboard, you can gain deeper insights and make more informed decisions based on your data.

Remember that this is just one example of how you can integrate OpenAI with Power BI for data analysis. You can customize the Python script and the OpenAI prompt to perform other analysis tasks such as topic extraction, keyword identification, or summarization. The possibilities are vast, and with a little creativity, you can unlock the full potential of combining AI and business intelligence tools to drive your organization’s success.

As you continue exploring the integration of OpenAI and Power BI, always keep in mind the ethical considerations and usage guidelines of AI-generated content. Ensure that the generated insights align with your organization’s values and goals while adhering to responsible AI practices.

Learn More

If you’re interested in learning more, here are three example follow-up questions you could ask ChatGPT about the blog post:

  1. In the blog post about using the OpenAI API to analyze data in Power BI, how can I optimize the Python script to handle a large volume of textual data for analysis without exceeding API rate limits or incurring excessive costs?
  2. What are some methods to ensure data privacy and security when analyzing sensitive textual data, such as customer reviews or internal communications, using the OpenAI API and Power BI integration?
  3. Are there any limitations or potential biases in the AI-generated analysis that users should be aware of when interpreting the results and making data-driven decisions based on the Power BI visualizations?

This blogpost was created with help from ChatGPT Pro.

Integrating Power BI with OpenAI: A Comprehensive Guide


As the need for data-driven decision-making grows, integrating artificial intelligence (AI) with business intelligence (BI) tools has become an invaluable asset for businesses. Two popular tools in these fields are Power BI by Microsoft and OpenAI’s GPT-4. In this blog post, we’ll walk you through a detailed process to integrate Power BI with OpenAI, unlocking powerful analytics and AI capabilities for your organization.

Power BI is a suite of business analytics tools that helps you visualize and share insights from your data. OpenAI is a cutting-edge AI research lab that has developed the GPT-4, a large language model capable of understanding and generating human-like text. By integrating Power BI with OpenAI, you can enhance your data analysis and generate insights using AI techniques.

Note – Please be aware that this solution involves interacting with OpenAI’s API. I encourage users to familiarize themselves with OpenAI’s data usage policy (https://platform.openai.com/docs/data-usage-policy) and take necessary precautions to ensure the privacy and security of their data.


  1. A Power BI Pro or Premium account
  2. OpenAI API Key (Sign up for OpenAI’s API service at https://beta.openai.com/signup/)

Step 1: Install Python and Required Libraries

To install Python on your computer, follow these steps:

  1. Visit the official Python website: https://www.python.org/downloads/
  2. You will see the download buttons for the latest Python version available for your operating system (Windows, macOS, or Linux). Click on the appropriate button to download the installer. If you need a different version or want to explore other installation options, click on the “View the full list of downloads” link below the buttons.
  3. Once the installer is downloaded, locate the file in your downloads folder or wherever your browser saves downloaded files.
  4. Run the installer by double-clicking on the file.

For Windows:

  • In the installer, check the box that says “Add Python to PATH” at the bottom. This will allow you to run Python from the command prompt easily.
  • Select the “Customize installation” option if you want to change the default installation settings, or just click on “Install Now” to proceed with the default settings.
  • The installer will install Python and set up the necessary file associations.

For macOS:

  • Follow the installation prompts in the installer.
  • Depending on your macOS version, Python may already be pre-installed. However, it’s usually an older version, so it’s still recommended to install the latest version from the official website.

For Linux:

  • Most Linux distributions come with Python pre-installed. You can check the installed version by opening a terminal and typing python --version or python3 --version. If you need to install or update Python, use your distribution’s package manager (such as apt, yum, or pacman) to install the latest version.

After installation, open a command prompt or terminal and type python --version or python3 --version to ensure that Python has been installed correctly. You should see the version number of the installed Python interpreter.

Now you have Python installed on your computer and are ready to proceed with installing the required libraries and running Python scripts.

2. Install the following Python libraries using pip:

pip install openai pandas powerbiclient
pip install msal

Step 2: Create a Power BI Dataset and Table

  1. Sign in to Power BI service at https://app.powerbi.com/
  2. Navigate to your workspace and click on ‘Datasets + dataflows’ in the left pane.
  3. Click on the ‘+ Create’ button and select ‘Streaming Dataset.’
  4. Choose ‘API’ as the connection type and click ‘Next.’
  5. Provide a name for your dataset, such as ‘OpenAI_Insights,’ and click ‘Create.’
  6. You will receive an API URL and an authentication token. Save these for later use.

Step 3: Create a Python Script to Fetch Data and Push to Power BI

  1. Create a new Python script (e.g., ‘openai_powerbi_integration.py’) and import the required libraries:
import openai
import pandas as pd
from powerbiclient import Report, models
import requests
from msal import PublicClientApplication

2. Set up OpenAI API and Power BI authentication:

# Set up OpenAI API
openai.api_key = "your_openai_api_key"

# Set up Power BI authentication
POWER_BI_CLIENT_ID = "your_power_bi_client_id"
AUTHORITY = "https://login.microsoftonline.com/common"
SCOPE = ["https://analysis.windows.net/powerbi/api/.default"]
app = PublicClientApplication(POWER_BI_CLIENT_ID, authority=AUTHORITY)

result = None
accounts = app.get_accounts()
if accounts:
    result = app.acquire_token_silent(SCOPE, account=accounts[0])

if not result:
    flow = app.initiate_device_flow(scopes=SCOPE)
    result = app.acquire_token_by_device_flow(flow)

powerbi_auth_token = result["access_token"]

Replace your_openai_api_key with your OpenAI API key and your_power_bi_client_id with your Power BI client ID. The script will prompt you to authenticate with Power BI by providing a URL and a device code.

To obtain your Power BI client ID, you need to register an application in the Azure Active Directory (Azure AD) associated with your Power BI account. Here’s a step-by-step guide to help you get your Power BI client ID:

  1. Sign in to the Azure portal: Go to https://portal.azure.com/ and sign in with the account you use for Power BI.
  2. Navigate to Azure Active Directory: Once you’re logged in, click on “Azure Active Directory” from the left-hand menu or find it using the search bar at the top.
  3. Register a new application: In the Azure Active Directory overview page, click on “App registrations” in the left-hand menu, and then click on the “+ New registration” button at the top.
  4. Configure your application:
    • Provide a name for your application (e.g., “PowerBI_OpenAI_Integration”).
    • Choose the supported account types (e.g., “Accounts in this organizational directory only” if you want to restrict access to your organization).
    • In the “Redirect URI” section, choose “Web” and provide a URL (e.g., “https://localhost“). This is just a placeholder and won’t be used for our Python script.
  5. Click on the “Register” button at the bottom to create the application.
  6. Obtain your client ID: After registering your application, you’ll be redirected to the application’s overview page. Here, you’ll find the “Application (client) ID.” This is the Power BI client ID you need for your Python script. Make sure to copy and save it securely.
  7. Grant API permissions:
    • In the application’s main menu, click on “API permissions.”
    • Click on the “+ Add a permission” button and select “Power BI Service.”
    • Choose “Delegated permissions” and check the “Dataset.ReadWrite.All” permission.
    • Click on the “Add permissions” button to save your changes.
  8. Don’t forget to update the Power BI client ID in your Python script!

3. Create a function to fetch data from OpenAI and process it:

def fetch_openai_data(prompt):
response = openai.Completion.create(
generated_text = response.choices[0].text.strip()
return generated_text

4. Create a function to push data to Power BI:

def push_data_to_powerbi(api_url, auth_token, dataframe):
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {auth_token}",
data_json = dataframe.to_json(orient="records")
response = requests.post(api_url, headers=headers, data=data_json)
return response.status_code

5. Use the functions to fetch data from OpenAI and push it to Power BI:

# Define your OpenAI prompt
prompt = "Summarize the key factors affecting the global economy in 2023."

# Fetch data from OpenAI
openai_data = fetch_openai_data(prompt)

# Create a DataFrame with the data
data = {"OpenAI_Insight": [openai_data]}
dataframe = pd.DataFrame(data)

# Push data to Power BI
api_url = "your_power_bi_api_url"
auth_token = powerbi_auth_token
status_code = push_data_to_powerbi(api_url, auth_token, dataframe)

# Print status code for confirmation
print(f"Data push status code: {status_code}")

6. Save and run the Python script:

python openai_powerbi_integration.py

If successful, you should see the status code ‘200’ printed, indicating that the data push was successful.

Step 4: Create a Power BI Report and Visualize Data

  1. Go back to Power BI service and navigate to the ‘OpenAI_Insights’ dataset.
  2. Click on the dataset to create a new report.
  3. In the report editor, create a table or any other visualization type to display the ‘OpenAI_Insight’ data.
  4. Save and publish the report to share insights with your team.


In this blog post, we walked you through the process of integrating Power BI with OpenAI. By following the steps, you can use Power BI to visualize and share insights generated by OpenAI’s GPT-4, enhancing your data analysis capabilities. This integration opens up new possibilities for advanced data-driven decision-making, enabling your organization to stay ahead of the competition.

Remember that this is just a starting point. You can further customize the Python script to fetch and process more complex data from OpenAI, and even create dynamic, real-time dashboards in Power BI to keep your team updated with the latest AI-generated insights.

Learn More

If you’re interested in learning more, here are three example follow-up questions you could ask ChatGPT about the blog post:

  1. How can I customize the OpenAI prompt to generate more specific insights or analyses for my Power BI dashboard?
  2. What are some best practices for visualizing the AI-generated insights in Power BI to create effective and easy-to-understand reports?
  3. Can you provide examples of other use cases where the integration of Power BI and OpenAI can be beneficial for businesses or organizations?

Make sure you provide the context of the blogpost when asking your follow-up questions. Here is an example of how you could ask it:

In the blog post about integrating Power BI with OpenAI, you mentioned creating a Python script to fetch data and push it to Power BI. How can I customize the OpenAI prompt within the script to generate more specific insights or analyses for my Power BI dashboard?

Thanks for reading!

This blogpost was created with help from ChatGPT Pro.