How to Take Perfect Notes with Your Voice Using ChatGPT and Notion

You’ll find all of these code steps in each of the instructional steps below, but I’ve also included them here in this convenient toggle.

You can come back here to reference code without needing to jump around the tutorial (which is quite lengthy, I know).

Note that the step names are important as they’re used for the export values that are referenced in subsequent steps. For example, the Download_to_tmp returns this object: steps.Download_to_tmp.$return_value.tmpPath – which is referenced in a future step.

All of this code is JavaScript, so make sure you use the Node app in Pipedream for each step.

Step 1: Trigger

The trigger step uses the Dropbox → New File action, and doesn’t use any code. Include Link must be set to True.

Step 2: Download_to_tmp

Node → Run Node Code

import stream from "stream";
import { promisify } from "util";
import fs from "fs";
import got from "got";

export default defineComponent({
  async run({ steps, $ }) {
    
    
    if (steps.trigger.event.size > 100000000) {
      throw new Error("File is too large. Files must be mp3 or m4a filels under 100mb")
    }

    try {
        
        const mime = steps.trigger.event.path_lower.match(/.w+$/)[0]
        
        
        if (mime !== '.mp3' && mime !== '.m4a') {
            throw new Error("Unsupported file type. Only mp3 and m4a files are supported.");
        }

        
        const tmpPath = `/tmp/recording${mime}`
        
        
        const pipeline = promisify(stream.pipeline);
        await pipeline(
        got.stream(steps.trigger.event.link),
        fs.createWriteStream(tmpPath)
        );

        
        const results = {
        "tmpPath": tmpPath,
        "mimetype": mime
        }

        return results
    } catch (error) {
        
        console.error(error);
        throw error;
    }
  }
})

Step 3: get_duration

Node → Run Node Code

import { parseFile } from 'music-metadata';
import { inspect } from 'util';

export default defineComponent({
  async run({ steps, $ }) {
    
    try {
      
      const filePath = steps.Download_to_tmp.$return_value.tmpPath

      if (!filePath) {
        throw new Error("File path is missing or invalid.");
      }

      
      let dataPack;
      try {
        dataPack = await parseFile(filePath);
      } catch (error) {
        throw new Error("Failed to read audio file metadata. The file format might be unsupported or corrupted, or the file might no longer exist at the specified file path (which is in temp storage).");
      }

      
      const duration = Math.round(await inspect(dataPack.format.duration, { showHidden: false, depth: null }));
      return duration;
    } catch (error) {
      
      console.error(error);
      throw new Error(`An error occurred while processing the audio file: ${error.message}`);
    }


  },
})

Step 4: create_transcription

This step uses the OpenAI (ChatGPT) → Create Transcription action, and doesn’t use any code.

Step 5: openai_chat

OpenAI (ChatGPT) → Use any OpenAI (ChatGPT) API in Node.js

import { Configuration, OpenAIApi } from "openai"
import { encode, decode } from "gpt-3-encoder"

