DEV Community: Santhosh Vijayabaskar

🔥 10 AI-driven packages for RPA and Intelligent Automation 🤖 🧠

Santhosh Vijayabaskar — Wed, 30 Oct 2024 23:00:00 +0000

Robotic Process Automation (RPA) is getting a big boost, thanks to AI 🤖. We’re way past just automating repetitive tasks—now, automation’s smart enough to handle complex stuff, make decisions, and even feel almost human in its interactions.

In this article, I’m running through 10 AI-driven tools that take RPA up a notch. From NLP to computer vision to machine learning, these tools are all about helping you build systems that aren’t just faster but also way more adaptable. Whether you’re looking to streamline document processing or enable predictive decision-making 📊, these tools have you covered.

1. spaCy – Powerful NLP for Automation

spaCy is a natural language processing library designed for speed and efficiency, making it ideal for text-based automation in RPA.

Key Features:

Spot Key Details: spaCy makes it easy to pick out important names, places, or other entities in text automatically.
Fast and Efficient: Great for quickly processing large chunks of text without slowing down.
Pre-trained Models: Comes ready-to-go with models in multiple languages, so you don’t have to start from scratch.

Use Case: Automating customer support by extracting key data from emails, such as complaint types, locations, or customer names, then categorizing the requests for the right department.

Getting Started: Install spaCy with pip install spacy, and access their documentation for model downloads and tutorials here.

2. PaddleOCR – Advanced OCR for Complex Documents

PaddleOCR is a deep-learning-based optical character recognition (OCR) tool that provides high accuracy across languages and complex document structures.

Key Features:

Multilingual Support: Reads text in many languages, which is super handy for global documents.
Handles Tables and Forms: Doesn’t just read words; it understands structured layouts like tables and forms.
Ready to Use: Comes pre-trained, so it’s easy to set up and start automating document-heavy tasks.

Use Case: Automating invoice processing by extracting line items, amounts, and dates from scanned invoices, feeding the data into financial systems, and reducing manual data entry.

Getting Started: Install PaddleOCR with pip install paddleocr, and follow its GitHub documentation for setup and usage.

3. OpenCV with YOLO – Vision-Based Automation

OpenCV is a computer vision library that, when combined with YOLO (You Only Look Once), enables object detection for interactive automation workflows.

Key Features:

Real-Time Object Detection: Detects and identifies things on the screen or in videos instantly.
Adaptable for Video and GUI: Great for dynamic interactions, like recognizing buttons or specific items in videos.
High Accuracy: YOLO’s model training means it’s good at knowing exactly what it’s looking at.

Use Case: Enabling bots to interact visually with applications, such as locating and clicking buttons in an application or recognizing visual patterns to trigger specific workflows.

Getting Started: Install OpenCV with pip install opencv-python and download YOLO models. OpenCV’s documentation is available here, while YOLO resources can be found on the YOLO website.

4. Hugging Face Transformers – High-Power NLP Models

Hugging Face Transformers is a library of pre-trained NLP models that cover a variety of text-based tasks, from summarization to translation.

Key Features:

Wide Range of Skills: Models for everything from summarizing content to translating languages and understanding tone.
Super Adaptable: You can fine-tune these models for your specific needs.
Community Favorites: Access popular models like GPT-2, BERT, and more.

Use Case: Automating customer interactions by using NLP models to analyze sentiment, categorize inquiries, and generate automated responses in a conversational style.

Getting Started: Install Hugging Face Transformers with pip install transformers, and check their extensive documentation.

5. Google Cloud Vision – Comprehensive Image Recognition

Google Cloud Vision provides powerful image and document recognition capabilities, integrating seamlessly with RPA workflows for intelligent document handling.

Key Features:

Smart Image Reading: It doesn’t just see text; it recognizes faces, objects, and more.
Reads Complex Layouts: Good for reading documents with complicated layouts or multiple sections.
Supports Many Languages: Ideal if you work with documents in multiple languages.

Use Case: Digitizing and categorizing physical documents, such as scanned forms or IDs, by reading and extracting key information to populate digital records.

Getting Started: Sign up for Google Cloud and activate the Vision API. Their documentation provides setup details and usage examples.

6. OpenAI API (GPT models) – Generative Text and Decision Support

The OpenAI API provides access to the powerful GPT language models, which can generate human-like text and offer conversational abilities.

Key Features:

Human-Like Responses: Can chat or write as if a real person is responding.
Multi-Tasking: Does everything from answering questions to summarizing content and translating.
Flexible Integration: Easy to plug into your automation setup for all sorts of text-based tasks.

Use Case: Enabling interactive customer support bots that can provide answers, assist with inquiries, and escalate issues to human agents when needed.

Getting Started: Access the OpenAI API by signing up at OpenAI’s website.

7. Microsoft Azure Cognitive Services – Versatile AI Models for Automation

Azure Cognitive Services offers a suite of AI tools covering vision, speech, language, and decision-making, helping drive intelligent automation.

Key Features:

Full Spectrum of Abilities: From translating speech to recognizing text and images, it’s an all-in-one package.
Ready-Made Models: Pre-trained models make it easy to get started.
Scalable for Big Projects: Works well for small tasks and massive projects alike.

Use Case: Automating call center operations by transcribing calls in real-time, analyzing sentiment, and providing actionable insights for agents.

Getting Started: Sign up on Azure Cognitive Services and start using their pre-trained AI models.

8. Scikit-Learn – Foundational Machine Learning

