Forem: Bhimashankar Patil

Soon, AI Won’t Just Answer It’ll Run Your Life

Bhimashankar Patil — Wed, 11 Jun 2025 10:00:49 +0000

You wake up, and your AI has already paid your phone bill, ordered milk because your smart fridge noticed you're running low, moved your 3 PM meeting to 4 PM because of traffic, and booked a table at your favourite restaurant for your anniversary next week. It even saw that you only got 4 hours of deep sleep and automatically ordered your usual coffee to be ready when you get to work

Today's AI Just Talks. Tomorrow's AI Actually Does Things

Handle Your Money

Pay your Netflix bill, rent, and credit cards automatically
Notice you spent $200 on coffee this month and suggest ways to save
Move money from checking to savings when you have extra
Text you: "Someone just charged $500 to your card at Best Buy. Was this you?"

Shop Like Your Personal Buyer

Order toilet paper before you run out (it knows you use 2 rolls per week)
Find the best deal on that laptop you've been wanting and buy it when the price drops
Return that shirt that doesn't fit and order the right size
Say "Hey, I found 5-star wireless headphones for $30. Want me to grab them?"

Plan Your Trips From Start to Finish

Book your flight to Chicago, find a hotel near your meeting, and order an Uber for the airport
Create a day-by-day plan for your Paris vacation based on your love of art museums and good food
Remind you to renew your passport 6 months before your trip to Japan
Rebook your delayed flight and update your hotel reservation automatically

Keep You Healthy

Remind you to take your vitamins and track if you actually did it
Schedule your annual checkup and send you the reminder
Order healthy groceries based on your diet goals
Notice your heart rate has been high this week and suggest you get more sleep

Manage Your Schedule Like a Pro

Look at your calendar and automatically block 2 hours for deep work every morning
Reschedule your dentist appointment when your work meeting runs long
Send follow-up emails after your meetings with action items
Know you're most productive at 10 AM and schedule important calls then

How This Actually Works

This sounds like magic, but it's really just several technologies working together:

Smart AI with Perfect Memory: Think of ChatGPT, but it remembers every conversation you've ever had, every preference you've mentioned, and everything about your life.

AI That Can See and Hear: Your phone's camera becomes the AI's eyes, the microphone becomes its ears. It can read your emails, see your calendar, and understand your daily routine.

AI That Can Use Apps: New technology lets AI actually click buttons, fill out forms, and use websites just like you do. It can log into your bank account, order from Amazon, or book flights on Expedia.

Everything Has an API: Banks, airlines, food delivery apps—they're all building ways for AI to connect and take actions automatically.
Your Phone + The Cloud: Some thinking happens on your phone for privacy, while the heavy computing happens in data centers.

Your Life, All in One Place

Imagine opening one app that shows you:
How much money did you spend this month, and where did it go
Your next trip to Seattle with the full itinerary already planned
Your fitness goals and how you're doing (you walked 8,000 steps yesterday, goal is 10,000)
Important emails you need to respond to and which ones your AI has already handled
Your mom's birthday is next week, and the gift your AI has already ordered

Like a Glove HTB: Decoding Metaphors with GloVe Embeddings

Bhimashankar Patil — Fri, 25 Apr 2025 16:18:07 +0000

The Challenge:

Words carry semantic information. Similar to how people can infer meaning based on a word's context, AI can derive representations for words based on their context too! However, the kinds of meaning that a model uses may not match ours. We've found a pair of AIs speaking in metaphors that we can't make any sense of! The embedding model is glove-twitter-25. Note that the flag should be fully ASCII ans starts with 'htb{some_text}'.

Ever wondered how AI understands metaphors and analogies? This Hack The Box challenge threw me into a linguistic maze filled with strange word pairs and metaphorical riddles. The twist? It had to be solved using GloVe Twitter embeddings.

Each line follows the analogy format:

A is to B, as C is to ?

These were weird combinations, mixing English, Unicode characters, emojis, and foreign scripts. We’re told that the embedding model in use is:glove-twitter-25

Goal:

Infer the missing fourth term using word embeddings and extract the final flag which must be ASCII and start with htb{}.

Tools & Setup

Model: glove-twitter-25
Library: gensim
Input: challenge.txt (a list of analogies)
Output: flag.txt (the inferred flag characters)

import re
from gensim.models import KeyedVectors

