Create a Custom AI-Powered Calling Agent for Recruitment

Home / Blogs / Technology / Create a Custom AI-Powered Calling Agent for Recruitment

Building a Custom AI-Powered Calling Agent Using Node.js, MongoDB, and ElevenLabs

Estimated reading time: 7 minutes

  • Comprehensive overview of creating an AI-powered calling agent.
  • Utilization of Node.js, MongoDB, and ElevenLabs for backend operations.
  • Integration of Twilio for telephony services (optional).
  • Guidance on setting up a suitable development environment.
  • In-depth code examples to facilitate understanding.

Table of Contents

Introduction

In the evolving landscape of recruitment and customer interactions, AI-powered voice agents are revolutionizing how businesses communicate with clients and candidates alike. This blog post will guide you through creating a custom AI-powered calling agent using Node.js for backend logic, MongoDB to store user profiles and call flow data, and ElevenLabs for generating realistic voice responses. We’ll also explore the optional integration of Twilio to handle outbound calls. By the end of this tutorial, you will have a robust understanding of how to set up this architecture, complete with practical code examples and implementation strategies.

Overview of the Stack and Workflow

Our proposed architecture leverages the following technologies:

  • Node.js: Serves as our backend server, managing API requests and orchestrating speech generation and telephony interactions.
  • MongoDB: Utilized for storing user profiles, dynamic call scripts, call states, and interaction histories, enabling personalized multi-turn dialogues.
  • ElevenLabs TTS API: Provides high-quality, natural-sounding voice responses generated in real-time from text prompts.
  • Twilio (optional): A telephony service for handling outbound and inbound calls, connecting them to our Node.js server via webhooks for dynamic voice interactions.

This stack allows us to create personalized automated voice interactions by dynamically generating speech and managing conversation flows stored in MongoDB.

Step 1: Setting Up the Project

Initialize the Node.js Backend

To get started, create a new directory for your project, initialize a Node.js application, and install the required packages:

mkdir ai-calling-agent
cd ai-calling-agent
npm init -y
npm install express axios mongodb twilio dotenv
  • express: A web server framework to handle HTTP requests.
  • axios: For making API calls to the ElevenLabs service.
  • mongodb: The official MongoDB driver for Node.js to manage our database interactions.
  • twilio: For managing telephony services, if integrated.
  • dotenv: A module for loading environment variables from a .env file.

Next, create a .env file in your project directory to securely store your sensitive credentials:

MONGODB_URI=<your_mongodb_atlas_uri>
ELEVENLABS_API_KEY=<your_elevenlabs_api_key>
TWILIO_ACCOUNT_SID=<your_twilio_account_sid>
TWILIO_AUTH_TOKEN=<your_twilio_auth_token>
TWILIO_PHONE_NUMBER=<your_twilio_phone_number>

This setup ensures that your API keys remain hidden and easily configurable.

Step 2: MongoDB – Structuring Dynamic Call Scripts and Data

In this stage, we will define the structure of the database that will support our calling agent, storing user profiles, conversation scripts, and call session data. MongoDB utilizes a flexible JSON-like format that allows us to define our data structures easily.

Example MongoDB Call Script Document

Here’s a sample structure for a dynamic call script stored in MongoDB:

{
  "_id": "script_001",
  "name": "Welcome Call",
  "steps": [
    {
      "id": "step1",
      "prompt": "Hello {{user.name}}, thank you for joining us. How can I help you today?",
      "expectedResponseType": "open-ended",
      "nextStep": "step2"
    },
    {
      "id": "step2",
      "prompt": "Can you please provide your membership ID?",
      "expectedResponseType": "numeric",
      "nextStep": "step3"
    },
    {
      "id": "step3",
      "prompt": "Thank you, let me check your details. One moment please.",
      "expectedResponseType": null,
      "nextStep": null
    }
  ]
}

This structure allows the backend to dynamically retrieve and control the flow of the conversation. The Node.js application can fetch this script and manage user interactions efficiently.

Step 3: Integrating ElevenLabs Text-to-Speech API

The ElevenLabs API simplifies the process of generating voice responses from text. Below is how to set up a function that takes a text input, calls the ElevenLabs API, and retrieves the audio response.

Example: Generate Voice Response Using Axios

const axios = require('axios');

async function generateSpeech(text) {
  try {
    const response = await axios.post(
      'https://api.elevenlabs.io/v1/text-to-speech/voice_id/generate',
      {
        text: text,
        voice_settings: {
          stability: 0.7,
          similarity_boost: 0.9
        }
      },
      {
        headers: {
          'xi-api-key': process.env.ELEVENLABS_API_KEY,
          'Content-Type': 'application/json'
        },
        responseType: 'arraybuffer' // get audio binary
      }
    );
    return response.data; // Audio buffer (e.g., mp3)
  } catch (error) {
    console.error("Error generating speech: ", error);
    throw new Error("Speech generation failed");
  }
}