Scikit-Learn is a machine learning library that provides algorithms for tasks like classification, regression, and clustering, essential for building predictive RPA workflows.

Key Features:

Lots of Algorithms: Offers tools for everything from predicting trends to clustering similar items.
Simple to Learn: Its straightforward syntax makes it accessible for beginners and pros alike.
Works with Python Libraries: Easily integrates with other Python tools for more powerful workflows.

Use Case: Enabling predictive maintenance by analyzing historical data to forecast equipment failures and schedule proactive repairs.

Getting Started: Install Scikit-Learn with pip install scikit-learn, and explore their extensive documentation.

9. Amazon Textract – Intelligent OCR for Document Automation

Amazon Textract is a machine-learning-based OCR that goes beyond simple text extraction by understanding the structure and hierarchy within documents.

Key Features:

Reads Complex Docs: Extracts data from tables, forms, and even understands multi-page layouts.
Good with Handwriting: Can read both printed and handwritten text, so it’s versatile.
AWS-Friendly: Built to work seamlessly with other AWS tools, making scaling easy.

Use Case: Automating loan application processing by extracting and organizing information from scanned documents, reducing the manual effort needed for data entry.

Getting Started: Set up Textract via the AWS console. Detailed documentation is available on AWS Textract.

10. DataRobot – AutoML for Predictive Analytics in RPA

DataRobot is an AutoML platform that automates the process of building, training, and deploying machine learning models, ideal for adding predictive capabilities to RPA workflows.

Key Features:

Automated Model Building: No need to be a data scientist; it helps pick the right model and trains it for you.
High Accuracy: Helps you find the best model quickly, which means more accurate predictions.
Real-Time Predictions: Can handle large datasets and make real-time predictions as your data changes.

Use Case: Building predictive models to optimize customer churn management, helping businesses proactively engage customers at risk of leaving.

Getting Started: Explore DataRobot’s platform and resources to see how AutoML can integrate with RPA.

So there you have it—10 powerful AI tools that can seriously level up your RPA game. Gone are the days of simple, rule-based automation; now, with these packages, you’re working with systems that can analyze, predict, and make your workflows smarter and way more adaptable.

Whether you’re knee-deep in automation as a developer, architect, or just someone looking to explore what AI can bring to the table, these tools are worth a try. Start experimenting, have some fun with it, and see how these packages can transform your workflows.

Happy automating! 🚀

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com

Credits: Photo by cottonbro studio

🔥 Build Your Own AI-Powered Chrome Extension 🧩

Santhosh Vijayabaskar — Wed, 30 Oct 2024 03:00:08 +0000

Ever find yourself scrolling through endless articles and news pages, just hoping to get the main points and move on? Yeah, me too. It’s exhausting, right? 😩 Well, here’s a little shortcut we’re going to build together! 💪

We’re going to make a Chrome extension that scrapes content from any webpage 🌐, whips up a quick summary with a bit of AI magic 🪄, and—here’s the fun part—reads it out loud for you 🔊. Super convenient, don’t you think?

By the end, you’ll have something that not only saves you time ⏱️ but also gives you that little boost of, ‘Hey, I built this!’ 😎

Here’s what we’re working with:

Cheerio: Think of Cheerio as the friend that helps us skim through HTML and grab the important stuff. It’ll make sure we’re only pulling what we need from each page.
Hugging Face Transformers: These AI models do the heavy lifting with summarization. We’ll use them to shrink long pages down to the essentials—no unnecessary fluff.
ResponsiveVoice.js: This adds the final touch by reading out the summary. It’s surprisingly simple to use, and there are lots of voices and languages to pick from.

By the end, you’ll have built an AI-powered Chrome extension, and along the way, you’ll pick up some solid skills in JavaScript, web scraping, and using AI models. Don’t worry if you’re new to this—I’ll guide you through it, and by the end, you’ll have something genuinely cool and useful to show off. Let’s get started! 🚀

🪄 Step 1: Setting Up Your Chrome Extension

First, let’s get the basic Chrome extension structure in place. We’ll create three files for this setup:

manifest.json - Configures our Chrome extension.
popup.html - The user interface for the extension.
popup.js - Contains JavaScript code to interact with the content and run summarization.

Create the Project Structure

Set up your project folder with the following structure:

/summarize-tool
|-- manifest.json
|-- popup.html
|-- popup.js

1.1 manifest.json: The Blueprint of Your Extension
The manifest file is what Chrome reads to know how to run and interact with our extension. Here’s what it should look like:

{
  "manifest_version": 3,
  "name": "Summarize Tool",
  "version": "1.0",
  "description": "A Chrome extension that scrapes and summarizes content from any webpage.",
  "permissions": ["scripting", "tabs", "activeTab"],
  "background": {
    "service_worker": "background.js"
  },
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "icons/icon16.png",
      "48": "icons/icon48.png",
      "128": "icons/icon128.png"
    }
  },
  "host_permissions": ["<all_urls>"]
}

This setup tells Chrome what the extension does, which files are in use, and what permissions it needs (like accessing the current webpage’s content).

1.2 popup.html: Creating the Extension Interface
Now let’s add some basic HTML to give users a button to trigger the summarization and text-to-voice features.

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Summarize Tool</title>
</head>
<body>
    <h2>Summarize This Page</h2>
    <button id="summarize-btn">Summarize</button>
    <div id="summary" style="margin-top: 15px; font-size: 14px;"></div>
    <button id="read-summary" style="margin-top: 15px;">Read Out Loud</button>
    <script src="popup.js"></script>