def load_glove_model():
    model_path = "glove.twitter.27B/glove.twitter.27B.25d.txt"
    model = KeyedVectors.load_word2vec_format(model_path, binary=False, no_header=True)
    return model

def parse_challenge(file_path, model):
    with open(file_path, 'r') as file:
        lines = file.readlines()

    results = []
    flag_characters = []

    for i, line in enumerate(lines):        
        match = re.search(r"Like (.+?) is to (.+?), (.+?) is to\?", line.strip())
        if not match:
            match = re.search(r"Like (.+) is to (.+), (.+) is to\?", line.strip())
            if not match:
                continue

        key, value, query = match.groups()
        key = key.strip()
        value = value.strip()
        query = query.strip()
        print(f"Extracted: '{key}' -> '{value}', '{query}' -> ?")       
        try:
            missing_words = []
            for word in [key, value, query]:
                if word not in model:
                    missing_words.append(word)           
            if missing_words:
                print(f"Skipping due to missing words: {missing_words}")
                continue
            # This performs the vector math   
            result_vector = model[value] - model[key] + model[query]
            closest_word = model.most_similar(positive=[result_vector], topn=1)[0][0]

            print(f"Closest match for '{query}' is '{closest_word}'")

            flag_characters.append((i, query, closest_word))
        except KeyError as e:
            print(f"Error: {e}")
            continue


    mapped_chars = [char[2] for char in flag_characters]

    potential_flag = ''.join(mapped_chars)
    print(f"Potential flag sequence: {potential_flag}")

    normalized_flag = potential_flag
    replacements = {
        '０': '0', '１': '1', '２': '2', '３': '3', '４': '4',
        '５': '5', '６': '6', '７': '7', '８': '8', '９': '9'
    }

    for non_ascii, ascii_char in replacements.items():
        normalized_flag = normalized_flag.replace(non_ascii, ascii_char)

    print(f"Normalized flag: {normalized_flag}")
    return normalized_flag

if __name__ == "__main__":
    challenge_file = "challenge.txt"
    model = load_glove_model()
    flag_sequence = parse_challenge(challenge_file, model)
    print("FINAL FLAG:")
    print(flag_sequence)

    # Create a clean output file with just the flag
    with open('flag.txt', 'w') as flag_file:
        flag_file.write(flag_sequence)
    print(f"Flag has been saved to flag.txt")

Steps to Run:

1) Place the GloVe files in "glove.twitter.25B/".
2) Run "python main.py" to process "challenge.txt".
3) The resulting flag is written to "flag.txt".

This challenge was a fun mix of NLP, embeddings, and CTF logic. It’s not every day you have AIs “speaking in metaphors,” and it was fascinating to reverse-engineer that conversation!

Let me know if you faced the same challenge — I’d love to compare notes!

Github Link for solution: Github Link

The Art of Data Storytelling: What I Learned

Bhimashankar Patil — Wed, 23 Apr 2025 19:52:34 +0000

We all know the pain of sitting through a presentation filled with charts that don’t tell us much or worse, confuse us more than clarify. I recently read Storytelling with Data and it completely shifted the way I think about communicating insights. This isn’t just about pretty visuals. It’s about clear, meaningful communication, especially when you're working with project sponsors, business users, or delivery teams.

Know Your People First

Before diving into dashboards or diagrams, pause and ask: Who is this for? That clarity changes everything.

Project sponsors need confidence that your solution maps to the business goals.
Business users want functionality that makes their lives easier.
Delivery teams care about feasibility and handoffs.

If you don’t know your audience’s goals, pain points, and decision power, it’s like planning a trip without a destination. Tailoring your message to each stakeholder group ensures your work stays relevant and actionable.

Explanatory Analysis: Go from Messy to Meaningful

This is where the rubber meets the road. Explanatory analysis is about refining raw input—data, conversations, assumptions into clear, prioritized requirements.

Here’s a simple guide:

Who? Which stakeholder or user group has this need?
What? What specific outcome or capability are they after?
How? In what process or context will they use this?

You’re basically turning chaos into clarity. It’s detective work, really listening, translating, and simplifying.

The 3-Minute Story: Nail the Essence Fast

Imagine you're in a kickoff meeting, and time is tight. You’ve got just three minutes to explain a key requirement. What do you say?

This is your 3-minute story. No fluff. No jargon.

Start with the core need. What does this user or team absolutely need to succeed?
Explain the benefit. How will this requirement improve things—faster workflow, reduced risk, better decision-making?

