Autogenerate Show Notes with yt-dlp, Whisper.cpp, and Node.js

End-to-end scripting workflow utilizing Whisper.cpp, yt-dlp, and Commander.js to automatically generate show notes with LLMs from audio and video transcripts.

Outline

• Introduction and Project Setup
• Download and Extract Audio with yt-dlp
• Create and Prepare Transcription for Analysis
  • Run Whisper Transcription Model
  • Format Transcript Output for Processing
• Show Notes Creation Prompt for LLM
• Create Autoshow Node CLI with Commander
  • Create Utility Functions for Common Operations
  • Add Option to Process Video
  • Add Option to Process Playlist of Videos
  • Add Option to Process Custom List of URLs
• Example Show Notes and Next Steps

All of this project’s code can be found on my GitHub at ajcwebdev/autoshow.

Introduction and Project Setup

Creating podcast show notes is an arduous process. Many podcasters do not have the support of a team or the personal bandwidth required to produce high quality show notes. A few of the necessary ingredients include:

• Accurate transcript with timestamps
• Chapter headings and descriptions
• Succinct episode summaries of varying length (sentence, paragraph, a few paragraphs)

Thankfully, through the magic of AI, many of these can now be generated automatically with a combination of open source tooling and affordable large language models (LLMs). In this project, we’ll be leveraging OpenAI’s open source transcription model, Whisper and their closed source LLM, ChatGPT. To begin, create a new project directory and perform the following steps:

• Initialize a package.json and set type to module for ESM syntax.
• Create a content directory for audio and transcription files that we’ll generate along the way.
• Create a .gitignore file for node_modules and the whisper.cpp GitHub repo.

mkdir autoshow && \
  cd autoshow && \
  npm init -y && \
  npm pkg set type="module" && \
  mkdir content utils commands && \
  printf "node_modules\n.DS_Store\nwhisper.cpp\ncontent\n.env" > .gitignore

Download and Extract Audio with yt-dlp

• yt-dlp is a command-line program for downloading videos from YouTube and other video platforms. It is a fork of yt-dlc, which itself is a fork of youtube-dl, with additional features and patches integrated from both.

• FFmpeg is a free and open-source software project consisting of a vast software suite of libraries and programs for handling video, audio, and other multimedia files and streams. It’s used for recording, converting, and streaming audio or video and supports a wide range of formats.

yt-dlp and ffmpeg both provide extensive documentation for installing their respective binaries for command line usage (I used brew install yt-dlp ffmpeg):

• Download FFmpeg
• yt-dlp Installation Wiki and README Installation section

In this project, we’re going to build a Node.js CLI that orchestrates executing different commands from yt-dlp and ffmpeg along with whisper.cpp later in the tutorial.

yt-dlp can process YouTube URL’s to download and extract audio for video transcriptions. The yt-dlp command will complete the following actions:

1. Download a YouTube video specified by its URL.
2. Extract and download the video’s audio as a WAV file.
3. Perform audio post processing to set the correct sample rate.
4. Save in the content directory with the filename output.wav.

yt-dlp -x \
  --audio-format wav \
  --postprocessor-args "ffmpeg: -ar 16000" \
  -o "content/output.wav" \
  "https://www.youtube.com/watch?v=jKB0EltG9Jo"

This command includes the following options:

• --extract-audio (-x) downloads the video from a given URL and extracts its audio.
• --audio-format specifies the format the audio should be converted to for Whisper we’ll use wav for WAV files.
• --postprocessor-args has the argument 16000 passed to -ar so the audio sampling rate is set to 16000 Hz (16 kHz) for Whisper.
• -o specifies the output template for the downloaded files, in this case content/output.wav which also specifies the directory to place the output file.
• The URL, https://www.youtube.com/watch?v=jKB0EltG9Jo is the YouTube video we’ll extract the audio from. Each YouTube video has a unique identifier contained in its URL (QhXc9rVLVUo in this example).

Include the --verbose command if you’re getting weird bugs and don’t know why.

Create and Prepare Transcription for Analysis

whisper.cpp is a C++ implementation of OpenAI’s whisper Python project. This provides the useful feature of making it possible to transcribe episodes in minutes instead of days. Run the following commands to clone the repo and build the base model:

git clone https://github.com/ggerganov/whisper.cpp && \
  bash ./whisper.cpp/models/download-ggml-model.sh base && \
  make -C whisper.cpp