</body>
</html>

This simple layout gives us two buttons: one for summarizing the page and another for reading the summary out loud.

🔍 Step 2: Extracting Content with DOMParser

Now that our extension is set up, let’s dive into getting the content we want from any webpage. We’ll use DOMParser to retrieve and parse HTML directly in the Chrome extension environment.

🤔 Why DOMParser?
DOMParser allows us to extract the main text from a webpage without needing external libraries, making it efficient and compatible with Chrome extensions.

Here’s what we’ll do:

When the "Summarize" button is clicked, the DOMParser will grab the main content on the page.
This content will then be passed along to Hugging Face for summarization.
Here’s the code for popup.js to extract the content:

document.getElementById("summarize-btn").addEventListener("click", async () => {
    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });

    chrome.scripting.executeScript({
        target: { tabId: tab.id },
        func: getPageContent,
    }, (results) => {
        if (results && results[0] && results[0].result) {
            const htmlContent = results[0].result;
            parseAndSummarizeContent(htmlContent);
        }
    });
});

// Function to retrieve the page’s HTML content
function getPageContent() {
    return document.documentElement.outerHTML;
}

// Function to parse the HTML content and extract the main text
function parseAndSummarizeContent(htmlContent) {
    const parser = new DOMParser();
    const doc = parser.parseFromString(htmlContent, "text/html");

    // Extract specific elements or paragraphs
    const paragraphs = Array.from(doc.querySelectorAll("p"));
    let bodyText = paragraphs.slice(0, 3).map(p => p.innerText).join(" ");

    // Limit to 500 characters for API to prevent server errors
    if (bodyText.length > 500) {
        bodyText = bodyText.substring(0, 500);
    }

    // Send the trimmed text for summarization
    summarizeContent(bodyText);
}

Now, whenever the button is clicked, this function will grab the main content of the page, trimmed to avoid API overload.

🧠 Step 3: Summarizing Content with Hugging Face Transformers

Next up, let’s condense that content with Hugging Face Transformers!

🤔 Why Hugging Face?
Hugging Face provides AI models that can do heavy-duty tasks, like turning a long article into a short summary. We’ll use their summarizer model to cut down the text into the key points.

To do this, you’ll need an API key from Hugging Face. Once you have that, here’s how to set up the API call in popup.js:

async function summarizeContent(content, retries = 3, delay = 1000) {
    const API_URL = "https://api-inference.huggingface.co/models/sshleifer/distilbart-cnn-12-6";
    const API_KEY = "YOUR_HUGGING_FACE_API_KEY";

    console.log("Sending content to summarize:", content); // Log the content being sent

    for (let attempt = 1; attempt <= retries; attempt++) {
        try {
            const response = await fetch(API_URL, {
                method: "POST",
                headers: {
                    "Authorization": `Bearer ${API_KEY}`,
                    "Content-Type": "application/json"
                },
                body: JSON.stringify({ inputs: content })
            });

            if (response.ok) {
                const summaryData = await response.json();
                const summary = summaryData[0]?.summary_text || "Summary not available.";
                document.getElementById("summary").innerText = summary;
                return;
            } else if (response.status === 503) {
                console.error(`Attempt ${attempt}: Server unavailable (503). Retrying in ${delay}ms...`);
                await new Promise(resolve => setTimeout(resolve, delay));
                delay *= 2; // Exponential backoff
            } else {
                console.error("Error in response:", response.status, response.statusText);
                document.getElementById("summary").innerText = "Error: Unable to fetch summary.";
                return;
            }

        } catch (error) {
            console.error("Error:", error);
            document.getElementById("summary").innerText = "Error: Unable to fetch summary.";
            return;
        }
    }

    document.getElementById("summary").innerText = "Error: Unable to fetch summary after multiple attempts.";
}

This code sends the content to Hugging Face, and the response will be a short summary that gets displayed in our popup. Now you’ve got the power of AI summarization with retry logic!

🔊 Step 4: Adding Text-to-Voice with Web Speech API

Let’s add the finishing touch by allowing users to hear the summary! The Web Speech API provides a simple way to convert text to speech directly in the browser.

In popup.js, add the functionality to read out the summary:

document.getElementById("read-summary").addEventListener("click", () => {
    const summaryText = document.getElementById("summary").innerText;
    if (summaryText) {
        const utterance = new SpeechSynthesisUtterance(summaryText);
        utterance.lang = "en-US"; // Adjust language as needed
        window.speechSynthesis.speak(utterance);
    } else {
        alert("No summary available to read.");
    }
});

Now when you click “Read Out Loud,” the summary will be spoken, giving you a hands-free experience!

Step 5: Testing the Extension 🚀

Time to see it in action!

Head over to chrome://extensions/, enable Developer Mode, and click Load unpacked to load your extension.

Now, open a webpage, click the extension icon, and test the summarization and voice features.

It’s a good idea to test on different pages to make sure it’s working smoothly.

✨ Step 6: Fine-Tuning and Enhancements

Here are a few ideas to make this extension even better:

Experiment with Summarization Models: Hugging Face has different models, so try others to see if one works better for your needs.
Add a Language Selector: ResponsiveVoice supports multiple languages, so why not add a selector for users who prefer a different language?
Adjust Summary Length: Give users the option to choose between short, medium, and long summaries for more customization.

And that’s it! 🎉 You’ve built a powerful, time-saving Chrome extension that combines scraping, summarizing, and text-to-speech. Not only does it save time, but it’s also a tool you can genuinely use every day. Enjoy showing off your creation!