export default defineComponent({
  props: {
    openai: {
      type: "app",
      app: "openai",
    }
  },
  async run({steps, $}) {

    
    const transcript = steps.create_transcription.$return_value.transcription

    
    const maxTokens = 2000

    
    const openAIkey = this.openai.$auth.api_key
    const configuration = new Configuration({
      apiKey: openAIkey,
    });
    const openai = new OpenAIApi(configuration);
    
    
    function splitTranscript(encodedTranscript, maxTokens) {
      const stringsArray = []
      let currentIndex = 0

      while (currentIndex < encodedTranscript.length) {
        let endIndex = Math.min(currentIndex + maxTokens, encodedTranscript.length)
        
        
        while (endIndex < encodedTranscript.length && decode([encodedTranscript[endIndex]]) !== ".") {
          endIndex++
        }

        
        if (endIndex < encodedTranscript.length) {
          endIndex++
        }

        
        const chunk = encodedTranscript.slice(currentIndex, endIndex)
        stringsArray.push(decode(chunk))

        currentIndex = endIndex
      }

      return stringsArray
    }

    const encoded = encode(transcript)

    const stringsArray = splitTranscript(encoded, maxTokens)
    const result = await sendToChat(stringsArray)
    return result

    
    async function sendToChat (stringsArray) {
      
      const resultsArray = []

      for (let arr of stringsArray) {

        
        const prompt = `Analyze the transcript provided below, then provide the following:
Key "title:" - add a title.
Key "summary" - create a summary.
Key "main_points" - add an array of the main points. Limit each item to 100 words, and limit the list to 10 items.
Key "action_items:" - add an array of action items. Limit each item to 100 words, and limit the list to 5 items.
Key "follow_up:" - add an array of follow-up questions. Limit each item to 100 words, and limit the list to 5 items.
Key "stories:" - add an array of an stories, examples, or cited works found in the transcript. Limit each item to 200 words, and limit the list to 5 items.
Key "arguments:" - add an array of potential arguments against the transcript. Limit each item to 100 words, and limit the list to 5 items.
Key "related_topics:" - add an array of topics related to the transcript. Limit each item to 100 words, and limit the list to 5 items.
Key "sentiment" - add a sentiment analysis

Example formatting:

{
    "title": "Notion Buttons",
    "summary": "A collection of buttons for Notion",
    "action_items": [
        "item 1",
        "item 2",
        "item 3"
    ],
    "follow_up": [
        "item 1",
        "item 2",
        "item 3"
    ],
    "arguments": [
        "item 1",
        "item 2",
        "item 3"
    ],
    "related_topics": [
        "item 1",
        "item 2",
        "item 3"
    ]
    "sentiment": "positive"
}

Ensure that the final element of any array within the JSON object is not followed by a comma.

Transcript:
        
        ${arr}`

        let retries = 3
        while (retries > 0) {
          try {
            const completion = await openai.createChatCompletion({
              model: "gpt-3.5-turbo",
              messages: [{role: "user", content: prompt}, {role: "system", content: "You are an assistant that only speaks JSON. Do not write normal text."}],
              temperature: 0.2
            });
            
            resultsArray.push(completion)
            break
          } catch (error) {
            if(error.response && error.response.status === 500) {
              retries--
              if (retries == 0) {
                throw new Error("Failed to get a response from OpenAI Chat API after 3 attempts.")
              }
              console.log("OpenAI Chat API returned a 500 error. Retrying...")
            } else {
              throw error
            }
          }
        }

      }
      
      return resultsArray
    }
    
  },
})

Step 6: format_chat

Node → Run Node Code