Note: This will build the smallest and least capable transcription model. For a more accurate but heavyweight model, replace base (150MB) with medium (1.5GB) or large-v2 (3GB).

If you’re a simple JS developer like me, you may find the whisper.cpp repo a bit intimidating to navigate. Here’s a breakdown of some of the most important pieces of the project to help you get oriented. Click any of the following to see a dropdown with further explanation:

It’s possible to run the Whisper model and have the transcript output just to the terminal by running:

./whisper.cpp/main \
  -m whisper.cpp/models/ggml-base.bin \
  -f content/output.wav

Note:

• -m and -f are shortened aliases used in place of --model and --file.
• For other models, replace ggml-base.bin with ggml-medium.bin or ggml-large-v2.bin.

This is nice for quick demos or short files. However, what you really want is the transcript saved to a new file.

Run Whisper Transcription Model

Whisper.cpp provides many different output options including txt, vtt, srt, lrc, csv, and json. These cover a wide range of uses and vary from highly structured to mostly unstructured data.

• Any combination of output files can be specified with --output-filetype using any of the previous options in place of filetype.
• For example, to output two files, an LRC file and basic text file, include --output-lrc and --output-txt.

For this example, we’ll only output one file in the lrc format:

./whisper.cpp/main \
  -m whisper.cpp/models/ggml-base.bin \
  -f content/output.wav \
  -of content/transcript \
  --output-lrc

-of is an alias for --output-file. The command is used to modify the final file name along with the selected file extensions. Since our command includes content/transcript, there will be a file called transcript.lrc inside the content directory.

./whisper.cpp/main \
  -m whisper.cpp/models/ggml-base.bin \
  -f content/output.wav \
  -of content/transcript \
  --output-txt --output-vtt \
  --output-srt --output-lrc \
  --output-csv --output-json

Format Transcript Output for Processing

Despite the various available options for file formats, whisper.cpp outputs all of them as text files that later can be parsed and transformed. As with many things in programming, numerous approaches could be used to yield similar results.

Based on your personal workflows/experience, you may find it easier to parse and transform a different common data formats like csv or json. For my purpose, I’m going to use the lrc output which looks like this:

[by:whisper.cpp]
[00:00.00] Okay, well, you know, it can be a great question for this episode.
[00:02.24] What is Fullstack Jamstack?
[00:04.04] What?
[00:05.04] Yeah, exactly.
[00:06.04] Yeah.
[00:07.04] And who are we?

Using a combination of grep and awk, I’ll write a short bash command to take the LRC transcript and modify it to look like this instead:

[00:00] Okay, well, you know, it can be a great question for this episode.
[00:02] What is Fullstack Jamstack?
[00:04] What?
[00:05] Yeah, exactly.
[00:06] Yeah.
[00:07] And who are we?

To achieve the desired transformations with the given directory structure, we’ll need to:

1. Read the transcript.lrc file from the content directory.
2. Remove the [by:whisper.cpp] signature.
3. Format the timestamps to remove milliseconds.
4. Write the transformed content to a new file called transcript.txt in the same directory as the original file.

grep -v '^\[by:whisper\.cpp\]$' "content/transcript.lrc" | awk '{ gsub(/\.[0-9]+/, "", $1); print }' > "content/transcript.txt"

In the next section we’ll create the prompt to tell ChatGPT or Claude how to write the show notes. This prompt along with all the previous logic to download, transcribe, and transform the output will be combined into a single Bash script.

Show Notes Creation Prompt for LLM

Now that we have a cleaned up transcript, we can use ChatGPT directly to create the show notes. The output will contain six distinct sections which correspond to the full instructions of the prompt. Any of these sections can be removed, changed, or expanded:

• Potential Episode Titles
• One Sentence Summary
• One Paragraph Summary
• Chapters
• Key Takeaways

Create a file called prompt.md in utils:

echo > utils/prompt.md

Include the following prompt with the transcript after the final line:

This is a transcript with timestamps. Write 3 potential titles for the video.

Write a one sentence summary of the transcript, a one paragraph summary, and a two paragraph summary.
  - The one sentence summary shouldn't exceed 180 characters (roughly 30 words).
  - The one paragraph summary should be approximately 600-1200 characters (roughly 100-200 words).