P.S.: I ran into a few NPM errors specific to my setup—if you hit any snags, feel free to reach out for help!

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com

Credits:
Photo by Firmbee.com on Unsplash

🤖 AI in DevOps: Tools 🧰 and Trends 🔥 You Need to Know

Santhosh Vijayabaskar — Sun, 27 Oct 2024 20:42:13 +0000

Hey Devs! 👋 In the AI Hands-On Series, we’ve been digging into how AI is making a difference across all sorts of tech spaces—from automating routine tasks to making smarter predictions. So far, we’ve looked at ways AI tools help us tackle challenges that were once just part of the grind, giving us back more time to innovate.

Today, we’re zooming in on DevOps and how AI is reshaping DevOps, adding intelligence to everything from code deployment to monitoring, and making life a whole lot easier for us.

With AI in the mix, some teams are reporting up to 30% faster release cycles and seeing 40% fewer errors in deployment. 🚀

Imagine using tools that learn from past data to predict issues before they even happen or automating tedious tasks that are used to slow down releases. Let’s look at the key tools and packages driving these changes and explore how they’re transforming the way we build, deploy, and manage applications!

Ready? Let’s dive in!

What is DevOps?

If you’re new to DevOps, think of it as the ultimate team-up between development and operations, aimed at delivering software faster and smoother. It’s not just about tools or processes—it’s a whole approach that gets Dev and Ops working side-by-side to keep code flowing seamlessly from a developer’s laptop to live production.

DevOps makes releasing, monitoring, and improving software a continuous, more efficient cycle—so instead of just pushing out updates, you’re building a culture that adapts and scales with the pace of modern development."

AI in DevOps

AI in DevOps isn't about replacing DevOps engineers with robots. It's about making the software deployment and monitoring pipelines smarter and more predictive - so that we can move beyond manual configurations and guesswork and let the tools anticipate, diagnose, and rectify issues with minimal human intervention

Key Benefits of AI in DevOps

Proactive Monitoring: AI can identify issues before they cause problems.
Faster Development: AI tools like Copilot assist with coding and reviewing, making development smoother.
Smarter CI/CD Pipelines: Predictive analysis lets teams anticipate deployment success, making releases more stable.

AI Trends in DevOps: What You Need to Know?

1. AI-Driven Monitoring: Spotting Issues Before They Happen

One of the most valuable applications of AI in DevOps is in monitoring and alerting. Let’s be honest: manually going through logs or responding to every alert can get overwhelmingly fast. This is where AI steps in to make things easier.

How It Works
AI-powered monitoring tools learn what “normal” behavior looks like over time and alert you when something’s off. Think of it as having a watchful eye on your system 24/7, catching issues before they impact users. AI helps sift through the noise, focusing on anomalies so you can act before problems escalate.

Tools to Try

Prometheus + Grafana with Machine Learning: Prometheus is widely used for monitoring, and you can extend its capabilities with ML models in Grafana to predict anomalies in metrics.
Elasticsearch and Kibana: These tools help visualize data from logs, and with some configuration, you can set up basic anomaly detection.

How to get started:
Start by setting up anomaly detection on your logs or metrics and adjusting alerts to focus on priority events. This small step helps you prioritize real issues without drowning in notifications. Even basic anomaly detection can save hours of sifting through logs!

2. AI-Assisted Code Completion and Review

Imagine you’re writing code, and an AI tool suggests improvements or even completes certain lines for you. This is a game-changer for both new and seasoned DevOps engineers, as it reduces coding errors, saves time, and keeps quality high.

How It Works
These tools use machine learning models trained on tons of code to make suggestions based on context. So, instead of writing everything from scratch, you get smart recommendations that match your coding style and DevOps practices.

Tools to Try

GitHub Copilot: Integrated into most editors, Copilot provides real-time code suggestions. It’s especially handy for infrastructure as code.
Tabnine: Works with various languages and environments, assisting with code suggestions tailored to your context.

How to get started:
Experiment with AI code assistance for repetitive tasks in your CI/CD scripts or infrastructure code. These tools can highlight best practices and catch mistakes, helping you avoid common pitfalls and reducing the time you spend on code reviews.

3. CI/CD Optimization with Predictive Analysis

Continuous integration and deployment (CI/CD) pipelines are the heartbeat of DevOps, but they’re also where things can break down if not managed properly. This is where AI shines by helping to identify patterns in failed builds and flagging code that might need extra testing before deployment.

How It Works
AI analyzes historical data from previous builds to identify patterns that predict failures. Based on these patterns, it can make recommendations for your pipeline configurations, or even suggest code areas that may need closer testing.

Tools to Try

Jenkins with ML Plugins: Jenkins supports plugins for ML analysis, which can analyze build data to forecast issues.
Spinnaker with Canary Analysis: Spinnaker, a multi-cloud continuous delivery platform, integrates AI for “canary analysis,” where it tests new releases on a small subset of users and rolls back if issues are detected.

How to get started:
Add predictive analysis to your CI/CD pipelines. You can start small by reviewing failure trends or implementing basic canary analysis to test deployments incrementally. This lets you catch issues early and deliver smoother, more reliable deployments.

4. Smart Incident Management and Response

When issues do arise, AI can also help with incident management by prioritizing alerts based on their urgency and impact. Rather than a flood of alerts hitting the team, AI-powered incident management tools create “incident clusters,” grouping related alerts so you can respond efficiently.

