DEV Community: Anand Sukumaran

Building an MCP Server in Javascript

Anand Sukumaran — Sat, 16 Aug 2025 14:10:10 +0000

What is MCP?

Model Context Protocol (MCP) is the hottest topic in AI world right now! Because it solves a major limitation of the LLMs. LLMs has limited knowledge based on the data on which it was training. It doesn't have any idea about the changes happened in the world after it's training cut-off.

To solve this problem, we need external tools to give additional information to LLMs. And depending on the judgement of the LLM, it should be able to call these tools whenever required, and the tool will pass the information back to LLM (by calling an external API or so).

And you can consider MCP as the standardised way to build these external tools. The simplest analogy is if your laptop is an LLM, then USB connector the MCP and the different USB drivers you plugin through this connector are the tools (that provides additional information to your laptop)

Building an MCP Server in Javascript

In this article, we will use the @modelcontextprotocol/sdk npm package to build a simple MCP server. This MCP server will have the ability to fetch the latest documentations for any given npm package, so the LLM clients using this MCP server don't have to rely on its outdated information about npm packages.

For example, if you're using Cursor and vibe coding a JS project and you're importing lot of npm packages in your project. But Cursor have no idea how to implement the npm package as per it's latest doc. So it might hallucinate and cause errors, or do some outdated implementation.

But with our MCP server, it can query and get the official README.md file of the npm package from it's official github repository!

Components in our MCP Server

In the MCP server that we're going to build here, we'll have only one tool:

get_docs_for_npm_package and the input parameter is packageName.

This tool will fetch the README.md file from it's github repository and return the raw contents of that file!

That's it! A simple, yet useful MCP server!

Let's start building

Install the dependencies

npm i @modelcontextprotocol/sdk zod

Let's create the MCP server object

const server = new McpServer({
    name: "npm-package-docs-mcp",
    version: "1.0.0"
})

Register the tool

We'll register the tool, describe it, specifcy the input schema and also write the callback function.

For describing and validating the input parameter, we should use the zod library.

server.registerTool("get_docs_for_npm_package", {
    title: "Get Docs for NPM Package",
    description: "Get the docs for a npm package",

    inputSchema:{
        packageName: z.string().describe("Name of the npm package")
    }
},
async ({packageName}) => {

    // We should use the official npmjs registry api to get the package details
    const registryResponse = await fetch(`https://registry.npmjs.org/${packageName}/latest`).then(res => res.json() as unknown as {repository: {url: string}});

    // Fetch the repository URL from the response
    const repositoryUrl = registryResponse.repository.url;

    //Format the URL and extract the Github repo URL and the repository path
    const githubUrl = new URL(repositoryUrl.replace("git+", ""));
    const repositoryPath = githubUrl.pathname.substring(1).replace(".git", "");

    //Now, lets get the README.md file content using raw.githubusercontent URL. Here we assume the branch is main
    const readmeUrl = `https://raw.githubusercontent.com/${repositoryPath}/refs/heads/main/README.md`;

    const readmeResponse = await fetch(readmeUrl);
    const readmeContent = await readmeResponse.text();

    //Just return the content of the README.md file as text response. That's it!
    return {
        content: [{ type: "text", text: readmeContent }]
    }

}
)

Done! Our MCP server is ready!

Testing the MCP Server

To test this MCP server, we can either use the @modelcontextprotocol/inspector tool by running

@modelcontextprotocol/inspector npx ts-node src/index.ts

Make sure you've ts-node dependency added to your project and the correct server file path in the argument.

With this inspector tool, you can view the tools in your MCP Server and even test them by providing the input values!

Adding this MCP Server to your Cursor IDE

You can simply add this MCP server to your Cursor IDE (or any MCP Client), with this configuration

{
  "mcpServers": {
    "npm-package-docs-mcp": {
      "command": "npx ts-node /full-path-to-your-mcp-server/src/index.ts",
      "env": {},
      "args": []
    }
  }
}

Video Tutorial

You can watch the video tutorial on creating an MCP server in Javascript here - https://www.youtube.com/watch?v=H4Odxtncxrk

Source code

The source code for the fully functional MCP server that fetches npm package docs is available here - https://github.com/meanands/npm-package-docs-mcp

How to create a Youtube video summariser agent using EnvoyJS