export default defineComponent({
  async run({ steps, $ }) {
    
    const resultsArray = []
    for (let result of steps.openai_chat.$return_value) {
      
      
      function removeTrailingCommas(jsonString) {
        const regex = /,s*(?=])/g;
        return jsonString.replace(regex, '');
      }
      
      
      
      const jsonString = result.data.choices[0].message.content
        .replace(/^[^{]*?{/, '{')
        .replace(/}[^}]*?$/,'}')

      const cleanedJsonString = removeTrailingCommas(jsonString)
      
      let jsonObj
      try {
        jsonObj = JSON.parse(cleanedJsonString)
      } catch (error) {
        console.error("Error while parsing cleaned JSON string:")
        console.error(error)
        console.log("Original JSON string:", jsonString)
        console.log(cleanedJsonString)
        console.log("Cleaned JSON string:", cleanedJsonString)
        jsonObj = {}
      }
      
      const response = {
        choice: jsonObj,
        usage: !result.data.usage.total_tokens ? 0 : result.data.usage.total_tokens
      }

      resultsArray.push(response)
    }

    const chatResponse = {
      title: resultsArray[0].choice.title,
      sentiment: resultsArray[0].choice.sentiment,
      summary: [],
      main_points: [],
      action_items: [],
      stories: [],
      arguments: [],
      follow_up: [],
      related_topics: [],
      usageArray: []
    }

    for (let arr of resultsArray) {
      chatResponse.summary.push(arr.choice.summary)
      chatResponse.main_points.push(arr.choice.main_points)
      chatResponse.action_items.push(arr.choice.action_items)
      chatResponse.stories.push(arr.choice.stories)
      chatResponse.arguments.push(arr.choice.arguments)
      chatResponse.follow_up.push(arr.choice.follow_up)
      chatResponse.related_topics.push(arr.choice.related_topics)
      chatResponse.usageArray.push(arr.usage)
    }

    console.log(chatResponse.related_topics)

    function arraySum (arr) {
      const init = 0
      const sum = arr.reduce((accumulator, currentValue) => accumulator + currentValue, init)
      return sum
    }
    
    const finalChatResponse = {
      title: chatResponse.title,
      summary: chatResponse.summary.join(' '),
      sentiment: chatResponse.sentiment,
      main_points: chatResponse.main_points.flat(),
      action_items: chatResponse.action_items.flat(),
      stories: chatResponse.stories.flat(),
      arguments: chatResponse.arguments.flat(),
      follow_up: chatResponse.follow_up.flat(),
      related_topics: Array.from(new Set(chatResponse.related_topics.flat().map(item => item.toLowerCase()))).sort(),
      tokens: arraySum(chatResponse.usageArray)
    }

    return finalChatResponse

  },
})

Step 7: make_paragraphs

Node → Run Node Code

import natural from 'natural'

export default defineComponent({
  async run({ steps, $ }) {

    const tokenizer = new natural.SentenceTokenizer()
    const transcriptSentences = tokenizer.tokenize(steps.create_transcription.$return_value.transcription)
    const summarySentences = tokenizer.tokenize(steps.format_chat.$return_value.summary)

    const sentencesPerParagraph = 3

    function sentenceGrouper(arr) {
      const newArray = []

      for (let i = 0; i < arr.length; i+= sentencesPerParagraph) {
        const group = []
        for (let j = i; j < i + sentencesPerParagraph; j++) {
          if (arr[j]) {
            group.push(arr[j])
          }
        }

        newArray.push(group.join(' '))
      }

      return newArray
    }

    function charMaxChecker(arr) {
      const sentenceArray = arr.map((element) => {
          if (element.length > 800) {
            const pieces = element.match(/.{800}[^s]*s*/g);
            if (element.length > pieces.join('').length) {
                pieces.push(element.slice(pieces.join('').length));
            }
            return pieces;
        } else {
            return element;
        }
      }).flat()

      return sentenceArray
    }

    const paragraphs = sentenceGrouper(transcriptSentences)
    const lengthCheckedParagraphs = charMaxChecker(paragraphs)

    const summaryParagraphs = sentenceGrouper(summarySentences)
    const lengthCheckedSummaryParagraphcs = charMaxChecker(summaryParagraphs)

    const allParagraphs = {
      transcript: lengthCheckedParagraphs,
      summary: lengthCheckedSummaryParagraphcs
    }

    return allParagraphs

  },
})

Step 8: notion

Notion → Use any Notion API in Node.js