The audio buffer returned can be streamed directly to the telephony service or handled accordingly in your application.

Step 4: Backend Logic to Handle Calls

Using Express.js, we can create a webhook endpoint for handling incoming/outgoing call events, such as those from Twilio.

Webhook Endpoint for Call Handling

const express = require('express');
const { MongoClient } = require('mongodb');
const twilio = require('twilio');
require('dotenv').config();

const app = express();
app.use(express.json());

const client = new MongoClient(process.env.MONGODB_URI);
let db;

app.post('/webhook/call', async (req, res) => {
  const { CallSid, From, To, SpeechResult } = req.body;

  let callSession = await db.collection('calls').findOne({ callSid: CallSid });
  if (!callSession) {
    callSession = {
      callSid: CallSid,
      from: From,
      to: To,
      stepId: 'step1',
      context: {}
    };
    await db.collection('calls').insertOne(callSession);
  }

  const script = await db.collection('scripts').findOne({ name: 'Welcome Call' });
  const currentStep = script.steps.find(s => s.id === callSession.stepId);

  // Prepare next prompt, considering user input if available
  let prompt = currentStep.prompt.replace('{{user.name}}', 'Caller');

  // Generate TTS audio
  const audioBuffer = await generateSpeech(prompt);

  const twiml = new twilio.twiml.VoiceResponse();
  twiml.play({ contentType: 'audio/mpeg' }, `data:audio/mpeg;base64,${audioBuffer.toString('base64')}`);

  const nextStepId = currentStep.nextStep;
  await db.collection('calls').updateOne({ callSid: CallSid }, { $set: { stepId: nextStepId } });

  res.type('text/xml').send(twiml.toString());
});

async function start() {
  await client.connect();
  db = client.db('ai_calling_agent');
  app.listen(3000, () => console.log('Server listening on port 3000'));
}

start();

This setup effectively manages the call’s state, processing user responses, and generating appropriate audio prompts dynamically.

Step 5: (Optional) Using Twilio for Outbound Calls

To initiate outbound calls, utilizing Twilio’s API is straightforward. Here’s a basic implementation:

const twilioClient = twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);

async function makeCall(toNumber) {
  await twilioClient.calls.create({
    url: 'https://your-server.com/webhook/call',
    to: toNumber,
    from: process.env.TWILIO_PHONE_NUMBER
  });
}

The url points to your webhook endpoint, which will be triggered once the call connects, enabling dynamic interaction.

How the Parts Work Together

– Node.js handles webhook events coming from the telephony service, managing conversation steps and states stored in MongoDB.

– Upon interacting with the user, the backend dynamically generates voice audio through the ElevenLabs TTS API for each prompt, ensuring a natural communication flow.

– User inputs collected via speech-to-text systems can be processed and utilized to update the context or state of the conversation.

– MongoDB maintains relevant data, including call scripts for easy modifications and active call sessions for tracking ongoing conversations.

– Twilio, if integrated, orchestrates the telephony aspect, connecting the generated audio and the ongoing voice interactions.

Summary

This comprehensive approach enables you to create an automated, personalized phone call system that interacts naturally with users through AI-generated voice responses and dynamic conversation scripts. Key steps for building this architecture include:

  1. Setting up Node.js and Express for handling webhooks and API logic.
  2. Structuring MongoDB schemas for managing call flows and session data.
  3. Integrating the ElevenLabs Text-to-Speech API for generating realistic voice prompts.
  4. Optionally employing Twilio to manage telephony calls, enhancing your application’s capabilities.

This blog post provides a technical foundation for developing your bespoke AI calling agent that performs intelligent, context-aware voice interactions. For more resources and advanced configurations with MongoDB and Node.js, you can refer to MongoDB’s tutorial on building a JavaScript AI agent here.

Call to Action

If you’re excited to explore how our AI consulting services can enhance your business processes or if you need assistance in implementing a custom AI-powered solution for your organization, don’t hesitate to contact us today. Let us guide you in leveraging technology for modern recruitment and communication challenges!

FAQ

1. What technologies are used in this project?

The project utilizes Node.js, MongoDB, ElevenLabs, and optionally Twilio.

2. Can I customize the call scripts?

Yes, call scripts are stored in MongoDB and can be modified easily.

3. What is the role of ElevenLabs?

ElevenLabs provides the Text-to-Speech API to generate realistic voice responses based on text prompts.

4. Is integration with Twilio mandatory?

No, Twilio integration is optional but recommended for telephony services.

5. What is the environment setup for the project?

Ensure to set up a .env file with your MongoDB and ElevenLabs credentials to secure sensitive data.