This mini-story helps you (and everyone else) zoom in on what matters most. If you can’t explain it clearly in three minutes, you probably haven’t understood it well enough yet.

Use a Storyboard Before You Get Fancy

Before writing specs or building wireframes, sketch out the user flow—simple slides or diagrams that show how users interact with the solution.

Think of it like mapping a journey:

These early sketches make a huge difference. They force you to think logically and spot missing pieces before things get complex (and costly).

Gestalt Principles: Design That Feels Right

You don’t need to be a graphic designer to make your visuals work harder. Just use some basic Gestalt principles to help the eye make sense of things.

Here’s what that looks like:

These are small tweaks, but they can make your requirements diagrams or dashboards instantly clearer.

Tell the Whole Story, Step by Step

When presenting your requirements—whether in a deck, a doc, or a meeting—follow a logical narrative:

Context: What business goals and challenges are we trying to solve?
Key Findings: What data or research tells us there’s a need?
Requirements: What exactly do we need to build or deliver?
Impact: What are the expected benefits or risks tied to these requirements?
Next Steps: What’s the plan to validate, prioritize, and assign ownership?

This flow keeps things grounded and moves the conversation forward. It’s not just “Here’s the data,” but “Here’s what it means, and what we’re doing next.”

Final Thoughts

Reading Storytelling with Data reminded me that clarity is everything—and that applies just as much to requirements as it does to analytics. Whether you’re writing user stories, building a roadmap, or presenting to the execs, the ability to tell a focused, visual, and human-centered story makes all the difference.

Next time you’re knee-deep in a project, ask yourself: What story am I telling—and who needs to hear it?

Building a Multi-Agent Conversational AI System.

Bhimashankar Patil — Thu, 10 Apr 2025 09:08:41 +0000

As AI systems become more sophisticated, we're moving beyond the "one model handles everything" approach. Today, I'll share how I built a conversational AI system that uses specialized agents for different tasks - all powered by Amazon Bedrock.

The Problem with Generic AI Assistants

Have you ever had a conversation with an AI chatbot that kept forgetting details or mixed up information from different topics? It's frustrating, right?

Generic AI assistants try to handle everything—from booking cabs to tracking orders to answering random questions—in one conversational flow. This often leads to context confusion and poor user experience.

Enter the Multi-Agent Architecture

To solve this, I created a system that uses specialized AI agents that focus on specific tasks:

A main coordinator agent that handles general queries and routes requests
A cab booking specialist agent
An order tracking specialist agent

System Architecture

Here's how the system works:

The user interacts with the main agent initially
Based on intent detection, the conversation gets transferred to a specialized agent
The specialized agent handles its specific task until completion
The user can switch between agents or return to the main menu

Building the System with Amazon Bedrock

Let's dive into the implementation. I used Amazon Bedrock with Claude 3.5 Sonnet as the underlying LLM.

import logging
import json
import boto3
import requests
import datetime
import random
from botocore.exceptions import ClientError

# Configure logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

# Create the Bedrock client
def get_bedrock_client():
    return boto3.client(
        service_name='bedrock-runtime',
        aws_access_key_id="YOUR_ACCESS_KEY",
        aws_secret_access_key="YOUR_SECRET_KEY",
        region_name="REGION"
    )

Tool Configuration
The system uses function calling (or "tools" in Amazon Bedrock terminology) to perform actions:

tool_config = {
    "tools": [
        {
            "toolSpec": {
                "name": "book_cab",
                "description": "Book a cab between locations",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "pickup": {
                                "type": "string",
                                "description": "Pickup location (e.g., Andheri, Bandra, Dadar)"
                            },
                            "destination": {
                                "type": "string",
                                "description": "Drop-off location (e.g., Airport, Powai, Worli)"
                            },
                            "time": {
                                "type": "string",
                                "description": "Pickup time in HH:MM format"
                            },
                            "passengers": {
                                "type": "integer",
                                "description": "Number of passengers"
                            }
                        },
                        "required": ["pickup", "destination"]
                    }
                }
            }
        },
        {
            "toolSpec": {
                "name": "track_order",
                "description": "Track the status of an order",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {
                            "order_id": {
                                "type": "string",
                                "description": "The order ID to track (e.g., ORD12345)"
                            }
                        },
                        "required": ["order_id"]
                    }
                }
            }
        }
    ]
}

Intent Detection
The system needs to identify what the user wants to do:

def detect_intent(text):
    text = text.lower()
    if any(keyword in text for keyword in ['book', 'cab', 'taxi', 'ride', 'uber', 'ola']):
        return 'cab_booking'
    elif any(keyword in text for keyword in ['order', 'track', 'package', 'delivery', 'shipment']):
        return 'order_tracking'
    else:
        return 'unknown'

The Cab Booking Agent
Let's look at how the cab booking agent is implemented:

def cab_booking_agent(bedrock_client, model_id, tool_config, conversation_history=None):
    print("Transferring to Cab Booking Agent...")
    print("-" * 50)

    # Start with a clean conversation history
    if conversation_history:
        messages = clean_conversation_history(conversation_history)
    else:
        messages = [{
            "role": "user",
            "content": [{
                "text": """You are a specialized cab booking agent. Focus only on helping users book cabs.
                Ask for the following information if not provided: pickup location, destination, pickup time, 
                and number of passengers. Be conversational but efficient."""
            }]
        }]

    # Add specialized prompt to make agent more focused
    specialized_prompt = {
        "role": "user",
        "content": [{
            "text": """You are now a specialized cab booking agent. Your responses should be direct and to the point.
            Just ask directly for any missing information needed to book a cab."""
        }]
    }
    messages.append(specialized_prompt)

    # Main conversation loop
    booking_complete = False
    first_interaction = True
    returning_to_main = False
    new_intent = None

    while not returning_to_main and not new_intent:
        try:
            # Get user input
            if first_interaction and conversation_history:
                user_input = ""
                first_interaction = False
            else:
                print("Cab Booking Agent: ", end="")
                user_input = input()

            # Check for exit commands or intent switching
            if user_input.lower() in ["exit", "quit", "bye", "cancel", "back", "return", "main menu"]:
                print("Cab Booking Agent: Returning to main menu.")
                returning_to_main = True
                break

            # Process conversation with model
            if user_input:
                messages.append({
                    "role": "user",
                    "content": [{"text": user_input}]
                })

            # Get model response
            response = bedrock_client.converse(
                modelId=model_id,
                messages=messages,
                toolConfig=tool_config
            )

            # Rest of conversation handling
            # ...

Handling Tool Calls
When the model decides to book a cab, it uses the tool:

if stop_reason == 'tool_use':
    has_tool_use = True
    tool_requests = response['output']['message']['content']

    for tool_request in tool_requests:
        if 'toolUse' in tool_request and tool_request['toolUse']['name'] == 'book_cab':
            tool = tool_request['toolUse']
            print("Processing your cab booking request...")

            try:
                booking_details = book_cab(
                    tool['input']['pickup'],
                    tool['input']['destination'],
                    tool['input'].get('time', '15:00'),
                    tool['input'].get('passengers', 1)
                )

                tool_result = {
                    "toolUseId": tool['toolUseId'],
                    "content": [{"json": booking_details}]
                }

                # Mark booking as complete
                booking_complete = True

            except CabNotFoundError as err:
                tool_result = {
                    "toolUseId": tool['toolUseId'],
                    "content": [{"text": f"I couldn't find cabs from {tool['input']['pickup']} to {tool['input']['destination']}. Please check the locations and try again."}],
                    "status": 'error'
                }

            # Send tool result back to model
            tool_result_message = {
                "role": "user",
                "content": [{"toolResult": tool_result}]
            }
            messages.append(tool_result_message)

Main Application Loop
The heart of the system is the main loop that coordinates between agents:

def main():
    # Setup
    model_id = "YOUR MODEL ID"
    bedrock_client = boto3.client(service_name='bedrock-runtime', region_name="ap-south-1")

    print("I can help you with cab booking and order tracking.")

    # Initialize base conversation
    base_messages = [{
        "role": "user",
        "content": [{
            "text": """You are a helpful travel and shopping assistant. You can help with cab booking and order tracking.
            Keep your responses friendly and concise."""
        }]
    }]

    try:
        current_intent = None
        base_messages_copy = None

        while True:
            if current_intent is None:
                # When in main menu
                user_input = input("You: ")

                if user_input.lower() in ["exit", "quit", "bye"]:
                    print("Assistant: Goodbye! Have a great day!")
                    break

                # Add user input to conversation
                base_messages.append({
                    "role": "user",
                    "content": [{"text": user_input}]
                })

                # Detect intent from user input
                intent = detect_intent(user_input)
                base_messages_copy = base_messages.copy()

                if intent == 'cab_booking':
                    # Transfer to cab booking agent
                    current_intent = 'cab_booking'
                    next_intent = cab_booking_agent(bedrock_client, model_id, tool_config, base_messages)

                    if next_intent:
                        current_intent = next_intent
                    else:
                        current_intent = None  # Return to main menu

                elif intent == 'order_tracking':
                    # Transfer to order tracking agent
                    current_intent = 'order_tracking'
                    next_intent = order_tracking_agent(bedrock_client, model_id, tool_config, base_messages)

                    if next_intent:
                        current_intent = next_intent
                    else:
                        current_intent = None  # Return to main menu

                else:
                    # General conversation
                    response = bedrock_client.converse(
                        modelId=model_id,
                        messages=base_messages,
                        toolConfig=tool_config
                    )

                    # Display response
                    # ...