How It Works
Incident management tools with AI analyze data from logs, metrics, and alerts to prioritize and group issues. They help you address high-impact incidents first, while also managing related events in one place.

Tools to Try

Moogsoft: Uses AI to cluster alerts and provides a prioritized list of incidents, saving you from alert fatigue.
PagerDuty with Machine Learning: Integrates AI to handle incident response, learning from past incidents to recommend steps in response.

How to get started:
If you’re in a high-alert environment, using AI to manage incident responses can be a big relief. By clustering related alerts and focusing on critical issues first, these tools allow teams to respond faster and reduce burnout.

5. AI-Enhanced Testing: Faster and More Reliable

Testing is a huge part of DevOps, and it can be tedious if done manually. AI-driven testing tools help you automate test creation, identify missing tests, and optimize test cases for better coverage and reliability.

How It Works
AI-enhanced testing tools analyze your codebase and automatically create test cases, often focusing on areas prone to bugs. They can also prioritize tests based on their impact, so you’re always testing what matters most.

Tools to Try

Testim: Generates automated test cases based on user flows, helping you catch issues faster.
Applitools: Uses visual AI to detect visual bugs in web applications, which can be tricky to catch with traditional testing.

How to get started:
Automating parts of your testing process, especially repetitive or high-importance tests, can help you catch issues faster and ensure each release is stable. This is especially useful if your team pushes frequent updates.

With these tools doing some of the heavy lifting, we’re freeing up more time to focus on the things that really matter.

If you’re using any other AI tools or have interesting projects that are supercharging your DevOps, drop them in the comments! Let’s keep the conversation going and share tips for building even better pipelines. Thanks for tuning in—here’s to working smarter and building faster!

PS: Don't forget to check out my other articles on AIHandsOn Series for more interesting projects on AI! 🚀

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com

🤖 Building a Financial AI Chatbot with Rasa: A Hands-On Guide 🌱

Santhosh Vijayabaskar — Sun, 27 Oct 2024 01:38:36 +0000

The Chatbots and intelligent virtual assistants market is projected to grow at a CAGR of 22% between 2020 and 2025, potentially reaching nearly $14 billion by 2025.📈

When it comes to the world of chatbots 🤖, not all the bots are the same. Think of the simplest chatbots, those that stick to set scripts and respond to exact phrases—like an FAQ section come to life. These are rule-based bots and can be helpful but often feel a bit, well, robotic.

Then there are retrieval-based bots that look for the best match from pre-existing responses, leveraging machine learning to be more flexible with language. These are good but still limited, especially if you’re looking for real interaction and multi-turn conversations.

Finally, we have conversational AI bots—the real stars of the chatbot world 🌟. They go beyond just answering questions; they’re context-aware, meaning they can remember details, adapt based on the conversation, and feel more like a human chat. And this is where Rasa comes in. With Rasa, you can build a bot that’s genuinely smart, customizable, and responsive to individual users.

🤖 What is Rasa?

Rasa is an open-source framework for building chat and voice-based AI assistants. Rasa lets us control every step of the chatbot's workflow.

Behind the Scenes: How Rasa’s Conversational AI Works

Here’s a glimpse of what’s happening under the hood with Rasa:

Intent Recognition: The bot uses machine learning to identify user intent (e.g., “check balance”) based on trained examples, allowing it to interpret even varied phrasings.
Entity Extraction: Rasa recognizes specific details, or entities (like “account balance” or “loan eligibility”), from the user’s input to respond accurately.
Dialogue Management: Rasa’s dialogue policies and stories control the conversation flow, remembering previous interactions and guiding the bot to respond contextually.

What You’ll Build in This Tutorial

In this tutorial, we’ll bring these elements together to create a financial AI chatbot capable of assisting with common banking inquiries. By the end, you’ll have the skills to expand this bot further, adapt it to specific use cases, and understand the core of conversational AI.

✨Let’s get started!🚀

Step 1: Set Up Your Project

Let’s start by creating a new Rasa project. Open your terminal and from your project directory, type:

rasa init --no-prompt

This command sets up the files we’ll be working with, like nlu.yml for defining intents and stories.yml for conversation flows.

Step 2: Defining Intents

Think of an “intent” as what the user wants to do. For example, when someone says “Hey!” they want to greet the bot. Let’s add a few intents to teach Rasa how to recognize them:

Open data/nlu.yml and add some examples:

- intent: greet
  examples: |
    - hello
    - hi there
    - hey

Great job! Now, let’s train the model so Rasa can understand these intents. In your terminal, run:

rasa train

Step 3: Creating Conversation Flows

Next, we’ll map out conversation flows. Think of it as scripting a conversation—what should the bot say when someone greets it?

a. Open data/stories.yml and add this story

- story: greet path
  steps:
    - intent: greet
    - action: utter_greet

Now, the bot will respond with “utter_greet” whenever someone says hello!

Step 4: Defining Responses

Let’s make the bot sound friendly! In domain.yml, define what “utter_greet” should say:

responses:
  utter_greet:
    - text: "Hello! How can I assist you today?"

Feel free to get creative with responses—this is your chatbot, after all!

Real-World Case Study: Finance Chatbot

Let’s take this up a notch. Imagine a bank chatbot that can answer questions about account balances and loan eligibility.

a. Add a check_balance intent in nlu.yml:

- intent: check_balance
  examples: |
    - What is my account balance?
    - Show my balance