Create chapters based on the topics discussed throughout.
  - Include timestamps for when these chapters begin.
  - Chapters shouldn't be shorter than 1-2 minutes or longer than 5-6 minutes.
  - Write a one paragraph description for each chapter.
  - Note the very last timestamp () and make sure the chapters extend to the end of the episode

Lastly, include three key takeaways the listener should get from the episode.

Format the output like so:

    ```md
    ## Potential Titles

    1. Title I - Title Hard
    2. Title II - Title Harder
    3. Title II - Title Hard with a Vengeance

    ## Episode Summary

    One sentence summary which doesn't exceed 180 characters (or roughly 30 words).

    tl;dr: One paragraph summary which doesn't exceed approximately 600-1200 characters (or roughly 100-200 words)

    ## Chapters

    00:00 - Introduction and Beginning of Episode

    The episode starts with a discussion on the importance of creating and sharing projects.

    02:56 - Guest Introduction and Background

    Introduction of guests followed by host discussing the guests' background and journey.

    ## Key Takeaways

    1. Key takeaway goes here
    2. Another key takeaway goes here
    3. The final key takeaway goes here

    ## Transcript
    ```

## Transcript

The final step is to:

• Copy the content of prompt.md.
• Append the prompt to the top of transcript.md.
• Create a new file called final.md in the content directory with the combined prompt and transcript.

To achieve this directly from the terminal, use the cat command:

cat utils/prompt.md content/transcript.txt > content/final.md

This concatenates the content of prompt.md to transcript.md and redirects the output to a newly created file called final.md in the content directory:

Create Autoshow Node CLI with Commander

For the last part of this tutorial, we’ll integrate all of the logic from the previous steps into one single command. The command will be implemented with Commander.js, an open source library for building command line interfaces with Node.js. Install the commander NPM package:

npm i commander

The entire example so far will be implemented as a processVideo function executed by the main autoshow.js function. The function will call out to utility functions for common operations. These will be abstracted into an index.js file in utils for reusability as the project grows. Create these three files:

echo > autoshow.js
echo > utils/index.js
echo > commands/processVideo.js

Create Utility Functions for Common Operations

We’ll start with three utility functions:

• processLrcToTxt
• concatenateFinalContent
• cleanUpFiles

We’ll also create an alias for yt-dlp called ytAlias that suppresses unnecessary warnings.

import fs from 'fs'

export const ytAlias = `yt-dlp --no-warnings`

export function processLrcToTxt(id) {
  const lrcPath = `${id}.lrc`
  const txtPath = `${id}.txt`
  const lrcContent = fs.readFileSync(lrcPath, 'utf8')
  const txtContent = lrcContent.split('\n')
    .filter(line => !line.startsWith('[by:whisper.cpp]'))
    .map(line => line.replace(/\[\d{2}:\d{2}\.\d{2}\]/g, match => match.slice(0, -4) + ']'))
    .join('\n')
  fs.writeFileSync(txtPath, txtContent)
  console.log(`Transcript file transformed successfully: ${id}.txt`)
  return txtContent
}

export function concatenateFinalContent(id, txtContent) {
  return [
    fs.readFileSync(`${id}.md`, 'utf8'),
    fs.readFileSync(`./utils/prompt.md`, 'utf8'),
    txtContent
  ].join('\n')
}

export function cleanUpFiles(id) {
  const files = [`${id}.wav`, `${id}.lrc`, `${id}.txt`, `${id}.md`]
  for (const file of files) {
    if (fs.existsSync(file)) {
      fs.unlinkSync(file)
    }
  }
}

processLrcToTxt takes an id as an argument and processes an LRC file associated with that id, transforming it into a text (TXT) file.

• Define the file paths for the LRC and TXT files based on the provided id.
• Read the LRC file’s content synchronously using fs.readFileSync and return a UTF-8 encoded string.
• Process the LRC content.
  • Split the content it into an array of lines using split('\n').
  • Filter out [by:whisper.cpp] by removing the line from the array.
  • Map over the remaining lines and remove decimals by replacing [mm:ss.xx] with [mm:ss].
  • Join the processed lines back into a single string with \n as the delimiter.
• Write the processed content to the TXT file using fs.writeFileSync.
• Log a success message to the console and return the processed TXT content.

concatenateFinalContent takes an id and txtContent, combining content from three sources into a single string.

