DEV Community: Thabasvini

Bug Whisperer – AI-Powered Debugging with Redis

Thabasvini — Mon, 11 Aug 2025 05:41:52 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

Bug Whisperer is an AI-powered debugging assistant that listens for error logs in real time, classifies their severity, explains the cause, and suggests fixes.
It stores embeddings of each bug so it can instantly recall and provide suggestions for similar issues in the future.

Key highlights:

Real-time bug ingestion via Redis Streams
AI-powered suggestions using Google FLAN-T5
Semantic similarity search via Redis Vector Store + Sentence Transformers
Template fallback for common errors
Streamlit dashboard to view recent bugs & chat with the assistant

Demo

GitHub Repo: https://github.com/Thabasvini/Bug-Whisperer-AI-Powered-Debugging-with-Redis-Vector-Search

How it works in action:

Producer/Simulated App pushes an error into Redis Stream bug_logs

Consumer reads new error → classifies severity → checks for similar bugs in Redis → generates suggestion

Dashboard displays recent errors + lets users ask about new bugs directly

How I Used Redis 8

I leveraged multiple Redis 8 AI-focused features:

Redis Streams: Acts as the real-time log ingestion layer (bug_logs).
Redis Hashes & Lists: Store structured bug reports (bug:{id}) and maintain an ordered list of recent bugs (bug_index).
Redis Vector Store: Store semantic embeddings of bug messages from all-MiniLM-L6-v2.
Enables semantic recall for similar bugs with high cosine similarity.
Semantic Caching: When a bug is seen again, the system instantly retrieves a stored suggestion instead of calling the model again, reducing cost & latency.

Solo project by @aibythabasvini

How Linear Regression Works: Predictive ML Explained with Python Demo

Thabasvini — Fri, 11 Jul 2025 13:16:31 +0000

What if a machine could predict your salary just by looking at your experience?

Well that what we call as Linear Regression, one of the most fundamental yet powerful algorithms in machine learning.

In this post, I’ll explain how linear regression works from intuition to code, complete with a real Python demo and visuals.

What Is Linear Regression?

Linear regression is a way for machines to predict a number (continuous value) based on past data.

Think of it like drawing the best-fitting straight line through your data points, and then using that line to make future predictions.

Real-life examples

Predicting house price based on area
Estimating sales based on ad spend
Calculating salary based on experience

Mathematically, it looks like this,

Y = mX + b

Here’s a simple scatter plot with a regression line that represents this idea,

The Intuition Behind It

Let’s say you have the following dataset,

Can you guess the salary for someone with 5 years of experience?

Probably ₹50,000?

That’s exactly what linear regression does, it finds the trend in past data and uses it to predict future values.

Linear Regression in Python

#Training the model

from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

X = [[1], [2], [3], [4], [5]]
y = [30000, 35000, 40000, 45000, 50000]

model = LinearRegression()
model.fit(X, y)

#Predicting the salary

prediction = model.predict([[6]])
print("Predicted salary for 6 years experience:", prediction[0])

Output:
Predicted salary for 6 years experience: 55000.0

Real-World Use Cases

Linear regression is widely used in industries,

Finance → Predicting stock price trends
Marketing → Estimating ROI from ad spend
Real Estate → Pricing homes based on area/location
Sales Forecasting → Projecting revenue

So yes, Linear regression is the gateway to machine learning.

Need a full YouTube video explanation on Decision Tree,

I build lightweight, fully tailored AI models that run directly on your own data, whether it's spreadsheets, CSVs, or CRM exports.

Whether you're in product, growth, support, or sales, you’ll get clear, AI-powered insights to automate decisions and save time.

Want to see what this looks like?
Check out SiteEncoders, where we turn AI ideas into real working solutions.

Check out our Blog-Page, How AI Can Make Smart Business Decisions ---> Automatically

How Decision Trees Work: Real Demo and Simple Explanation

Thabasvini — Thu, 26 Jun 2025 14:26:43 +0000

Do you ever ask yourself how machines make decisions like humans?

Let’s break down one of the most beginner-friendly algorithms in machine learning,

Wanna know what’s that, ta-da “Decision Tress”, with a real working demo using Python and scikit-learn.

What Is a Decision Tree?

A decision tree is a flowchart-like structure where each internal node represents a question based on a feature, each branch represents an answer, and each leaf node represents an outcome or class label.