Anand Sukumaran — Thu, 23 Jan 2025 16:44:58 +0000

In this tutorial, I will explain how you can build a Youtube video summariser AI agent using EnvoyJS, a minimal agentic framework in Javascript.

The idea

We will create a youtube video summariser agent and instruct them about their job. We will supply YoutubeTranscript tool to the agent so it can fetch the transcript of a given video.

We can either use the gpt-4o model, or deep-seek for this.

Install EnvoyJS library

npm i @envoyjs/core

Import EnvoyJS library, and Youtube Transcript tool

import { Agent, youtubeTranscriptTool } from "@envoyjs/core";

Create the agent

Let's create our agent using the Agent class.

const agent = new Agent({
    name: "Content Summariser Agent",
    bio: "You are an expert in reading YouTube video transcripts and summarizing what the video is about.",
    steps: [
        "Read the transcript",
        "Understand the entire context",
        "Find relevant portions",
        "Summarize as text",
        "Save it as a file"
    ],
    modelConfig: {
        provider: "OPEN_AI",
        apiKey: "", // Don't forget to add your OpenAI API key
        model: "gpt-4o"
    },
    tools: [youtubeTranscriptTool, fileWriterTool] // Add tools here
});

In this class, we're giving instructions to the agent on how to do the task. We have given a bio, and then steps instructions on how to perform!

Running the agent!

Let's prompt the agent to do the work using the print_response() function.

agent.printResponse("Summarise this youtube video - https://www.youtube.com/watch?v=QtYEPYntfL4&t=27s");

Now sitback and see how the agent analyses the task, take decisions to use the tool to fetch the transcript and summarise the video for you!

How to build an AI Agent in Javascript from scratch

Anand Sukumaran — Mon, 20 Jan 2025 18:53:20 +0000

In this tutorial, I'll explain how to build a simple appointment scheduler AI Agent from scratch in Javascript. We won't be using any agentic AI frameworks.

So you will understand how agents work without any abstractions!

I've published the same tutorial as a video on Youtube as well. You can check that here.

Architecture of the AI Agent

You already know what an LLM is. It is similar to a human brain. It can think and take decisions. But cannot execute things without the help of some external tools. Just like how brain uses hands, legs and other organs to perform tasks!

So, an LLM combined with external tools, and a process for cordinating this could be defined as an "AI Agent".

In our case, the Node program will act as the controller who'll interact with the LLM and interfaces it to external tools, and the end-user.

Prerequisites

Javascript and Typescript
OpenAI API Key
Readline library for accepting inputs from commandline

Building the Agent

Note: The finished source code of this agent is available on Github.

Import the dependencies and initialize them

import OpenAI from "openai";
import readline from "readline";

const client = new OpenAI({
    apiKey: ""
});

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

Define the `messages` array

We'll define a global messages array for storing the inputs from the end-user, and the responses from the llm. We'll feed the LLM with this array so that the LLM have the entire context of the conversation!

const messages = [] as any;

Define the SYSTEM_PROMPT

The system prompt is what makes the LLM capable of doing these tasks. We're simply instructing the LLM to act as a scheduler agent, defining his duties and finally the list of available functions the agent can use!

const SYSTEM_PROMPT = `
You are an appointment scheduler AI agent. You're always interacting with a system. You have the ability to do function calls. 
Your response can be either a reply to the user, or to the system to do a function call. But you cannot reply to the user and system in the same response.
So your response should be in JSON format as specified. -

{
    "to": ""
    "message": "",
    "function_call": {
       "function": "",
       "arguments": []
    }
}

I will explain the keys -

1. to - values could be system or user, depending on whom you are replying
2. message - plain text message. Use this only if you are replying to the user not system
3. function_call - Use this only if you are replying to the system. It is a JSON object that determines which function to call, and it's arguments.
4 a. function - name of the function
4 b. arguments - An array of arguments for the function call where each array item is the value for the argument.

Available functions:

function name - check_appointment_availability
arguments - datetime (ISO 8601 format, UTC timezone)

function name - schedule_appointment
arguments - datetime (ISO 8601 format, UTC timezone), name (String), email (string)

function name - delete_appointment
arguments - datetime (ISO 8601 format, UTC timezone), name (String), email (string)

Here are some instructions - 

Chat with user who wants to schedule an appointment with your owner.
Ask if they have any choice for the appointment time.
You must be able to understand that users might be from a different time zone.
Always use their timezone while chatting about times and dates to the user.
Before scheduling the appointment, you must ask their name and email.
Your owner is in IST timezone (+05:30)
Time and date now for your owner is ${getCurrentTimeInTimeZone("Asia/Kolkata")}
`;

