Real-Time Sentiment Analysis: Integrating Python NLP with Node.js

Have you ever wished you could mix the best tools from different programming languages in a single project? Imagine taking Python’s powerful natural language processing (NLP) tools and using them directly in your Node.js app without setting up extra APIs or complicated workarounds. Sounds awesome, right? That’s exactly what Javonet lets you do!

Now, picture this: You’re building a chat app that doesn’t just send messages but also understands them. For example, it could detect if a message is happy, neutral, or angry and respond in smart ways. Usually, combining Python and Node.js for something like this would be a hassle—writing APIs, managing multiple servers, or juggling different tools. But with Javonet, it’s quick and simple.

In this article, we’ll show you how to connect Python’s NLP libraries (like textblob) directly to a Node.js app using Javonet. By the end, you’ll have a real-time chat system that can analyze emotions in every message. Let’s dive in and see how easy this can be!

What You’ll Need

Basic knowledge of Python and Node.js.
Python installed with textblob.
Javonet library installed in your Node.js project.
Good mood and willing to experiment :)

Step 1: Setting Up Your Environment

1.1 Install Python and textblob

First, make sure Python is installed. Then, install textblob:

pip install textblob

1.2 Create a Python Script for Sentiment Analysis

Here’s a simple Python function to analyze sentiment:

from textblob import TextBlob

class SentimentAnalyzer:
    @staticmethod
    def get_polarity(text):
        score = TextBlob(text).sentiment.polarity
        if score < 0:
            return 'negative'
        elif score == 0:
            return 'neutral'
        elif score > 0:
            return 'positive'

Save this file as sentiment.py.

1.3 Install Javonet in Your Node.js Project

npm i javonet-nodejs-sdk

Visit Javonet to get more information about starting with Javonet

It's worth visiting Javonet website, to get more information about how to get started with Javonet, here are the exact instructions for NodeJs.

Step 2: Using Javonet to Connect Python with Node.js

2.1 Import and Configure Javonet

const {Javonet} = require('javonet-nodejs-sdk')

// Initialize Javanet
Javonet.activate("your-license-key") // Replace with your Javanet license key

let pythonRuntime = Javonet.inMemory().python()
pythonRuntime.loadLibrary(".")
let calledRuntimeType = pythonRuntime.getType("sentiment.SentimentAnalyzer").execute()

const message = "The movie was so awesome!";
const message2 = "The food here tastes terrible.";

let sentiment = calledRuntimeType.invokeStaticMethod("get_polarity" ,message).execute().getValue()
let sentiment2 = calledRuntimeType.invokeStaticMethod("get_polarity" ,message2).execute().getValue()

console.log(`Message: "${message}" - Sentiment: ${sentiment}`);
console.log(`Message2: "${message2}" - Sentiment: ${sentiment2}`);

Message: "The movie was so awesome!" - Sentiment: positive
Message2: "The food here tastes terrible." - Sentiment: negative

Step 3: Integrating with a Real-Time Chat App

Now that sentiment analysis is working, let’s add it to a real-time chat app using Socket.IO.

3.1 Install Socket.IO

npm install socket.io
npm install express

3.2 Set Up a Basic Chat Server

Here’s a simple chat server chat.js:

const express = require('express');
const http = require('http');
const path = require('path');
const { Server } = require('socket.io');
const { Javonet } = require('javonet-nodejs-sdk');

Javonet.activate("your-license-key");

let pythonRuntime = Javonet.inMemory().python();
pythonRuntime.loadLibrary(".");
let sentimentAnalyzer = pythonRuntime.getType("sentiment.SentimentAnalyzer").execute();

const app = express();
const server = http.createServer(app);
const io = new Server(server);

// Serve the HTML file
app.use(express.static(path.join(__dirname, 'public')));

io.on('connection', (socket) => {
  console.log('A user connected');

  socket.on('chat message', (msg) => {
    let sentiment = sentimentAnalyzer.invokeStaticMethod("get_polarity", msg).execute().getValue();
    socket.emit('sentiment', { message: msg, sentiment });
  });

  socket.on('disconnect', () => {
    console.log('A user disconnected');
  });
});

server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

3.3 Frontend Integration

On the frontend create public/index.html in your working directory, you can use the Socket.IO client to send messages and display their sentiment:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Chat Sentiment Analysis</title>
  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    socket.on('sentiment', (data) => {
      const messageElement = document.createElement('li');
      messageElement.textContent = `Message: "${data.message}" - Sentiment: ${data.sentiment}`;
      document.getElementById('messages').appendChild(messageElement);
    });

    function sendMessage() {
      const message = document.getElementById('message').value;
      socket.emit('chat message', message);
      document.getElementById('message').value = '';
    }
  </script>
</head>
<body>
  <input type="text" id="message">
  <button onclick="sendMessage()">Send</button>
  <ul id="messages"></ul>
</body>
</html>

In the end your project structure should look like this:

/chat-with-javonet/
  ├── chat.js
  ├── sentiment.py
  ├── public/
  │   └── index.html
  └── node_modules/

And now just start it!

node chat.js

What You Get

With this setup, your Node.js chat app can now analyze the sentiment of every message in real-time using Python’s textblob library. The combination of Javonet, Python, and Node.js ensures that you’re using the best tools for each task without unnecessary complexity