import { Client } from "@notionhq/client"
export default defineComponent({
  props: {
    notion: {
      type: "app",
      app: "notion",
    }
  },
  async run({steps, $}) {

    
    const notion = new Client({auth: this.notion.$auth.oauth_access_token});

    
    const dbID = process.env.CIG_ALL_NOTES_DB_ID

    
    const whisperRate = 0.006
    const gptTurboRate = 0.002

    
    const mp3Link = encodeURI("https://www.dropbox.com/home" + steps.trigger.event.path_lower);

    
    const duration = steps.get_duration.$return_value

    
    const today = new Date();
    const year = today.getFullYear();
    const month = String(today.getMonth() + 1).padStart(2, '0');
    const day = String(today.getDate()).padStart(2, '0');
    const date = `${year}-${month}-${day}`;

    
    const meta = steps.format_chat.$return_value

    
    meta.transcript = steps.make_paragraphs.$return_value.transcript

    
    meta.long_summary = steps.make_paragraphs.$return_value.summary

    
    const transcriptionCost = Number(((steps.get_duration.$return_value / 60) * whisperRate))
    meta['transcription-cost'] = `Transcription Cost: $${transcriptionCost.toFixed(3).toString()}`
    const chatCost = Number(((steps.format_chat.$return_value.tokens / 1000) * gptTurboRate))
    meta['chat-cost'] = `Chat API Cost: $${chatCost.toFixed(3).toString()}`
    const totalCost = Number((transcriptionCost + chatCost))
    meta['total-cost'] = `Total Cost: $${totalCost.toFixed(3).toString()}`

    
    const labeledSentiment = `Sentiment: ${meta.sentiment}`

    
    const data = {
      "parent": {
        "type": "database_id",
        "database_id": dbID
      },
      "icon": {
        "type": "emoji",
        "emoji": "🤖"
      },
      "properties": {
        "Title": {
          "title": [
            {
              "text": {
                "content": meta.title
              }
            }
          ]
        },
        "Type": {
          "select": {
            "name": "AI Transcription"
          }
        },
        "AI Cost": {
          "number": Math.round(totalCost * 1000) / 1000
        },
        "Duration (Seconds)": {
          "number": duration
        }
      },
      "children": [
        {
          "callout": {
            "rich_text": [
              {
                "text": {
                  "content": "This AI transcription and summary was created on "
                }
              },
              {
                mention: {
                  "type": "date",
                  "date": {
                    "start": date
                  }
                }
              },
              {
                "text": {
                  "content": ". "
                }
              },
              {
                "text": {
                  "content": "Listen to the original recording here.",
                  "link": {
                    "url": mp3Link
                  }
                }
              }
            ],
            "icon": {
              "emoji": "🤖"
            },
            "color": "blue_background"
          }
        },
        {
          "table_of_contents": {
            "color": "default"
          }
        },
        {
          "heading_1": {
            "rich_text": [
              {
                "text": {
                  "content": "Summary"
                }
              }
            ]
          }
        }
      ]
    }

    
    for (let paragraph of meta.long_summary) {
      const summaryParagraph = {
        "paragraph": {
          "rich_text": [
            {
              "text": {
                "content": paragraph
              }
            }
          ]
        }
      }

      data.children.push(summaryParagraph)
    }

    
    const transcriptHeader = {
      "heading_1": {
        "rich_text": [
          {
            "text": {
              "content": "Transcript"
            }
          }
        ]
      }
    }
    
    data.children.push(transcriptHeader)

    
    
    
    const transcriptHolder = []
    const transcriptBlockMaxLength = 80

    for (let i = 0; i < meta.transcript.length; i += transcriptBlockMaxLength ) {
      const chunk = meta.transcript.slice(i, i + transcriptBlockMaxLength)
      transcriptHolder.push(chunk)
    }


    
    const firstTranscriptBlock = transcriptHolder[0]
    console.log(firstTranscriptBlock)
    for (let sentence of firstTranscriptBlock) {
      const paragraphBlock = {
        "paragraph": {
          "rich_text": [
            {
              "text": {
                "content": sentence
              }
            }
          ]
        }
      };
      console.log(sentence)
      data.children.push(paragraphBlock)
    }

    

    const additionalInfoArray = []

    const additionalInfoHeader = {
      "heading_1": {
        "rich_text": [
          {
            "text": {
              "content": "Additional Info"
            }
          }
        ]
      }
    }

    additionalInfoArray.push(additionalInfoHeader)

    

    function additionalInfoHandler (arr, header, itemType) {
      const infoHeader = {
        "heading_2": {
          "rich_text": [
            {
              "text": {
                "content": header
              }
            }
          ]
        }
      }

      additionalInfoArray.push(infoHeader)

      if (header === "Arguments and Areas for Improvement") {
        const argWarning = {
          "callout": {
            "rich_text": [
              {
                "text": {
                  "content": "These are potential arguments and rebuttals that other people may bring up in response to the transcript. Like every other part of this summary document, factual accuracy is not guaranteed."
                }
              }
            ],
            "icon": {
              "emoji": "⚠️"
            },
            "color": "orange_background"
          }
        }
      }

      for (let item of arr) {
        const infoItem = {
          [itemType]: {
            "rich_text": [
              {
                "text": {
                  "content": item
                }
              }
            ]
          }
        }

        additionalInfoArray.push(infoItem)
      }
    }

    additionalInfoHandler(meta.main_points, "Main Points", "bulleted_list_item")
    additionalInfoHandler(meta.stories, "Stories, Examples, and Citations", "bulleted_list_item")
    additionalInfoHandler(meta.action_items, "Potential Action Items", "to_do")
    additionalInfoHandler(meta.follow_up, "Follow-Up Questions", "bulleted_list_item")
    additionalInfoHandler(meta.arguments, "Arguments and Areas for Improvement", "bulleted_list_item")
    additionalInfoHandler(meta.related_topics, "Related Topics", "bulleted_list_item")

    
    const metaArray = [labeledSentiment, meta['transcription-cost'], meta['chat-cost'], meta['total-cost']]
    additionalInfoHandler(metaArray, "Meta", "bulleted_list_item")

    
    const response = await notion.pages.create( data )

    
    const responseHolder = {
      response: response,
      transcript: transcriptHolder,
      additional_info: additionalInfoArray
    }

    return responseHolder


  },
})