- intent: loan_eligibility
  examples: |
    - Am I eligible for a loan?
    - Can I get a loan?
    - What’s my loan eligibility?

In nlu.yml, we’re teaching the bot to recognize user intents: if they ask about balance, it’s check_balance; for loans, it’s loan_eligibility. This setup helps the bot understand and respond accurately

b. Define a Custom Action in actions/actions.py to handle balance requests:

from rasa_sdk import Action

class ActionCheckBalance(Action):
    def name(self):
        return "action_check_balance"

    def run(self, dispatcher, tracker, domain):
        # Example logic for retrieving balance
        balance = "$10,000"
        dispatcher.utter_message(text=f"Your balance is {balance}.")
        return []

class ActionCheckLoanEligibility(Action):
    def name(self):
        return "action_check_loan_eligibility"

    def run(self, dispatcher, tracker, domain):
        # Placeholder logic for loan eligibility
        eligibility_status = "You're eligible for a loan up to $50,000!"
        dispatcher.utter_message(text=eligibility_status)
        return []

In the above code, we set up a custom action called ActionCheckBalance for the bot. When a user asks about their balance, this action responds with a set balance of "$10,000." Think of it as a placeholder—later, you can link it to actual account data for live results!

For eligibility status, I have set to respond with "You're eligible for a loan up to $50,000!" as a placeholder. Similar to account balance action, you can also replace it with actual calculations or criteria.

c. In stories.yml, add this flow for the balance check:

- story: check balance path
  steps:
    - intent: check_balance
    - action: action_check_balance

- story: check loan eligibility path
  steps:
    - intent: loan_eligibility
    - action: action_check_loan_eligibility

In the above stories.yml, we're mapping user paths: if they ask for a balance, the bot triggers action_check_balance; for loans, it triggers action_check_loan_eligibility. This guides the bot’s responses based on user intent!

Step 5: Testing and Fine-Tuning

Time to test it! In your terminal, run:

rasa interactive

This lets you simulate real conversations and adjust responses on the go.

🎉 Congratulations! Your chatbot can now handle basic finance queries.

Remember, the world of conversational AI is constantly evolving, and every tweak you make to your bot brings it closer to a more natural, human-like interaction. So, keep experimenting, stay curious, and don’t be afraid to explore new possibilities with Rasa and conversational AI. Who knows? This might just be the start of your very own AI-driven customer experience journey 🌱.

Scaling Up: Going Beyond Basics

For those ready to dive deeper:

Deploy to Multiple Platforms: Consider integrating with Slack/MS Teams or a custom API for a broader reach.
Advanced Response Customization: Add Rasa custom pipelines or integrate with external databases.

More Recommended Reading on this topic

Rasa Documentation for in-depth guidance.
Conversational Design Best Practices for user-centric tips.

Happy building!🏆 Don't forget to check out my other articles on AIHandsOn Series for more interesting projects on AI! 🚀

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com

Building Your First AI Agent with LangChain and Open APIs

Santhosh Vijayabaskar — Thu, 24 Oct 2024 12:04:46 +0000

I am sure we all have been hearing about AI agents and are not sure where to begin 🤔; no worries—you're in the right place! In this article, I am going to introduce you to the world of AI Agents and walk you through step-by-step how to build your first AI agent with LangChain.

LangChain is an incredibly useful tool for connecting AI models to various outbound APIs. In this guided tutorial, we will build our first Agent and connect it to Open API Weather data 🌦️ to make it more interactive and practical.

By the time we're done, you will have your own AI agent 🤖, which can chat, pull in live data, and do so much more!

🤖 What is an AI Agent? Let’s Break it Down

AI Agents are like a supercharged virtual assistant that’s always ready to help. Whether it’s answering your questions, doing small tasks for you, or even making decisions, this AI agent is like having a digital helper at your disposal. It can do everything from fetching data to creating content or even having a conversation with you. Pretty cool, right?😎

AI agents aren’t just static—they’re smart, dynamic, and capable of working on their own, thanks to the power of large language models (LLMs) like GPT-3 or GPT-4.

🧩 What is LangChain? A Developer-Friendly Powerhouse

LangChain is a developer-friendly framework that connects AI models (like GPT-3 or GPT-4) with external tools and data. It helps create structured workflows where the AI agent can talk to APIs or databases to fetch information.

Why LangChain?

Easy to use: It simplifies integrating large language models with other tools (Jira, Salesforce, Calendars, Database, etc).
Scalable: You can build anything from a basic chatbot to a complex multi-agent system.
Community-driven: With a large, active community, LangChain provides a wealth of documentation, examples, and support.

In our case, we’re building a simple agent that can answer questions, and to make things cooler, it’ll retrieve real-time data like weather information. Let's dive in!

Step 1: Setting Up Your Environment

In this section, let's set up our development environment.

1.1 Install Python (if you haven’t already)

Make sure you have Python installed. You can download it from python.org. Once installed, verify it by running:

python --version

1.2 Install LangChain
Now let’s install LangChain via pip. For those who are new to Python, PIP is a package manager for Python packages. Open your terminal and run:

pip install langchain

1.3 Install OpenAI
We’ll also be using the OpenAI API to interact with GPT-3, so you’ll need to install the OpenAI Python client:

pip install openai

1.4 Set Up a Virtual Environment (Optional)
It’s a good practice to work in a virtual environment to keep your project dependencies separate:

python -m venv langchain-env
source langchain-env/bin/activate   # For Mac/Linux

# or for Windows
langchain-env\Scripts\activate