• Read the content of ${id}.md and ./utils/prompt.md using fs.readFileSync.
• Combine these contents with txtContent into a single string, joined by newline characters and return the combined string.

cleanUpFiles deletes files associated with a given id.

• Create an array of file paths based on the provided id.
• Loop through the file paths and use fs.unlinkSync to delete the file if it exists.

Add Option to Process Video

The --print option from yt-dlp can be used to extract metadata from the video. We’ll use the following in our script:

• id and upload_date provide a unique name for each video.
• webpage_url for the full video URL.
• uploader for the channel name.
• uploader_url for the channel URL.
• title for the video title.
• thumbnail for the video thumbnail.

Include the following code in commands/processVideo.js:

import fs from 'fs'
import { execSync } from 'child_process'
import { ytAlias, processLrcToTxt, concatenateFinalContent, cleanUpFiles } from '../utils/index.js'

export async function processVideo(url) {
  try {
    const videoId = execSync(`${ytAlias} --print id "${url}"`).toString().trim()
    const uploadDate = execSync(`${ytAlias} --print filename -o "%(upload_date>%Y-%m-%d)s" "${url}"`).toString().trim()
    const id = `content/${videoId}`
    const final = `content/${uploadDate}-${videoId}`

    const mdContent = [
      "---",
      `showLink: "${execSync(`${ytAlias} --print webpage_url "${url}"`).toString().trim()}"`,
      `channel: "${execSync(`${ytAlias} --print uploader "${url}"`).toString().trim()}"`,
      `channelURL: "${execSync(`${ytAlias} --print uploader_url "${url}"`).toString().trim()}"`,
      `title: "${execSync(`${ytAlias} --print title "${url}"`).toString().trim()}"`,
      `publishDate: "${uploadDate}"`,
      `coverImage: "${execSync(`${ytAlias} --print thumbnail "${url}"}`).toString().trim()}"`,
      "---\n"
    ].join('\n')

    fs.writeFileSync(`${id}.md`, mdContent)
    console.log(`Markdown file completed successfully: ${id}.md`)

    execSync(`${ytAlias} -x --audio-format wav --postprocessor-args "ffmpeg: -ar 16000" -o "${id}.wav" "${url}"`)
    console.log(`WAV file completed successfully: ${id}.wav`)

    let txtContent
    execSync(`./whisper.cpp/main -m whisper.cpp/models/ggml-base.bin -f "${id}.wav" -of "${id}" --output-lrc`, { stdio: 'ignore' })
    console.log(`Transcript file completed successfully: ${id}.lrc`)
    txtContent = processLrcToTxt(id)

    const finalContent = concatenateFinalContent(id, txtContent)
    fs.writeFileSync(`${final}.md`, finalContent)
    console.log(`Prompt concatenated to transformed transcript successfully: ${final}.md`)

    cleanUpFiles(id)
    console.log(`Process completed successfully for URL: ${url}`)
  } catch (error) {
    console.error(`Error processing video: ${url}`, error)
  }
}

Import processVideo.js in autoshow.js and create a new option:

import { Command } from 'commander'
import { processVideo } from './commands/processVideo.js'

const program = new Command()

program
  .name('autoshow')
  .description('Automated processing of YouTube videos, playlists, and podcast RSS feeds')
  .option('-v, --video <url>', 'Process a single YouTube video')

program.action(async (options) => {

  const handlers = {
    video: processVideo,
  }

  for (const [key, handler] of Object.entries(handlers)) {
    if (options[key]) {
      await handler(options[key])
    }
  }
})

program.parse(process.argv)

Run node autoshow.js --video followed by the URL for the video you want to transcribe:

node autoshow.js --video "https://www.youtube.com/watch?v=jKB0EltG9Jo"

Next, we’ll write two more functions that each run the process_video function on multiple videos. These videos will be either contained in a playlist (process_playlist) or written in a urls.md file (process_urls_file).

Add Option to Process Playlist of Videos

At this point, the autoshow.js script is designed to run on individual video URLs. However, if you already have a backlog of content to transcribe, you’ll want to run this script on a series of video URLs. To implement a second option that accepts a playlist URL instead of a video URL, create a file called processPlaylist.js in the commands directory:

echo > commands/processPlaylist.js

The processPlaylist function will fetch video URLs from a playlist, save them to a file, and processes each video URL by calling processVideo. The --print "url" and --flat-playlist options from yt-dlp can be used to write a list of video URLs to a new file which we’ll call urls.md.