Key Features That Make This System Special

Context Isolation: Each specialized agent maintains its own conversation state, preventing context confusion.
Seamless Transitions: Users can move between different agents without losing context.
Proactive Intent Detection: The system identifies when a user wants to switch topics and transfers them to the appropriate agent.
Persistent Memory: The system remembers key information across transfers.
Error Handling: Robust error handling for API failures, invalid inputs, and edge cases.

Conclusion

The multi-agent approach represents the next evolution in conversational AI. By using specialized agents, we can create more focused, helpful, and reliable conversational experiences.

The code shared here is just a starting point. You could expand this system with more specialized agents, better natural language understanding, and integration with real backend systems.

What specialized agents would you build for your business? Let me know in the comments!

Understanding MCP (Model Context Protocol) with Examples

Bhimashankar Patil — Tue, 01 Apr 2025 05:48:52 +0000

Introduction

The Model Context Protocol (MCP) is a structured way to manage and exchange contextual information between AI models and applications. It allows AI systems to maintain state, remember previous interactions, and improve response relevance in multi-turn conversations.

Why is MCP Needed?

Most AI models process each request independently. Without context, they cannot recall previous interactions, leading to disjointed conversations. MCP solves this by providing a framework to:

Maintain conversation history
Track user preferences
Improve response accuracy
Call external tools and APIs to enhance responses

How MCP Works

MCP operates using context objects that store relevant details about an interaction. These context objects can include:

Session ID: Unique identifier for a conversation
User Information: Preferences, history, and settings
Previous Queries & Responses: Helps maintain continuity
Domain-Specific Knowledge: Relevant facts that improve AI accuracy
API & Tool Calls: Enables dynamic responses by fetching real-time data

Example of MCP in Action

Let's say we are building an AI assistant for customer support. Without MCP, the conversation might look like this:

Without MCP

User: "What's my order status?"

AI: "Please provide your order ID."

User: "It's #12345."

AI: "Your order is in transit."

Here, the AI forgets the user after every message and needs additional input each time.

With MCP

Using MCP, we store the session details and user data:

{
  "session_id": "abc123",
  "user": {
    "name": "John Doe",
    "email": "john@example.com"
  },
  "context": {
    "last_order_id": "12345",
    "last_query": "order_status"
  }
}

Now, the conversation is smoother:

User: "What's my order status?"

AI: "Your last order (#12345) is in transit."

Since the AI remembers the order ID from context, it eliminates the need to ask again.

Using Tools and APIs in MCP

MCP also allows AI systems to call external APIs and tools dynamically. For example, if a user asks for real-time weather updates, MCP can fetch data from a weather API:

{
  "session_id": "xyz789",
  "user": {"name": "Alice"},
  "context": {"last_query": "weather"},
  "api_call": {
    "endpoint": "https://weatherapi.com/current",
    "parameters": {"location": "New York"}
  }
}

The AI can then return:

User: "What's the weather like in New York?"

AI: "It's 72°F and sunny in New York."

By integrating API calls, MCP enables AI assistants to provide real-time, accurate responses beyond static knowledge.

Implementing MCP

To implement MCP, you need:

Session Management – Store session data using a database or memory cache (e.g., Redis).
Context Storage – Maintain a structured context object.
Stateful APIs – Modify API calls to include and update context data.
Tool and API Integration – Enable AI to fetch external data dynamically.

Example: Context-Aware API in Python

from flask import Flask, request, jsonify

app = Flask(__name__)
context_store = {}

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    session_id = data.get("session_id")
    user_message = data.get("message")

    if session_id not in context_store:
        context_store[session_id] = {"history": []}

    context_store[session_id]["history"].append(user_message)

    response = generate_response(user_message, context_store[session_id])
    return jsonify({"response": response})