Step 2: Building Your First AI Agent

Now comes the fun part—let’s build our first AI agent! In this step, we’ll create an agent that can have a simple conversation using OpenAI’s language model. For this, you’ll need an API key from OpenAI, which you can get by signing up at OpenAI.

Here’s a small snippet to create your first agent:

from langchain.llms import OpenAI

# Initialize the model
llm = OpenAI(api_key="your-openai-api-key")

# Define a prompt for the agent
prompt = "What is the weather like in New York today?"

# Get the response from the AI agent
response = llm(prompt)
print(response)

In the above code, we’re setting up a very basic agent that takes a prompt (a question about the weather) and returns a response from GPT-3. At this point, the agent doesn’t actually retrieve live weather data—it’s just generating a response based on the language model’s knowledge.

Step 3: Connecting to an Open API (Weather API)

Now let’s step things up by integrating real-time data into our agent. We’re going to connect it to a weather API, which will allow the agent to retrieve live weather information 🌦️.

Here’s how you do it.

Get an API Key from OpenWeather
Head over to OpenWeather and sign up for a free API key.
Make the API Request
In this next part, we’ll modify our agent so that it fetches live weather data from OpenWeather’s API, and then outputs it as part of the conversation.

import requests
from langchain.llms import OpenAI

def get_weather(city):
    api_key = "your-openweather-api-key"
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
    response = requests.get(url).json()

    # Extract relevant data
    temp = response['main']['temp']
    description = response['weather'][0]['description']
    return f"The current temperature in {city} is {temp}°C with {description}."

# Now use the LangChain LLM model to integrate this data
llm = OpenAI(api_key="your-openai-api-key")
city = "New York"
weather_info = get_weather(city)
prompt = f"Tell me about the weather in {city}: {weather_info}"

response = llm(prompt)
print(response)

In the above code, the get_weather function makes a request to the OpenWeather API and extracts data like temperature and weather description.

The response is then integrated into the AI agent’s output, making it look like the agent is providing up-to-date weather information.

Step 4: Deploying Your AI Agent as an API

Now that our agent can chat and retrieve live data, let’s make it accessible to others by turning it into an API. This way, anyone can interact with the agent through HTTP requests.

Using FastAPI for Deployment

FastAPI is a powerful web framework that makes it easy to create APIs in Python. Here’s how we can deploy our agent using FastAPI:

from fastapi import FastAPI
from langchain.llms import OpenAI
import requests

app = FastAPI()

def get_weather(city):
    api_key = "your-openweather-api-key"
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
    response = requests.get(url).json()
    temp = response['main']['temp']
    description = response['weather'][0]['description']
    return f"The weather in {city} is {temp}°C with {description}."

llm = OpenAI(api_key="your-openai-api-key")

@app.get("/ask")
def ask_question(city: str):
    weather = get_weather(city)
    prompt = f"Tell me about the weather in {city}: {weather}"
    response = llm(prompt)
    return {"response": response}
Now you can run this API locally and access it by sending HTTP requests to http://localhost:8000/ask?city=New York.

Conclusion: What’s Next?

Congratulations!🎉 You’ve just built your first AI agent from scratch and connected it to an open API to fetch real-time data. You’ve also deployed your agent as an API that others can interact with. From here, the possibilities are endless—you can integrate more APIs, build multi-agent systems, or deploy it on cloud platforms for broader use.🚀

If you’re ready for more 🔥, and want to explore advanced features of LangChain, like memory management for long conversations, or dive into multi-agent systems to handle more complex tasks, do let me know in the comments below.

Have fun experimenting, and feel free to drop your thoughts in the comments below!💬

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com

Build Your Own AI Language Model with Python and NumPy

Santhosh Vijayabaskar — Fri, 18 Oct 2024 23:35:15 +0000

Artificial Intelligence is everywhere these days, and language models are a big part of that. We all have always wondered how AI can predict the next word in a sentence or even write entire paragraphs. In this tutorial, we’ll build a super simple language model without relying on fancy frameworks like TensorFlow or PyTorch—just plain Python and NumPy.

Sounds cool? Let’s get started!🚀

What We’re Building:

We'll be creating a bigram model. It predicts the next word in a sentence based on the current word. We’ll keep it straightforward and easy to follow so you’ll learn how things work without getting buried in too much detail.🧠💡

Step 1: Set Up

Before we begin, let's make sure you’ve got Python and NumPy ready to go. If you don’t have NumPy installed, quickly install it with:

pip install numpy

Step 2: Understanding the Basics

A language model predicts the next word in a sentence. We’ll keep things simple and build a bigram model. This just means that our model will predict the next word using only the current word.

We’ll start with a short text to train the model. Here’s a small sample we’ll use:

import numpy as np

# Sample dataset: A small text corpus
corpus = """Artificial Intelligence is the new electricity.
Machine learning is the future of AI.
AI is transforming industries and shaping the future."""

Step 3: Preparing the Text

First things first, we need to break this text into individual words and create a vocabulary (basically a list of all unique words). This gives us something to work with.

# Tokenize the corpus into words
words = corpus.lower().split()

# Create a vocabulary of unique words
vocab = list(set(words))
vocab_size = len(vocab)

print(f"Vocabulary: {vocab}")
print(f"Vocabulary size: {vocab_size}")

Here, we’re converting the text to lowercase and splitting it into words. After that, we create a list of unique words to serve as our vocabulary.

Step 4: Map Words to Numbers