**Key points to note here

We're instructing the LLM to always respond in a JSON format.
LLM can respons either to the system (this node program), or to the end user.
LLM must think and decide which functions to call based on the end users requirement.
If a function call is requested, the system (this node program) will execute the function and feed back the response into the LLM

**### Push the system prompt to messages array

As we mentioned, we need to push the prompt to our messages array.

messages.push({
    role: 'system',
    content: SYSTEM_PROMPT
});

Define the functions

As we instructed the LLM, we need to define the available functions. For simplicity we will instruct all functions to return true.

function check_appointment_availability(datetime: string){
    console.log("Calling check_appointment_availability ", datetime)
    return true;
}

function schedule_appointment(datetime: string, name: string, email: string){
    console.log("Calling schedule_appointment ", datetime, name, email)
    return true;
}

function delete_appointment(datetime: string, name: string, email: string){
    console.log("Calling delete_appointment ", datetime, name, email)
    return true;
}

We will also define a function map to call these functions dynamically by using their name from a string variable.

const function_map = {
    'check_appointment_availability': check_appointment_availability,
    'schedule_appointment': schedule_appointment,
    'delete_appointment': delete_appointment
} as any

Defint the `send_to_llm` function

This is the one of the core components of this script. This function accepts a message, adds it to the messages array, and then finally pass the entire array to LLM and wait for it to respond.

async function send_to_llm(content: string){

    messages.push({
        role: 'user',
        content
    });

    const response = await client.chat.completions.create({
        messages,
        model: 'gpt-4o'
    });

    messages.push(response.choices[0].message);

    return response.choices[0].message.content;
}

You can also see that, once the response is received, we're pushing the response back to the messages array so the entire conversation history can be maintained.

Define the `process_llm_response` function

When we receive an input from the LLM, it could be for two purposes.

Send a message to the end user
Execute a function call

The process_llm_response function will parse the received response and do the appropriate action.

async function process_llm_response(response: any){
    const parsedJson = JSON.parse(response);

    if(parsedJson.to == 'user'){
        console.log(parsedJson.message);
    }else if(parsedJson.to == 'system'){
        const fn = parsedJson.function_call.function;
        const args = parsedJson.function_call.arguments;

        const functionResponse = function_map[fn](...args);

        await process_llm_response(await send_to_llm('response is '+functionResponse ? 'true' : 'false'))
    }
}

Here, if the message is sent to the user, then we're simply printing it using console.log().

However, if the message is for the system, we will find the function name, arguments and finally call the function using the function_map we defined before.

The response from the function is fed back into the LLM in a specific format, and we'll call the same process_llm_response function to process the response!

Combining everything

Finally, we will write the main() function.

/**
 * main function
 */
async function main(){

    while(true){

        const input: string = await new Promise((resolve)=>{
            rl.question("Say something: ", resolve);
        });

        const response = await send_to_llm(input);
        await process_llm_response(response);

    }

}

main();

Here we will first accept an input from the user using the readline library. And then the input is fed into the LLM using the send_to_llm function.

Then the response is processed using the process_llm_response function, which decides whether to print the response, or to execute a function!

Final thoughts

Building an agent is not rocket science. It's just instructing the LLM to cordinate with a system program (such as this node script), to execute function or API calls and return the responses accordingly!

As mentioned earlier, this tutorial is available as a video on Youtube as well. You can check that here.

How RAG works? Retrieval Augmented Generation Explained

Anand Sukumaran — Wed, 15 Jan 2025 12:10:20 +0000

You might have heard the term RAG, or Retrieval-Augmented Generation, explained, but you might not know exactly what it is or how it works. This article is for you! Here, I will explain what RAG is, why it is needed, and how it works.

Before that, a quick dive into how an LLM works

An LLM is simply a deep-learning model trained on a large corpus of text data. Think of it this way: a human baby is born completely new to the world and doesn’t know anything. However, as the baby grows, they learn by observing, listening, reading, and more. By the age of 18 or so, they have accumulated significant knowledge about the world and can make informed decisions.

