Cloudinary Blog

Building a Smart AI Image Search Tool Using React - Part 2: UI Components and Server Setup

Building a Smart AI Image Search Tool Using React Part 2

In our first article, we built a part of the front-end of our image search tool with the focus mainly on the parent App.js stateful component.

In this article - part two of a series - we will continue developing a AI image Search App, in which users can search for content in an image, not just the description. The app is built with React for UI interaction, Cloudinary for image upload and management and Algolia for search.

We will show how to complete the app. I know you must be stoked, I am too. We will be building the stateless components of our app and these components without state will mostly receive props from the parent component as with parent-child communication existing in React. Also the server-side of our app will be built and deployed to Webtask. You can read more about webtasks here.

Webinar
Marketing Without Barriers Through Dynamic Asset Management

Installation

All build tools and dependencies have been installed in the first part so we can move on with building.

The Custom Stateless Components

The stateless components are the ImageList component and the modal component. These display the list of images fetched from Algolia and the upload modal interface respectively. The action of buttons on the interface have already been configured in the parent App.js component and will be passed down to the child stateless components via props as earlier stated.

The ImageList Component

This component holds the images saved on the webtask server. In configuring the component, navigate to the ImageList.js file in the components folder and configure it like this:

Copy to clipboard
import React from 'react';
import {Image, CloudinaryContext, Transformation} from 'cloudinary-react';
import './ImageList.css';
export default ({ hit }) => {
  return (
    <div className="card">
      <div className="card-content">
        <Image publicId={hit.public_id}>
            <Transformation format=auto quality=auto />
         </Image>
        <p>{hit.description}</p>
      </div>
    </div>
  );
};

First, we import all dependencies and its CSS file. Since the component is stateless, props are just passed as parameter to the export function which returns JSX elements. The Cloudinary React component exposes Image and Transformation which helps with fetching the image from the Cloudinary server and setting transformations respectively. The interesting thing is that the transformation sets format and quality to auto. This renders the best optimized format for a give client (browser) and also optimizes the image intelligently.

The elements are styled with Bulma classes to image cards. It can be seen that the image src is the URL received from the hit prop and also its description. Style the ImageList cards with the ImageList.css file.

Copy to clipboard
.card {
  background: #f5f5f5;
  display: inline-block;
  margin: 0 0 1em;
  width: 100%;
  cursor: pointer;
}

The Modal Component

The Modal component is the interface handling uploads, description creation and saving. Previously we created the Modal.js file in the components folder and its accompanying CSS file. Here we configure this empty file. In Modal.js, import all required dependencies and modules:

Copy to clipboard
import React from 'react';
import classNames from 'classnames';
import './Modal.css';

classnames is a module (which we installed earlier) that is used to dynamically assign classes to an element in React. In the Modal component, create a function with a parameter ‘isActive’ and assign it to the variable modalClass. In the function, the classNames function is called and passed an object containing keys, modal and is-active. is-active is the CSS class to be manipulated.

Copy to clipboard
...
const modalClass = isActive =>
  classNames({
    modal: true,
    'is-active': isActive
  });
...

Next, we render the image upload interface and a close button:

Copy to clipboard
...
export default ({
  isActive,
  toggleModal,
  onDrop,
  saveImage,
  preview,
  description,
  pending,
  handleDescriptionChange,
  handleDropZoneClick
}) => {
  return (
    <div className={modalClass(isActive)}>
      <div className="modal-background" onClick={toggleModal} />
      <div className="modal-content">
        <div className="modal-card">
          <header className="modal-card-head">
            <p className="modal-card-title">Upload an image!</p>
            <button
              onClick={toggleModal}
              className="delete"
              aria-label="close"
            />
          </header>
        </div>
      </div>
      <button
        onClick={toggleModal}
        className="modal-close is-large"
        aria-label="close"
      />
    </div>
  );
};

Note the way the props are passed down to the components from the parent as parameters. The toggleModal function is used to open and close the modal box as can be seen in both buttons at the top and bottom of the box. Since we have created just the Modal header, let’s create the description, upload and save interface. Just after the closing header tag, create the description, upload and save features with:

Copy to clipboard
...
<section className="modal-card-body">
  <div className="columns">
    <div className="column">
      <div className="field">
        <label className="label">Short Description</label>
        <div className="control">
          <textarea
            className="textarea"
            value={description}
            onChange={handleDescriptionChange}
            placeholder="Textarea"
          />
        </div>
        <button
          onClick={saveImage}
          className="button is-info is-margin-top"
        >
          Save
        </button>
      </div>
    </div>
    <div className="column upload-column">
      {!preview ? (
          <button
          onClick={handleDropZoneClick}
          className="button is-info is-margin-top"
        >
          Upload
        </button>
      ) : (
        <img src={preview} alt="Preview" />
      )}
      <div
        className="mainImageLoading"
        style={{ display: pending ? 'block' : 'none' }}
      />
    </div>
  </div>
</section>
...