Computers work with numbers, not words. So, we’ll map each word to an index and create a reverse mapping too (this will help when we convert them back to words later).

word_to_idx = {word: idx for idx, word in enumerate(vocab)}
idx_to_word = {idx: word for word, idx in word_to_idx.items()}

# Convert the words in the corpus to indices
corpus_indices = [word_to_idx[word] for word in words]

Basically, we’re just turning words into numbers that our model can understand. Each word gets its own number, like “AI” might become 0, and “learning” might become 1, depending on the order.

Step 5: Building the Model

Now, let’s get to the heart of it: building the bigram model. We want to figure out the probability of one word following another. To do that, we’ll count how often each word pair (bigram) shows up in our dataset.

# Initialize bigram counts matrix
bigram_counts = np.zeros((vocab_size, vocab_size))

# Count occurrences of each bigram in the corpus
for i in range(len(corpus_indices) - 1):
    current_word = corpus_indices[i]
    next_word = corpus_indices[i + 1]
    bigram_counts[current_word, next_word] += 1

# Apply Laplace smoothing by adding 1 to all bigram counts
bigram_counts += 0.01

# Normalize the counts to get probabilities
bigram_probabilities = bigram_counts / bigram_counts.sum(axis=1, keepdims=True)

print("Bigram probabilities matrix: ", bigram_probabilities)

Here’s what’s happening:

We’re counting how often each word follows another (that's the bigram).
Then, we turn those counts into probabilities by normalizing them.
In simple terms, this means that if "AI" is often followed by "is," the probability for that pair will be higher.

Note: When we use bigram_count += 0.01, we're applying Laplace smoothing with a small adjustment to avoid zero probabilities when certain word pairs don't appear in the corpus. This ensures that every word pair has a slightly positive probability, even if it’s rare, and helps prevent issues like division errors during the normalization process. By using a smaller value like 0.01, we strike a balance between avoiding zeros and not overly inflating probabilities for unseen word pairs.

Step 6: Predicting the Next Word

Let’s now test our model by making it predict the next word based on any given word. We do this by sampling from the probability distribution of the next word.

def predict_next_word(current_word, bigram_probabilities):
    word_idx = word_to_idx[current_word]
    next_word_probs = bigram_probabilities[word_idx]
    next_word_idx = np.random.choice(range(vocab_size), p=next_word_probs)
    return idx_to_word[next_word_idx]

# Test the model with a word
current_word = "ai"
next_word = predict_next_word(current_word, bigram_probabilities)
print(f"Given '{current_word}', the model predicts '{next_word}'.")

This function takes a word, looks up its probabilities, and randomly selects the next word based on those probabilities. If you pass in "AI," the model might predict something like "is" as the next word.

Step 7: Generate a Sentence

Finally, let's generate a whole sentence! We’ll start with a word and keep predicting the next word a few times.

def generate_sentence(start_word, bigram_probabilities, length=5):
    sentence = [start_word]
    current_word = start_word

    for _ in range(length):
        next_word = predict_next_word(current_word, bigram_probabilities)
        sentence.append(next_word)
        current_word = next_word

    return ' '.join(sentence)

# Generate a sentence starting with "artificial"
generated_sentence = generate_sentence("artificial", bigram_probabilities, length=10)
print(f"Generated sentence: {generated_sentence}")

This function takes an initial word and predicts the next one, then uses that word to predict the following one, and so on. Before you know it, you’ve got a full sentence!

Output

santhoshs-mbp:bigram-language-model santhosh1$ python3 main.py
Vocabulary: ['electricity.', 'artificial', 'future', 'industries', 'intelligence', 'ai.', 'future.', 'new', 'the', 'machine', 'is', 'learning', 'of', 'transforming', 'ai', 'shaping', 'and']
Vocabulary size: 17
Bigram probabilities matrix:  [[0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.11111111 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.11111111 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.11111111 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.11111111]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.11111111 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.11111111 0.05555556 0.05555556]
 [0.05882353 0.05882353 0.05882353 0.05882353 0.05882353 0.05882353
  0.05882353 0.05882353 0.05882353 0.05882353 0.05882353 0.05882353
  0.05882353 0.05882353 0.05882353 0.05882353 0.05882353]
 [0.11111111 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05       0.05       0.1        0.05       0.05       0.05
  0.1        0.1        0.05       0.05       0.05       0.05
  0.05       0.05       0.05       0.05       0.05      ]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.11111111
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05       0.05       0.05       0.05       0.05       0.05
  0.05       0.05       0.15       0.05       0.05       0.05
  0.05       0.1        0.05       0.05       0.05      ]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.11111111 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.11111111
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.11111111 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.11111111 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.11111111 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556]
 [0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
  0.05555556 0.05555556 0.05555556 0.11111111 0.05555556]]
Given 'ai', the model predicts 'ai.'.
Generated sentence: artificial ai. of electricity. ai. artificial future learning artificial of ai.

🚀📂 Check out the complete code for the Bigram Language Model on GitHub.

Wrapping Up

There you have it—a simple bigram language model built from scratch using just Python and NumPy! 🧑‍💻✨ No fancy libraries needed, and now you’ve got a basic idea of how AI can predict text. Feel free to experiment, tweak the code, or even extend it with more advanced models! 🚀

Give it a go, and let me know how it turns out. Happy coding! 😄💻

PS: Got questions or thoughts? 💡 Drop them in the comments! Let’s keep the conversation going! 🔄

🌐 You can also learn more about my work and projects at https://santhoshvijayabaskar.com