def generate_response(message, context):
    return f"You said: {message}. Context length: {len(context['history'])}"

if __name__ == '__main__':
    app.run(debug=True)

Conclusion

MCP helps AI models maintain state and improve conversational flow. By structuring context information efficiently and integrating tools and APIs, AI assistants can provide more meaningful and personalized responses, leading to better user experiences.

What are your thoughts on MCP? Have you implemented something similar? Let me know in the comments!

How to Perform Audio Call QA Analysis Using the Sonnet Model and Deepgram API

Bhimashankar Patil — Fri, 21 Feb 2025 05:32:18 +0000

Quality Assurance (QA) analysis for audio calls is crucial for businesses that rely on customer interactions. By analyzing customer support or sales calls, companies can improve customer experience, ensure compliance, and enhance agent performance. With AI-powered tools like Deepgram for speech-to-text conversion and Sonnet for intelligent analysis, automating QA analysis has become easier than ever.

Why Use Deepgram and Sonnet?

Deepgram is an AI-powered speech-to-text platform known for its accuracy and real-time transcription capabilities. Sonnet, on the other hand, is a powerful AI model capable of analyzing text data and extracting meaningful insights. When combined, they offer a seamless way to process and analyze call recordings for QA purposes.

Steps to Perform QA Analysis on Audio Calls

Convert Audio Calls to Text Using Deepgram

import requests

API_KEY = "your_deepgram_api_key"
AUDIO_FILE_PATH = "path_to_your_audio_file.wav"

with open(AUDIO_FILE_PATH, "rb") as audio:
    response = requests.post(
        "https://api.deepgram.com/v1/listen",
        headers={
            "Authorization": f"Token {API_KEY}",
            "Content-Type": "audio/wav",
        },
        data=audio,
    )
    transcript = response.json()["results"]["channels"][0]["alternatives"][0]["transcript"]
    print("Transcript:", transcript)

2. Analyze the Transcription Using Sonnet Model
Once we have the call transcript, we can analyze it for QA purposes using the Sonnet model. The Sonnet model can help with:

-- Sentiment analysis (detecting customer and agent emotions)
-- Keyword spotting (identifying compliance keywords)
-- Issue detection (highlighting complaints or repeated concerns)
-- Agent performance evaluation (checking script adherence)

import boto3

def analyze_text_with_sonnet(text):
    client = boto3.client("bedrock-runtime")
    response = client.invoke_model(
        modelId="sonnet-3.5",
        contentType="application/json",
        body={"prompt": f"Analyze the sentiment and key insights from this conversation: {text}"}
    )
    return response["output"]

transcription_text = "The customer was unhappy with the service and asked for a refund."
qa_results = analyze_text_with_sonnet(transcription_text)
print("QA Analysis:", qa_results)

3. Automating QA Analysis
-- n8n or Zapier for automation
-- Metabase for visualizing trends in call analytics

Conclusion

Using Deepgram and the Sonnet model together can significantly improve the speed and accuracy of audio call QA analysis. With automated transcription and AI-powered analysis, businesses can gain better insights into customer interactions, ensure compliance, and enhance customer service quality.

By implementing this workflow, you can save time, reduce manual QA efforts, and make data-driven decisions to improve customer satisfaction.

Check out this project on automated df analysis !!!!

Bhimashankar Patil — Fri, 13 Dec 2024 10:04:59 +0000

Automating Data Analysis with Python: A Hands-On Guide to My Project

Bhimashankar Patil ・ Dec 13 '24

#datascience #analytics #python #webdev

Automating Data Analysis with Python: A Hands-On Guide to My Project

Bhimashankar Patil — Fri, 13 Dec 2024 09:29:30 +0000

Data analysis is crucial across industries, but handling raw data efficiently can be a daunting challenge. With this project, I created an Automated Data Analysis pipeline that simplifies data handling and transformation, making it faster.

Why Automated Data Analysis?

Manual processes are time-consuming and error-prone. To solve this, I developed a Python-based pipeline that automates these tasks while ensuring accuracy and scalability

Why Add a UI to Automated Data Analysis?

While command-line tools are powerful, they can be intimidating for non-technical users. The new interactive UI bridges the gap, enabling analysts and business users to:

Upload Excel files directly for analysis.
Generate custom plots and statistical insights without writing code.
Perform outlier detection and correlation analysis interactively.