Step 9: update_page

Notion → Use any Notion API in Node.js

import { Client } from "@notionhq/client"
export default defineComponent({
  props: {
    notion: {
      type: "app",
      app: "notion",
    }
  },
  async run({steps, $}) {

    const notion = new Client({auth: this.notion.$auth.oauth_access_token});

    
    const pageID = steps.notion.$return_value.response.id.replace(/-/g,'')

    
    
    
    async function sendTranscripttoNotion (transcript) {
      
      const data = {
        block_id: pageID,
        children: []
      }

      for (let sentence of transcript) {
        const paragraphBlock = {
          "paragraph": {
            "rich_text": [
              {
                "text": {
                  "content": sentence
                }
              }
            ]
          }
        };

        data.children.push(paragraphBlock)
      }

      const response = await notion.blocks.children.append(data)
      return response
    }

    const transcriptArray = steps.notion.$return_value.transcript
    transcriptArray.shift()
    const transcriptAdditionResponses = []
    for (let transcript of transcriptArray) {
      const response = await sendTranscripttoNotion(transcript)
      transcriptAdditionResponses.push(response)
    }

    
    
    
    const additionalInfo = steps.notion.$return_value.additional_info
    const infoHolder = []
    const infoBlockMaxLength = 95

    for (let i = 0; i < additionalInfo.length; i += infoBlockMaxLength ) {
      const chunk = additionalInfo.slice(i, i + infoBlockMaxLength)
      infoHolder.push(chunk)
    }
    
    
    async function sendAdditionalInfotoNotion (info) {

      const data = {
        block_id: pageID,
        children: []
      }

      for (let block of info) {
        data.children.push(block)
      }

      const response = await notion.blocks.children.append(data)
      return response

    }

    const additionalInfoAdditionResponses = []
    for (let addition of infoHolder) {
      const response = await sendAdditionalInfotoNotion(addition)
      additionalInfoAdditionResponses.push(response)
    }

    const allAPIResponses = {
      transcript_responses: transcriptAdditionResponses,
      additional_info_responses: additionalInfoAdditionResponses
    }

    return allAPIResponses

  },
})