import { execSync } from 'child_process'
import fs from 'fs'
import { processVideo } from './processVideo.js'
import { ytAlias } from '../utils/index.js'

export async function processPlaylist(playlistUrl) {
  const episodeUrls = execSync(`${ytAlias} --flat-playlist -s --print "url" "${playlistUrl}"`)
  const urls = episodeUrls.toString().split('\n').filter(Boolean)
  fs.writeFileSync(`content/urls.md`, `${episodeUrls}`)
  for (const url of urls) {
    await processVideo(url)
  }
}

Here’s how it works:

• Required modules are imported including:
  • execSync from the child_process module for executing shell commands.
  • fs for file system operations.
  • processVideo function defined in the previous step.
• Shell command is executed to get video URLs.
  • The yt-dlp command is run with execSync to retrieve a flat list of video URLs.
  • The results from the playlist, episodeUrls, is a buffer containing the URLs as a string.
• URLs are converted and filtered from a buffer to a string and split into an array of URLs using split('\n').
  • filter(Boolean) removes any empty strings from the array, leaving only valid URLs.
  • The list of URLs is saved to a file named content/urls.md using fs.writeFileSync.
• Video URLs are processed by looping through the array and using await on each to call the processVideo function asynchronously.

Import processPlaylist.js in autoshow.js and create a new option:

import { Command } from 'commander'
import { processVideo } from './commands/processVideo.js'
import { processPlaylist } from './commands/processPlaylist.js'

const program = new Command()

program
  .name('autoshow')
  .description('Automated processing of YouTube videos, playlists, and podcast RSS feeds')
  .option('-v, --video <url>', 'Process a single YouTube video')
  .option('-p, --playlist <playlistUrl>', 'Process all videos in a YouTube playlist')

program.action(async (options) => {

  const handlers = {
    video: processVideo,
    playlist: processPlaylist,
  }

  for (const [key, handler] of Object.entries(handlers)) {
    if (options[key]) {
      await handler(options[key])
    }
  }
})

program.parse(process.argv)

Run node autoshow.js --playlist with the playlist URL passed to --playlist to run on multiple YouTube videos contained in the playlist.

node autoshow.js --playlist "https://www.youtube.com/playlist?list=PLCVnrVv4KhXMh4DQBigyvHSRTf2CSj129"

Add Option to Process Custom List of URLs

To process a list of arbitrary URLs, we’ll want to bypass the yt-dlp command that reads a list of videos from a playlist and pass urls.md directly to Whisper. Create a file called processUrlsFile.js in the commands directory.

echo > commands/processUrlsFile.js

processUrlsFile will process a list of video URLs. It reads a file containing video URLs, parses the URLs, and processes each URL by calling the processVideo function. The function checks to see if the file exists so it can log an error message and exit early if the file doesn’t exist.

import fs from 'fs'
import { processVideo } from './processVideo.js'

export async function processUrlsFile(filePath) {
  if (!fs.existsSync(filePath)) {
    console.error(`File not found: ${filePath}`)
    return
  }
  const urls = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean)
  for (const url of urls) {
    await processVideo(url)
  }
}

Here’s how it works:

• Import required modules including:
  • fs module for file system operations.
  • processVideo function.
• Check if the file specified by filePath exists using fs.existsSync.
  • If the file does not exist, log an error message to the console and return early from the function to prevent further execution.
• If the file exists, read the file content synchronously as a UTF-8 string using fs.readFileSync.
  • Split the file content into an array of URLs using split('\n'), splitting at each newline character.
  • filter(Boolean) removes any empty strings from the array, leaving only valid URLs.
• Loop through each URL in the array and call the processVideo function asynchronously using await.

Import processUrlsFile.js in autoshow.js and create a new option:

import { Command } from 'commander'
import { processVideo } from './commands/processVideo.js'
import { processPlaylist } from './commands/processPlaylist.js'
import { processUrlsFile } from './commands/processUrlsFile.js'

const program = new Command()

program
  .name('autoshow')
  .description('Automated processing of YouTube videos, playlists, and podcast RSS feeds')
  .option('-v, --video <url>', 'Process a single YouTube video')
  .option('-p, --playlist <playlistUrl>', 'Process all videos in a YouTube playlist')
  .option('-u, --urls <filePath>', 'Process YouTube videos from a list of URLs in a file')