Features Overview

File Upload for Analysis
The interface lets you upload Excel files with a single click.
Once uploaded, the app automatically Identifies numerical and
categorical columns and display summary statistics.
Custom Plot Generation
Select any column and generate visualizations instantly. This is perfect for understanding trends and distributions in your data.
Outlier Detection
The app supports outlier detection using methods like Z-Score. Set a threshold value, and it highlights outliers for further investigation.
Correlation Heatmap
Generate a heatmap to visualize correlations between numerical features, helping identify patterns and relationships.
Pair Plot Generation
The pair plot feature offers a way to explore the relationships between multiple features in a dataset through scatter plots and distributions.
Behind the Scenes: How the App Works
File Handling and Data Parsing:
The uploaded Excel file is read into a pandas DataFrame for preprocessing.
Dynamic Plotting
Matplotlib and Seaborn are used to create dynamic visualizations based on user input.
Outlier Detection
The Z-Score method flags outliers beyond the specified threshold.
Interactive Widgets
Streamlit widgets, such as dropdowns, sliders, and file upload buttons, allow users to interact with the app intuitively.

Future Enhancements

Real-Time Data Streaming: Adding support for live data updates.
Advanced Analytics: Incorporating machine learning models for predictions and clustering.

Conclusion

The Automated Data Analysis project demonstrates the power of combining automation with interactivity. Whether you’re a business analyst or a data enthusiast, this tool simplifies exploring and analyzing datasets.

UI Screenshots:

Linkedin URL: Click here to watch the video how it work

[Boost]

Bhimashankar Patil — Thu, 28 Nov 2024 05:38:14 +0000

Building a Simple Chatbot with Llama2 [Chat with Excel]

Bhimashankar Patil ・ Nov 28 '24

#python #nlp #llm #datascience

Building a Simple Chatbot with Llama2 [Chat with Excel]

Bhimashankar Patil — Thu, 28 Nov 2024 05:17:37 +0000

In this post, I’ll explain how I built a chatbot using the Llama2 model to query Excel data intelligently.

What We’re Building

Loads an Excel file.
Splits the data into manageable chunks.
Stores the data in a vector database for fast retrieval.
Use a local Llama2 model to answer questions based on the content of the Excel file.

Prerequisites:

Python (≥ 3.8)
Libraries: langchain, pandas, unstructured, Chroma

Step 1: Install Dependencies

%pip install -q unstructured langchain
%pip install -q "unstructured[all-docs]"

Step 2: Load the Excel File

import pandas as pd

excel_path = "Book2.xlsx"
if excel_path:
    df = pd.read_excel(excel_path)
    data = df.to_string(index=False)
else:
    print("Upload an Excel file")

Step 3: Chunk the Data and Store in a Vector Database

Large text data is split into smaller, overlapping chunks for effective embedding and querying. These chunks are stored in a Chroma vector database.

from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

text_splitter = RecursiveCharacterTextSplitter(chunk_size=7500, chunk_overlap=100)
chunks = text_splitter.split_text(data)

embedding_model = OllamaEmbeddings(model="nomic-embed-text", show_progress=False)
vector_db = Chroma.from_texts(
    texts=chunks, 
    embedding=embedding_model,
    collection_name="local-rag"
)

Step 4: Initialize the Llama2 Model

We use ChatOllama to load the Llama2 model locally.

from langchain_community.chat_models import ChatOllama

local_model = "llama2"
llm = ChatOllama(model=local_model)

Step 5: Create a Query Prompt

The chatbot will respond based on specific column names from the Excel file. We create a prompt template to guide the model

from langchain.prompts import PromptTemplate

QUERY_PROMPT = PromptTemplate(
    input_variables=["question"],
    template="""You are an AI assistant. Answer the user's questions based on the column names: 
    Id, order_id, name, sales, refund, and status. Original question: {question}"""
)

Step 6: Set Up the Retriever

We configure a retriever to fetch relevant chunks from the vector database, which will be used by the Llama2 model to answer questions.

from langchain.retrievers.multi_query import MultiQueryRetriever

retriever = MultiQueryRetriever.from_llm(
    vector_db.as_retriever(), 
    llm,
    prompt=QUERY_PROMPT
)

Step 7: Build the Response Chain

The response chain integrates:

A retriever to fetch context.
A prompt to format the question and context.
The Llama2 model to generate answers.
An output parser to format the response.