(Deos the definition overwhelm you?)

Here is the simplified version,

*Machines ask yes/no questions ----> (just like we do)----> to make decisions. *

Real Life Analogy

That’s a decision tree for you to visualize.

The Sample Use Case

Let's Build It in Python

Import Libraries

from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

Prepare the Data

X = [[25, 50000], [35, 60000], [45, 80000], [22, 30000]]
y = [0, 1, 1, 0]  # 0 = No Buy, 1 = Buy

Train the Model

clf = DecisionTreeClassifier()
clf.fit(X, y)

Visualize the Tree

plt.figure(figsize=(8, 5))
plot_tree(clf, feature_names=["Age", "Income"], class_names=["No", "Yes"], filled=True)
plt.show()

Output:

How Does It Decide?

Well, thats the cool one here,the decision tree uses something called Gini Impurity to choose the best split,

If a node has all “Yes” or all “No”, it’s pure (Gini = 0).
The more mixed it is, the higher the impurity.

So, the takeaway algorithm keeps splitting where impurity is lowest.

Try making a prediction using the above code!

print(clf.predict([[40, 70000]]))

The output will be [1] //means they will buy.

Where Are Decision Trees Used?

Credit card approval
Customer churn prediction
Recommender systems
Medical diagnosis
E-commerce decision engines

okay so finally, Decision Trees are powerful, visual, and easy to understand.

If you’re learning ML or just want to understand how AI “thinks”, start with Decision Trees.

And if you want to see a live demo in action,Here's a quick youtube video me explaining How decision tress actually work,

🙌 Follow me for more beginner-friendly AI & ML breakdowns!
🚀 Need help building real AI/ML solutions? Check out SiteEncoders, we build it for you.

How KNN "Guesses" Like a Human: A Visual Python Demo

Thabasvini — Mon, 16 Jun 2025 14:18:03 +0000

Have you ever made a decision just by looking around and trusting your instinct! Well, That’s how K-Nearest Neighbors (KNN) works.

In this post, I’ll walk you through a visual, beginner-friendly KNN demo using Python. We’ll plot data, add a new point.

What is KNN

KNN is one of the simplest machine learning algorithms but also one of the most intuitive:

It stores all known data
When asked to make a prediction, it finds the K closest known data points
Then, it "votes" on what the new data point should be

Think of it like this:

If your 5 closest friends love Chocolate Burgers, well, chocolate Burgers! Does anyone like Chocolate Burger's here?

LOL

Chances are you will too, or that's how KNN will assume.

Why it's Super Cool

No need for the training step, it's Lazy Learning.
Works really well on small datasets.
It's super great for visual understanding of AI behaviour

Python Code (Visual Demo)

Let me show some code for KNN, we'll create a synthetic dataset of two classes, plot them and predict a new data point

import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.neighbors import KNeighborsClassifier

# let's create a 2D Dataset

data, labels = make_classification(n_samples=100,n_features=2,n_informative=2, n_redundant=0,n_clusters_per_class=1)

# Split the data into two classes

class_0 = data[labels == 0]
class_1 = data[labels == 1]

# Plot the existing data

plt.scatter(class_0[:, 0], class_0[:, 1], color='blue', label='Class 0')
plt.scatter(class_1[:, 0], class_1[:, 1], color='red', label='Class 1')

# Define a new plot

new_point = [[0.5, -0.5]]
plt.scatter(new_point[0][0], new_point[0][1], color='green', label='New Point', s=100, edgecolors='black')

# Fit the model and start predicting

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(data, labels)
predicted = knn.predict(new_point)

# Finally Annotate

plt.title(f"Predicted Class: {predicted[0]}")
plt.legend()
plt.show()

This code works, feel free to run it, tweak the dataset size or n_neighbors, and experiment with different points. It's a great way to see how AI makes decisions.

Output:

So why KNN matter, it's not just acadamic,it's used in:

Recommendation Systems

Image Classifier

Anomaly Detection

The beauty of KNN lies in simplicity which lays the foundation for understanding more complex AI systems.

Want to see more? I build AI agents, storytelling bots, and fun Python experiments that feel alive.

Follow me here on Dev.to or check out SiteEncoders where we turn cool AI into real products.

Let me know your thoughts below or share your favorite "super smart" algorithm!