Similarly, an LLM is trained using all the text data available on the internet. It has absorbed information from public forum conversations, online books, blogs, research papers, and more. As a result, it knows how to generate text in a human-like manner and possesses knowledge about the world based on what it has read.

You know what is prompting, but have you heard of context window?

You interact with an LLM by writing prompts or instructions, just as you would when talking to a human. Now, imagine this scenario: you are explaining a complex task with multiple steps to a friend. After hearing your instructions, the friend says, 'Whoa, whoa... I missed that. Can you slow down so I can take notes?'

LLMs face a similar challenge. They can only handle a specific amount of input, prompt, or instructions at one time. This limitation is known as the context window.

Just tell me what is RAG!

Exactly, now you understand that there’s a limit to the amount of context or information you can pass to an LLM. Now, think about this scenario: you want the LLM to understand a huge book (which you’ll provide) and then answer questions on topics from that book.

The LLM is helpless here for two reasons. First, it hasn’t read this book during its initial training, so it has no prior knowledge of it. Second, the book is so large that it exceeds the context window limit of the LLM.

Ok, so RAG is a workaround for the context window size limit?

Exactly, you're getting there! RAG is a technique used to solve this context-window size limit. I'll explain how!

Consider the previous example. When you have a question about that book, what would you do manually? Would you read the book from page one all the way to the end? Of course not! Instead, you’d go to the index, find the relevant section, and refer to just that section, right?

This is what RAG is!

When you ask a question, another service matches the context of your question to different sections of the book. This is achieved by performing a similarity search on a vector database. (The details of this process are beyond the scope of this article.)

It’s important to note that this matching process is not done by the LLM itself but by a separate service.

Once the relevant section is identified, it is retrieved and combined with your original question. This process is called Augmenting the Prompt.

By providing the LLM with this additional knowledge, it is now equipped to think and answer your question accurately and effectively.

It’s a simple concept, but it significantly improves the performance of an LLM!

If you’re interested in learning more AI topics explained in a simplified way, consider following me here. I’ll be sharing more articles that break down complex concepts into easy-to-understand explanations.

AI Workflows vs AI Agents — What’s the Difference?

Anand Sukumaran — Wed, 15 Jan 2025 05:47:53 +0000

The tech world is abuzz with talk about one thing — AI Agents! Everywhere you turn — YouTube, Instagram, X — you hear both excitement and fear about AI agents taking over jobs.

But before AI agents became the topic of discussion, people were already discussing AI Workflows. So, what’s the difference between these two concepts? Let’s explore.

What is a Workflow (Non-AI Workflow)?

A workflow, or automation workflow, has been around for a long time. Businesses use it to complete complex tasks involving multiple steps.

For example, consider a leave approval workflow in your company. You send a leave request through the HR portal. It goes to your engineering manager for acknowledgment, then to an HR person for approval, and finally, you receive a confirmation email about your leave status.

So, What is an AI Workflow?

Simple - using the AI logic in a particular step in your workflow, such as predicting something, calculating some score etc.

In the HR leave request example we discussed, humans were involved in decision-making at certain steps. For instance, your manager decided whether to approve your leave based on factors like your reason for taking leave, the workload, and deadlines.

But what if AI logic was integrated into this workflow? AI could analyze data points about your past leave history, workload, and other relevant factors to make an initial decision. This would save time for your manager while keeping the workflow intact.

The only difference here is that AI logic augments human decision-making in certain steps, and the workflow steps remains the same!

What is an AI Agent?

As we saw before, using “AI logic” in one or more steps of a workflow seems sufficient, right? Yes, but AI can do more! Let’s think about a more complex scenario.

Customer support example

Suppose a customer contacts your company with a support request. Their query could be about a product feature, a warranty claim, a refund, or something entirely unique.

You cannot pre-define a workflow to handle every possible situation, because you don't know what the customer is asking. Even if you provide the customer with a menu of options to choose from, some cases might not fit into any of them. I'm sure you might felt similar frustration as a user many times.

This is where AI Agent helps

An AI agent can handle such open-ended scenarios. First, the agent analyzes the customer’s message to understand the context. It then asks relevant questions to gather more details using RAG, dynamically deciding on the next steps without relying on pre-defined workflows. And guess what, it can even decide which tools to be used to solve this case!

