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 to accelerate and streamline this process. My implementation is open source and all resources will be provided on GitHub.

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. 

The process that I'm trying to automate is 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 effectively 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 are we building? 

I’ve built 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 setup on AWS Lambda. 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. 

Outline of the Talk

1. Introductions (3 mins)
2. Explaining the problem statement (3-5 mins)
3. Here, I will also share a little bit about my experience working on tech support for the last few months
4. Architecture and Approach towards our solution (3-5 mins)
5. Just overviewing the code (2 mins)
6. Sharing the GitHub Repository that contains the entire setup along with some documentation in case people wish to reproduce this. 
7. Demonstration of the solution (3 mins)
8. I’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)
9. 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 we don’t rush through the talk at the end.

Notes:

1. I haven’t had a chance to present this talk yet, but it only makes me more excited to showcase it in PuneFOSS.
2. I've spoken at events in college and have also taken tech workshops, but it's my first time speaking in a conference. Am I nervous? Yes. Am I excited? OH YES.
3. Intended Audience:
4. Technologists in general, beginner to advanced-level would benefit from our talk.
5. Developers working in a role that involves realtime tech support would definitely benefit more from the talk. People actively working on solving PROD issues regularly will be able to relate more to the problem that we are trying to address.
6. Ideal Duration: 20-25 minutes
7. Category: Python and Generative AI
8. I work as a Software Engineer in JP Morgan Chase & Co. and I'm from Mumbai.

Tech Stack used to build the solution:

1. Python 3.12
2. Flask
3. Langchain
4. AWS Services
5. AWS Lambda
6. Amazon SNS
7. AWS Bedrock
8. Foundational Model: Anthropic Claude v2
9. JIRA Cloud
10. JIRA Dashboard
11. JIRA Cloud API