program.action(async (options) => {

  const handlers = {
    video: processVideo,
    playlist: processPlaylist,
    urls: processUrlsFile,
  }

  for (const [key, handler] of Object.entries(handlers)) {
    if (options[key]) {
      await handler(options[key])
    }
  }
})

program.parse(process.argv)

Run node autoshow.js --urls with the path to your urls.md file passed to --urls.

node autoshow.js --urls urls.md

Example Show Notes and Next Steps

Here’s what ChatGPT generated for Episode 0 of the Fullstack Jamstack podcast:

---
showLink: "https://www.youtube.com/watch?v=QhXc9rVLVUo"
channel: "FSJam"
channelURL: "https://www.youtube.com/@fsjamorg"
title: "Episode 0 - The Fullstack Jamstack Podcast with Anthony Campolo and Christopher Burns"
publishDate: "2020-12-09"
coverImage: "https://i.ytimg.com/vi_webp/QhXc9rVLVUo/maxresdefault.webp"
---

## Potential Titles

1. "Unpacking FSJam: A New Era of Web Development"
2. "From Jam to Fullstack: Revolutionizing Web Architecture"
3. "Navigate the FSJam Landscape: Tools, Frameworks, Community"

## Episode Summary

The podcast explores Fullstack Jamstack's principles, from basic Jamstack components to advanced tools like Prisma and meta frameworks, emphasizing community dialogue and development practices.

This episode of the Fullstack Jamstack podcast, hosted by Anthony Campolo and Christopher Burns, dives into the essence and philosophy of Fullstack Jamstack, a modern web development architecture. Starting with a basic introduction to the Jamstack components (JavaScript, APIs, Markup), the hosts expand into discussing the evolution from monolithic architectures to more decoupled, service-oriented approaches that define Fullstack Jamstack. They explore the significance of tools like Prisma for database management, the role of Content Management Systems (CMS), and the transition towards serverless functions. Furthermore, the discussion includes the introduction of meta frameworks like Redwood and Blitz, which aim to streamline the development process by integrating front-end, back-end, and database layers cohesively. The episode emphasizes community building, the exchange of ideas across different frameworks, and invites listeners to participate in the conversation through social media and Discord.

## Chapters

00:00 - Introduction to Fullstack Jamstack and Podcast Goals

Introduction and foundational questions about FSJam, its significance, and the podcast's aim to educate and foster community dialogue.

03:00 - Defining Jamstack: Components and Evolution

Clarification of Jamstack's components, JavaScript, APIs, Markup and its evolution from static sites to dynamic, service-oriented architectures.

08:00 - From Monolithic to Decoupled Architectures

Discussion on the transition from monolithic to decoupled architectures, highlighting the role of CMS and serverless functions in modern web development.

14:00 - Introduction to Prisma and Database Management

Exploration of Prisma's role in FSJam for efficient DB management and the differences between Prisma 1 and 2.

20:00 - Meta Frameworks and the Future of FSJam

Introduction to meta frameworks like Redwood and Blitz, their contribution to simplifying FSJam development, and speculation on future trends.

28:00 - Philosophies of FSJam & Community Engagement

Discussion on the core philosophies of FSJam, the importance of selecting the right tools and frameworks, and encouraging listener engagement through social media and Discord.

## Key Takeaways

1. Fullstack Jamstack represents a modern approach to web development, emphasizing decoupled architectures that separate the front-end from the back-end, enabling more flexible and scalable applications.
2. Tools like Prisma for database management and the adoption of meta frameworks (Redwood, Blitz) are pivotal to simplify and enhancing the development process for FSJam apps.
3. Community engagement and exchange of ideas across different frameworks are essential for the growth and evolution of FSJam, encouraging developers to contribute, learn, and collaborate.

## Transcript

This workflow is fine for me because I only create a podcast every week or two, so I can just copy paste the transcript into ChatGPT and copy out the output. However, it’s very possible that you could have dozens or even hundreds of episodes that you want to run this process on.

To achieve this in a short amount of time, you’ll need to use the OpenAI API and drop a bit of coin to do so. In my next blog post, I’ll be showing how to achieve this with OpenAI’s Node.js wrapper library. Once that blog post is complete I’ll update this post and link it at the end.