Coming back to the same customer support example

For example, the agent reads the customer email. Now it thinks and figure out what this is about. Let's say it determine that the customer’s issue stems from an unusual product configuration, causing error.

At this moment, the next steps of this resolution workflow might seem totally different than a refund issue, or a billing issue.

So, the agent makes a plan, on how to proceeed.

So in this case - It can then suggest tailored troubleshooting steps, by searching an FAQ database. If the customer provides feedback or encounters further errors, the agent adjusts its actions accordingly.

Let’s say the issue turns out to be a rare error requiring engineering intervention. The agent can understand this, create a support ticket, using the support ticketing as the tool, assign it to an engineer, and notify the customer that the issue has been escalated. All of this happens dynamically, driven by the agent’s ability to think, reason, and act using given tools, just like a human!

Here is another example -

What Makes AI Agents Different for Customers?

Customers often dislike chatbots that rely on rigid, predefined steps because they feel these bots cannot address unique or complex issues.

In contrast, an AI agent is intelligent, flexible, and can even take actions, not just chat! It gathers the necessary information, analyzes the problem, and decides on appropriate actions. It can even escalate the issue to the right team when needed. This personalized approach builds trust and confidence, making the customer experience seamless and efficient.

How can I make an AI Agent?

There are lot of agentic frameworks (code and low-code/no-code) available to build your agents!

Some of them are -

I'll be writing a post on how to build your own AI agents using these frameworks!

The Future of AI Agents

This year, we are likely to see more and more cases where AI agents solve complex problems that traditional workflows cannot handle. These agents will not just automate tasks — they will think, reason, use tools, and act, bringing us closer to intelligent robots who thinks like humans!

You can learn more about the basic concepts of AI and AI-Agents from my Youtube video here -> https://www.youtube.com/watch?v=QtYEPYntfL4

Notifications still disappoint! It needs to be re-invented

Anand Sukumaran — Sun, 17 Mar 2024 19:50:22 +0000

In every app (web/mobile) development project I worked, there wasn't a single one that didn't need notification.

Notification in the sense, any form of communication with the user. It's not just push notifications! It could be email, it could be SMS, call, slack or anything.

It could be triggered from the product such as welcome emails, or subscription reminders or even when two users interact within the product such as liking or replying to someone else's content.

Usually, for web apps, we try to deliver these messages through email and for mobile apps, we stick to push notifications because that's the norm.

Finding the best communication channel!

Think of yourself. You know what's the best way to reach your friends. Some of them are active on email, some of them are best reached via WhatsApp, some of them like calls, Facebook, LinkedIn.

But what about the apps we make? Unfortunately, our apps don't have this ability. Why? Because the app developers can't just integrate a dozen of communication APIs to their backend!

It could result in

Sending the same message across every other channel, annoying your users or
Users not getting the right message at the right time, thus leading to delayed replies or actions!

What's the fix?

Accept the fact that, there is no one best channel to reach your user. And having too many channels won't be good either.

The best thing is to find the right channel based on the context and the message. Let's take a look at few examples.

Sending a welcome message.

Email is widely used for this. But, users are already on your app. Why send an email? They might read it later. But if it has some information to help the user NOW, you lost the context. You should have shown the message inside the app.

Sending offers or promotions to an e-commerce app

Usually, this is sent as push notifications. But do you know how many push notifications stacked on your phone's notification tray? And at the end of the day you clear them all at once and boom! Where are the offers now?

Again, the best way here is to have a message inbox that sits inside your app with the entire message history. So if a user wants that promo code you sent via push, they can find it there.

Have you observed the pattern here?

The best channel depends on the context. If users are spending more time on the app, In-App is undoubtedly the best channel. If not, then the next best might be Push. If they're offline, and if it's really urgent, it could be SMS, or else Email.

What does this means for developers?

So, for developers, it's not easy as integrating an Email API or an SMS API. You need to build a smart communication layer that understands what's the best channel to reach and when.

Let's consider this scenario. We have a support ticketing app and the support agent gets a new ticket from a customer.

What's the best way to notify the agent so he can proactively take action?