An input text area is used to handle description input with its value bound to description and an event listener in onChange is on hand to pick up any entries in the description field as specified in the handleDescriptionChange function. The saveImage function is assigned to a button which triggers once clicked. Now here’s a tricky part, conditional rendering is used when displaying either the upload button or the uploaded image. The pending state comes in handy here and if pending is false (no image is uploaded), the upload button is visible and triggers the handleDropZoneClick when clicked. f pending is true, the uploaded image is displayed.

Update the Modal.css file to this. Now that the user interface is done, let’s create the server to handle uploads.

Configure Server.js

In the root directory of the project, create a file server.js, in here we will configure the server. In the server file, import all required dependencies with:

Copy to clipboard
const Express = require('express');
const Webtask = require('webtask-tools');
const bodyParser = require('body-parser');
const cloudinary = require('cloudinary');
const multipart = require('connect-multiparty');
var algoliasearch = require('algoliasearch');

As stated earlier, we will be making use of an express server to make the process easier. Let’s configure the server to use the required modules with:

Copy to clipboard
const app = Express();
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
// Multipart middleware to
// parse files
const multipartMiddleware = multipart();
// Replace credentials
// with your Cloudinary credentials
cloudinary.config({
  cloud_name: 'cloud_name',
  api_key: 'key',
  api_secret: 'secret'
});
// Configure Algolia
// with your Algolia credentials
var algoliaClient = algoliasearch(
  'id',
  'key'
);
var algoliaIndex = algoliaClient.initIndex('index');

Images are uploaded via Cloudinary. Configure the upload API endpoint next with:

Copy to clipboard
app.post('/upload', multipartMiddleware, function(req, res) {
  // Upload image to cloudinary
  cloudinary.v2.uploader.upload(
    // File to upload
    req.files.image.path,
    // AWS tagging transformation
    // Activate here by selecting a plan:
    // https://cloudinary.com/console/addons#aws_rek_tagging
    { categorization: 'aws_rek_tagging' },
    // Callback function
    function(err, result) {
      if (err) return res.send(err);
      res.json({ data: result });
    }
  );
});

The uploaded files are saved to an Algolia index where search and retrieval occurs. This makes use of a post request and you configure it with:

Copy to clipboard
app.post('/save', function(req, res) {
  // index record
  console.log(req.body)
  algoliaIndex.addObject(req.body, function(err, content) {
    if (err) return res.send(err);
    res.json(content);
  });
});

Lastly, the app is exported to a Webtask with:

Copy to clipboard
module.exports = Webtask.fromExpress(app)

This creates a webtask for our server. Read more about webtasks and creating a webtask for a serverless architecture here.

Launch the app on the local server by running:

Copy to clipboard
npm run start

Smart Search

Conclusion

Now we have a AI image search tool that searches uploaded images and looks for a pattern queried using the Algolia search tool. Cloudinary, which is used to upload images, provides a robust upload widget that makes it even better and improves the developer experience. Feel free to play around with the app, suggest improvements or make improvements to the source code here.

Recent Blog Posts

Create Lightweight Sites With Low-Code and No-Code Technology

Consumers expect modern websites to be mainly visual. But, the more compelling and complex the related media is, the more data is involved, compounding the site’s weight. In today’s content-craving world, delivering unoptimized media can cost you because it leads to sluggish page loads, resulting in visitors abandoning your site in search of a faster alternative. In fact, a page load that takes more than three seconds can cause as many as 40% of your visitors to bounce. Given this competitive, digital-first environment, you can’t afford to lose page views, for time is of the essence.

Read more
A Blueprint for AWS-Secured Webhook Listeners for Cloudinary

tl;dr: An AWS-secured and optimized Cloudinary webhook listener for extending the Cloudinary service

Code: Github

A webhook is a communication medium for sending notifications from one platform to another about events that occurred. In place are user-defined HTTP callbacks that are triggered by specific events. When a triggered event takes place on the source site, the webhook listens to the event, collects the data, and sends it to the URL you specified in the form of an HTTP request.

Read more
New Accessibility Features for Cloudinary’s Product Gallery Widget

Cloudinary’s Product Gallery widget, which launched in 2019, has enabled many brands to effectively and efficiently showcase their products in a sleek and captivating manner, saving countless hours of development time and accelerating release cycles. By adding Cloudinary’s Product Gallery widget with its customizable UI to their product page, retailers reap numerous benefits, often turning visitors into customers in short order.

Read more
Why Successful Businesses Engage With and Convert Audiences With Visual Media

Most business buyers prefer to research purchase options online, as do many shoppers. No wonder online retail sales in the U.S. rose by 32.4% in 2020—an impressive gain of $105 billion.

For B2B and B2C businesses, text-heavy websites are no longer adequate in attracting shoppers. Instead, engaging visual media—spin images, videos, 3D models, augmented reality—are becoming a must for conveying eye-catching details and differentiators about products or services.

Read more
Making User-Generated Content (UGC) Shoppable With Cloudinary

User-generated content (UGC) is a powerful marketing tool. Not only does video complement marketing efforts for e-commerce by enabling customers to explore products in greater detail, but UGC also adds an element of trust. As a bonus, user-generated video is an exceptional opportunity for e-businesses to attract website traffic without their marketing team having to create promotional videos from scratch. User-generated content drives conversions and brand loyalty as a direct result of authentic interaction.

Read more