from langchain.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

template = """Answer the question based ONLY on the following context:
{context}
Question: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

Step 8: Ask a Question

Now we’re ready to ask a question! Here’s how we invoke the chain to get a response:

raw_result = chain.invoke("How many rows are there?")
final_result = f"{raw_result}\n\nIf you have more questions, feel free to ask!"
print(final_result)

Sample Output

When I ran the above code on a sample Excel file, here’s what I got:

Based on the provided context, there are 10 rows in the table.
If you have more questions, feel free to ask!

Conclusion:

This approach leverages the power of embeddings and the Llama2 model to create a smart, interactive chatbot for Excel data. With some tweaks, you can extend this to work with other types of documents or integrate it into a full-fledged app!

Check working example with UI on my LinkedIn:

Introducing BChat Excel: A Conversational AI-Powered Tool for Excel File Interactions

Exploring Async Deepgram API: Speech-to-Text using Python

Bhimashankar Patil — Mon, 21 Oct 2024 08:58:25 +0000

Today will explore the Deepgram API for converting voice to text [transcription]. Whether building a voice assistant, transcribing meetings or creating a voice-controlled app, Deepgram makes it easier than ever to get started.

What is Deepgram?

Deepgram is a powerful speech recognition platform that uses advanced machine learning models to transcribe audio in real-time. It offers an easy-to-use API that developers can integrate into their applications for tasks like transcribing phone calls, converting meetings into text, or even analyzing customer interactions.

Why Use Deepgram?

Accuracy: Deepgram boasts high accuracy rates thanks to its deep learning algorithms trained on vast datasets.
Real-Time Transcription: Get instant results as you speak, perfect for live applications.
Multiple Languages: Supports several languages and accents, making it versatile for global applications.

Getting Started with Deepgram API

Install - pip install httpx

Importing Required Libraries

import httpx
import asyncio
import logging
import traceback

Defining the Asynchronous Function

#recording_url: The URL of the audio file to be transcribed.
#callback_url: The URL to which Deepgram will send the #transcription results (optional).
#api_key: Your Deepgram API key.

async def transcribe_audio(recording_url: str, callback_url: str, api_key: str):
    url = "https://api.deepgram.com/v1/listen"

    # Define headers
    headers = {
        "Authorization": f"Token {api_key}"
    }

    # Define query parameters
    query_params = {
        "callback_method": "post",
        "callback": callback_url
    }

    # Define body parameters
    body_params = {
        "url": recording_url
    }

4. Sending the Asynchronous Request

    logger.info(f"Sending request to {url} with headers: {headers}, query: {query_params}, body: {body_params}")

    async with httpx.AsyncClient(timeout=60.0) as client:
        try:
            # Make a POST request with query parameters and body
            response = await client.post(url, headers=headers, params=query_params, json=body_params)
            response.raise_for_status()  # Raise an error for HTTP error responses
            result = response.json()
            logger.info(f"Response received: {result}")

            return result

We create an instance of httpx.AsyncClient with a timeout of 60 seconds. Using async with ensures that the client is properly closed after the block is executed.
If the request is successful, we parse the JSON response and log it, then return the result.

Call back URL :

You can use for sample call back URL for testing.

conclusion:

This structured approach highlights how to utilize asynchronous programming in Python to interact with the Deepgram API efficiently. By breaking the code into blocks and explaining each part, readers can better understand the implementation and how to adapt it to their own needs.

How to run python3 using Power Automate Desktop.(Step Wise Guide)

Bhimashankar Patil — Mon, 15 Jan 2024 11:47:47 +0000

Hi Folks, This blog is about how can we run a python3 script using Power Automate.
As of now, Power Automate desktop supports Python 2.7 which has limitations.

Prerequisites :
1 - You need to have PAD installed. (obviously)
2 - Python3

Step 1 - Create A flow with any Name that you like.

Step 2 - Go to Action and search for "Open CMS Session".

Step 3 - Inside that give the current working directory as a Parameter.

Step4 - Again search for "Write to CMD Session" in actions and drag it under "Open CMD Session"

In "Write to CMD Session" give the command to run your python3 script.
example: cd.\PyProjects&& cd.my_script.py

Step 5 - Now again go to Actions and search for "Read from CMD Session" It will help you to see the output that is displayed on CMD.

As the Parameter just pass the instance of "Open CMD Session"

Now Save and Test your flow.

If you face any problem feel free to comment your questions.