If the agent is currently online and working on the app, then a realtime In-App message would be the best to get their attention.
If the agent is online, but away from the app, a push notification will do the job!
If the agent has snoozed all notifications, then sending it in an email, and a copy inside the In-App inbox makes sure they see it when they're back.
If it's top priority (like your server is on fire), call might be the best channel ever!

Delivering a message doesn't ends with a single step. It's a workflow!

Identifying the communication triggers

Most likely, you're under communicating with your users. No I'm not talking about the mass promotional notifications or emails you sent. That you should limit anyways!

I mean the important messages that your users needs to know. For example if you're building a server deployment tool, what are some important communication triggers that adds value?

How do you let users know when a deployment fails?
How do they know when a health-check fails?
How do they know if a deployment is waiting approval?
What if a infrastructure fails when the user is offline?
How do they take action out of the alert they received?

Unless you effectively communicate with the user about these events, they're missing something. These communication triggers are not a luxury but a necessary feature of your product.

So, developers must make sure it is easy to build new communication triggers as required

Respect the user's preferences.

This is important. Even if your system is smart enough to find the best channel to notify a user, it's ultimately their choice.

How do you do this? Allow them to set their preferences on every communication trigger from your app. Let them choose the frequency. For less-important messages, allow them to get multiple messages batched together instead of sending them one by one!

Building a developer-first notification infrastructure!

A problem that appeared to be very trivial in the beginning has now become a huge project with several months of effort.

Now the question is about whether you should spend at least 6 months of your engineering team's effort in building this from scratch or just buy the API?

Well, engineering teams at companies are almost always occupied. So, trying to build this in-house will probably take you at least an year if you start planning now.

At Engagespot, we are building a notification infrastructure for developers to help them build a delightful communication experience in minutes!

And unlike our competitors, we focus on making notifications actionable, and provides deep integration capabilities with your existing code.

To learn more about Engagespot, check our website - https://engagespot.co. And good news, we got selected to Techstars NYC 24 batch, one of the top startup accelerators in the world!

Conclusion

Having a great communication experience is a necessity for your product's success. It's not just about regular marketing communication. It's about how your users get informed about the things that they should know, and how quickly they can take action.

How to setup SES Email templates [2024 Guide]

Anand Sukumaran — Sat, 17 Feb 2024 05:31:35 +0000

When I want to build transactional emails in my apps, AWS SES is my first choice! There are several alternatives like Sendgrid, Mailgun but when it comes to pricing, AWS SES wins!

But the only drawback is that, AWS SES doesn't offer any template editors. Developers should write HTML to build good looking emails, and keep them in S3.

But that's boring, difficult and hard to maintain.

In this tutorial, I'll show you an alternative, an easiest way to setup SES email templates using a free tool - Engagespot!

Prerequisites

Configured SES account
Engagespot account (signup here)

Setting up SES Email templates

Then, navigate to Templates and create a new template and add Email channel to it. Now you'll get the email editor.

Build a beautiful email editor using one of the existing layouts, or create one from scratch yourself.

You can also test the template directly using the "Test" template option available in the dashboard!

Sending the SES Email template from your backend

Now, to trigger the email template you've created using the SES provider, we will use the Engagespot REST API, or a library such as @engagespot/node or Engagespot PHP library

If you're using the REST API, this is how you can simply send the templated SES email to your user!

Done! All it took was less than a few minutes!
You can edit the template anytime without having to touch your code!

How to send email attachments using nodemailer

Anand Sukumaran — Sun, 23 Oct 2022 03:50:06 +0000

Nodemailer is a popular library in Node.js to send emails.

Features of nodemailer are

It has zero dependencies
Secure email delivery with SSL/TLS support
Supports email transport via popular providers like Amazon SES, Sendgrid etc.
Easy to add attachments unlike other libraries.
In this tutorial we’ll learn how to send email attachments using nodemailer.

1. First, add nodemailer to our project.
npm i nodemailer

2. Now let’s create a transport

Like I mentioned above, nodemailer supports other thirdparty providers to be used as transport like Amazon SES, Sendgrid, Mailgun, SMTP etc. In this example, we’ll use SMTP transport.

I’ll be using Typescript for this example.

import nodemailer from "nodemailer";

const smtpTransport = nodemailer.createTransport({
  host: "smtp.example.com",
  port: 587,
  secure: false,
  auth: {
    user: "username",
    pass: "password",
  },
});

