Abstract:

As a developer on tech support, one of the most difficult tasks is to identify which part of the code is causing a certain issue and the initial analysis as to how it can be fixed. Let’s leverage the potential of Python along with Generative AI and other open-source tools to accelerate and streamline this process.

Description:

The problem that I am trying to address is the time and effort it takes for a developer or a representative at tech support desks to look at support tickets for doing the initial level of analysis to find out the root cause behind an issue, debugging, and identifying a fix for it. 

If you’re catering to a large codebase, it’s impossible for an individual to know all parts of it. Every issue is new and comes with a new scenario that probably wasn’t considered while writing the code initially. It’s a challenging task for anyone to identify what part of the code might cause the issue, what the issue-causing scenario is, and how to go about fixing it. 

I am trying to automate the initial level of analysis that can be done for every new support ticket, that answers the following questions:

1. Which file in the codebase is potentially related to the issue?
2. Which function/line-of-code is causing the problem?
3. Is there a scenario that can be used to locally reproduce the fault?
4. Has a similar problem happened before? If yes, is it documented anywhere?

Given the answers to these questions, the developer at work can focus on debugging rather than spending time searching for where a particular chunk of code might exist or spending time on trial and error just trying to figure out what works.

What this approach does is that it instantly speeds up the process of tickets getting resolved, enhancing customer/user satisfaction, and therefore elevating the overall experience of fixing an issue. 

What have I built?

I’ve developed an automation script hosted in an API, which is associated with an account on JIRA Cloud. JIRA is a popular software used by large organizations to manage issues and support tickets. 

When a new ticket is created on JIRA, it triggers a notification to Amazon SNS, which in turn triggers our API via a serverless function. We then make use of the issue details, provide context to a foundational Large Language Model in Amazon Bedrock; and then obtain an ideal response from it. The model is provided the issue details, the entire codebase, and previously existing tickets as context.

The response from the model would contain the initial analysis for the issue that can help the tech support representative, potentially answering those questions that we mentioned above. This response is then automatically shared in an internal comment on the same issue in JIRA via the JIRA API. 

Talk Outline

1. Introduction (3 mins)
2. Explaining the problem statement (3-5 mins) I will also share a little bit about my experience working on tech support for the last few months.
3. Architecture and Approach towards the solution (3-5 mins)
4. Just overviewing the code (2 mins) I will be sharing my GitHub Repository that contains the entire setup along with some documentation in case people wish to reproduce this. 
5. Demonstration of our solution (3 mins) We’ll walk through the same process of creating an issue ticket on JIRA, then wait for our script to come up with a response on the same. Naturally, for demonstration, I will be using a smaller codebase (given how expensive LLMs can get on an individual level)
6. Conclusion and Final Thoughts (3 mins)

I'd ideally plan this for around 20 mins, keeping a solid buffer in case things slow down at any point, giving me enough time to cover everything and ensuring I don’t rush through the talk at the end.