3. Construct the email body

We can create the email body as an object with from, to, subject and html.

const mailBody = {
  from: "username@gmail.com",
  to: "receiver@gmail.com",
  subject: "Sample email sent using nodemailer",
  html: "<h1>Hello World!</h1>"
};

4. Let’s add our attachment

Nodemailer supports different types of attachments like base64, file path, stream etc. To get the complete list of attachment supported by nodemailer, refer their documentation.

In this example, we’ll be using file path. So, let’s modify our mailBody.

const mailBody = {
  from: "username@gmail.com",
  to: "receiver@gmail.com",
  subject: "Sample email sent using nodemailer",
  html: "<h1>Hello World!</h1>"
  attachments: [
        {
            filename: 'sample_attachment.png',
            path: __dirname + '/sample_attachment.png',
        }
    ]
};

5. Send the email

To send the email, use the transport.sendMail() function.

smtpTransport.sendMail(mailBody, function (error, info) {
   if (error) {
      console.log(error);
   }

   console.log("Email with attachment delivered successfully")
});

Final code to send email attachments using Nodemailer.

import nodemailer from "nodemailer";

const smtpTransport = nodemailer.createTransport({
  host: "smtp.example.com",
  port: 587,
  secure: false,
  auth: {
    user: "username",
    pass: "password",
  },
});

const mailBody = {
  from: "username@gmail.com",
  to: "receiver@gmail.com",
  subject: "Sample email sent using nodemailer",
  html: "<h1>Hello World!</h1>"
  attachments: [
        {
            filename: 'sample_attachment.png',
            path: __dirname + '/sample_attachment.png',
        }
    ]
};

smtpTransport.sendMail(mailBody, function (error, info) {
    if (error) {
        console.log(error);
    }

    console.log("Email with attachment delivered successfully")
});

Simple! Hope this tutorial has helped you to understand how to send attachments using nodemailer in your email notifications.

Migrating a MySQL database to AWS RDS using AWS DMS with zero downtime

Anand Sukumaran — Sat, 01 Oct 2022 14:31:52 +0000

Recently, at Engagespot, we had to migrate our MySQL database which was hosted in an EC2 instance to AWS RDS to ensure high availability, automated backups and get more visibility through Cloudwatch monitoring and logs.

But the challenge was the size of the database. We had several Gigabytes of data with millions of rows. The next challenge is to ensure sync between both databases. By the time we take the backup and restore it, the data on our original database would have been changed. And, we cannot lock the original database from new writes as it would affect the uptime of our service.

Alternative Methods

We tried several solutions like doing a mysqldump and piping it to the RDS server but it continuously broke the pipe.

We came across this useful service from Amazon called AWS DMS (Database Migration Service) that helps you migrate any database from one server to another. Not just MySQL, but any other databases like Postgres, MSSQL, etc.

By using DMS, we were able to migrate our entire production database to RDS without any downtime.

In this article, I'll explain how to migrate a MySQL database hosted in an EC2 instance (or any other remote server) to RDS. The steps to migrate other databases like Postgres are almost the same, however, the configurations might be different.

Prerequisites

AWS Account
Target RDS instance already created with the schema and table structure. (This is because DMS is not great at replicating your table's auto-increment and other constraints)
Source MySQL database that can be accessed remotely.
Binary log enabled in source MySQL database with few parameters in your my.cnf file configured as per AWS documentation here.

Copy the entire table structure from your source DB to target manually.

As I mentioned above, you must copy your tables, foreign keys, primary keys, Indexes, and other constraints from your source database to RDS manually, using mysqldump, or any other tools. This is because DMS won't migrate the table structure and its constraints properly.

You can simply do this using a MySQL client like Tableplus.

After you've migrated all the table structures, let's proceed to transfer the actual data.

Creating a Replication Instance

Goto AWS Console, and open the DMS service.

To migrate your database, you must first create a DMS replication instance. Navigate to Replication instances -> Create replication instance.

Specify the name and class of the replication instance. You can select the class identical to the RDS instance or your source database. Don't worry about incurring costs because you can quickly delete the replication instance after the migration is completed.

Creating Source endpoint.

After creating the replication instance, you must create the source and target database endpoints. For this, navigate to Endpoints -> create endpoint.

First, we'll create the source endpoint. Make sure you have the source database credentials ready.

Select Source Endpoint as the Endpoint Type.

Specify your source database credentials. Make sure the MySQL user you specify here has SUPER privileges. Without that, the migration might fail.

Finally, click on the save button.

Creating Target endpoint.

The steps are similar to that of creating a source endpoint. There is one additional configuration to specify here.

Under the Endpoint settings, check Use endpoint connection attributes. And in the textbox labeled Extra connection attributes, add the value initstmt=SET FOREIGN_KEY_CHECKS=0. This disables Foreign Key checks on your RDS database during migration and avoids foreign key-related errors.

After creating source and target endpoints, you can test the connection from the Connections tab to make sure those databases can be reached by DMS.

Creating Migration Target

A migration task is a process that copies the database from your source to the target. DMS offers three types of migration tasks.

Migrate existing data - Choose this type if you just want to copy the existing data from the source to the target once.

Migrate existing data and replicate ongoing changes - Choose this method if you want to copy the existing data from the source to the target and keep syncing new records as they are created on the source DB. This is an ongoing process. And we'll be using this method.

Migrate existing data and replicate ongoing changes - Choose this method if you already have some data migrated and now you want to sync the new data from source to target.

Navigate to Database migration tasks and click Create task button. Choose the replication instance you had created earlier, and select the source and target endpoints. Choose migration type as Migrate existing data and replicate ongoing changes.

Under the Task settings section, choose Target table preparation mode as do nothing. This is because you had already migrated the table structure manually.

You can enable Cloudwatch logs to debug if something goes wrong.

Just click on Create task button.

After some time, your task status will be "In Progress". At first, DMS will copy the entire data from source to target, and after that, it will continuously keep the two in sync.

The initial time to copy the data might take anywhere from a few mins to hours depending on the size of your database.

Once you confirm that the entire data has been copied to your target DB, you can run a few tests by creating records in your source DB to ensure new records are being synced.

At this stage, you can update the database credentials of your production app to RDS and that's it! You have migrated your entire production database to RDS without any downtime!

Please let me know in the comments if you face any issues!

DEV Community: Anand Sukumaran

Building an MCP Server in Javascript

What is MCP?

Building an MCP Server in Javascript

Components in our MCP Server

Let's start building

Testing the MCP Server

Adding this MCP Server to your Cursor IDE

Video Tutorial

Source code

How to create a Youtube video summariser agent using EnvoyJS

The idea

Install EnvoyJS library

Import EnvoyJS library, and Youtube Transcript tool

Create the agent

Running the agent!

How to build an AI Agent in Javascript from scratch

Architecture of the AI Agent

Prerequisites

Building the Agent

Import the dependencies and initialize them

Define the messages array

Define the SYSTEM_PROMPT

Define the functions

Defint the send_to_llm function

Define the process_llm_response function

Combining everything

Final thoughts

How RAG works? Retrieval Augmented Generation Explained

Before that, a quick dive into how an LLM works

You know what is prompting, but have you heard of context window?

Just tell me what is RAG!

Ok, so RAG is a workaround for the context window size limit?

AI Workflows vs AI Agents — What’s the Difference?

What is a Workflow (Non-AI Workflow)?

So, What is an AI Workflow?

What is an AI Agent?

This is where AI Agent helps

What Makes AI Agents Different for Customers?

How can I make an AI Agent?

The Future of AI Agents

Notifications still disappoint! It needs to be re-invented

Finding the best communication channel!

What's the fix?

Sending a welcome message.

Sending offers or promotions to an e-commerce app

What does this means for developers?

Identifying the communication triggers

Respect the user's preferences.

Building a developer-first notification infrastructure!

Conclusion

How to setup SES Email templates [2024 Guide]

Setting up SES Email templates

Sending the SES Email template from your backend

How to send email attachments using nodemailer

Final code to send email attachments using Nodemailer.

Migrating a MySQL database to AWS RDS using AWS DMS with zero downtime

Alternative Methods

Prerequisites

Copy the entire table structure from your source DB to target manually.

Creating a Replication Instance

Creating Source endpoint.

Creating Target endpoint.

Creating Migration Target

Define the `messages` array

Defint the `send_to_llm` function

Define the `process_llm_response` function