Skip to content
BranchesTags

Latest commit

History

21 Commits

Folders and files

NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md

Repository files navigation

VideoToBlogAI

Project Proposal for the AssemblyAI Challenge

Overview

VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.

Main Image

Upload ImageEditPost Image

Features

  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:
    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.

Technologies Used

  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)

Prerequisites

Make sure you have the following installed:

  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key

Setup Instructions

  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.

Step1: Backend Installation

Clone the Repository

Clone the TextTriangleAI repository from GitHub:

git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend

Install Dependencies

Install the necessary dependencies using npm:

npm install

Configuration (.env)

Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:

ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog

Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.

Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.

Running the Server

To run the backend server locally, use the following command:

node app.js

This starts the Node.js server.

First Run Setup

When you first run the project, an admin user will be created automatically:

Username: admin@gmail.com
Password: Admin@1103

This is initialized by initializeAdmin.js located in the utils folder.

Accessing Analytics

To access the /analytics route, you need to log in using the following credentials:

Username: admin@gmail.com
Password: Admin@1103

This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.

Step2: Frontend Installation

cd VideoToBlogAI/frontend

Install Dependencies

Install the necessary dependencies using npm:

npm install

Configuration

Add url to .env file in the root of the frontend directory and add the following content:

NEXT_PUBLIC_API_BASE_URL=http://localhost:3000

This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.

Running the Development Server

To run the development server locally, use the following command:

npm run dev

This starts the Next.js development server on http://localhost:3000.

Building for Production

To build the project for production, run:

npm run build

This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.

Additional Notes

  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production

Contributors

License

This project is licensed under the [MIT] License - see the LICENSE file for details.

About

Convert your video to technical blog post using AI

shark-app-n5snu.ondigitalocean.app

Resources

Readme
MIT license
Activity

Stars

3 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - bakkeshks/VideoToBlogAI: Convert your video to technical blog post using AI · GitHub
Skip to content
BranchesTags
Latest commit
History
21 Commits
Folders and files
NameName
Last commit message
Last commit date
backend
backend
frontend
frontend
images
images
.gitignore
.gitignore
LICENSE
LICENSE
README.md
README.md
Repository files navigation
VideoToBlogAI
Project Proposal for the AssemblyAI Challenge
Overview
VideoToBlogAI is a project designed to generate technical blog posts from various sources such as local videos, and audio files (with a 30 MB limit). It leverages the Google Gemini AI API for language model tasks and AssemblyAI API for speech-to-text functionality.
Main Image
Upload ImageEditPost Image
Features
  • User registration and sign-in with error handling.
  • Admin analytics: blog post generation, total hours processed.
  • Content uploads: MP4 videos, MP3 audio (max 30 MB).
  • Credit check: Verify user credits before generating blog posts and manage available time for processing.
  • AI-generated blog posts: view, edit, delete, save.
  • Automatic code extraction from videos, audios and youtube url.
  • Features: Word count, character count, dynamic table of contents, semantic analysis.
  • Rendering: Markdown format with Next.js for a user-friendly interface.
  • Transcription services:

    • Video/audio: AssemblyAI's speech-to-text API.
  • Google Gemini API: Transform transcriptions into blog posts.
Technologies Used
  • Frontend: Next.js, Shadcn/UI, Tailwind CSS, Highlight.js
  • Backend: Node.js, Express.js, MongoDB
  • AI APIs: Google Gemini AI API (for language model tasks), AssemblyAI API (for speech-to-text)
  • Authentication: JWT (JSON Web Tokens)
Prerequisites
Make sure you have the following installed:
  • Node.js (version 18 or higher)
  • npm (Node Package Manager)
  • MongoDB Installed Locally or Mongodb Cloud
  • Google GeminiAI Api key & AssemblyAI Api key
Setup Instructions
  1. Clone the repository from [git clone https://github.com/bakkeshks/VideoToBlogAI.git].
  2. Navigate to the project directory.
  3. Install dependencies using npm install.
  4. Set up MongoDB and configure the connection string in the backend.
  5. Obtain API keys for Google Gemini AI and AssemblyAI and configure them in the backend.
  6. Run the backend server using node app.js (for development).
  7. Run the frontend server using npm run dev in the frontend directory.
  8. Access the application at http://localhost:3000 in your web browser.
Step1: Backend Installation
Clone the Repository
Clone the TextTriangleAI repository from GitHub:
git clone https://github.com/your-username/VideoToBlogAI.git
cd VideoToBlogAI/backend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration (.env)
Add Gemini AI, AssemblyAI, JWT (random no) to a .env file in the root of the backend directory and add the following environment variables:
ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
GEMINIAI_API_KEY=your_geminiapi_api_key_here
JWT_SECRET=7c6f1f6e064d6f9f9f4b2e6faa1d57e4
MONGODB_URI=mongodb://localhost:27017/videotoblog
Adjust the values for ASSEMBLYAI_API_KEY, GEMINIAI_API_KEY, MONGODB_URI and JWT_SECRET with your actual API keys and JWT secret.
Make sure the MongoDB URI (uri) matches your local MongoDB setup or your cloud database URL.
Running the Server
To run the backend server locally, use the following command:
node app.js
This starts the Node.js server.
First Run Setup
When you first run the project, an admin user will be created automatically:
Username: admin@gmail.com
Password: Admin@1103
This is initialized by initializeAdmin.js located in the utils folder.
Accessing Analytics
To access the /analytics route, you need to log in using the following credentials:
Username: admin@gmail.com
Password: Admin@1103
This route provides insights such as the number of users who generated blog posts, total hours processed, and other user metrics.
Step2: Frontend Installation
cd VideoToBlogAI/frontend
Install Dependencies
Install the necessary dependencies using npm:
npm install
Configuration
Add url to .env file in the root of the frontend directory and add the following content:
NEXT_PUBLIC_API_BASE_URL=http://localhost:3000
This sets the base URL for API requests. Adjust NEXT_PUBLIC_API_BASE_URL if your backend server runs on a different port or domain.
Running the Development Server
To run the development server locally, use the following command:
npm run dev
This starts the Next.js development server on http://localhost:3000.
Building for Production
To build the project for production, run:
npm run build
This command builds the application for production usage. You can then deploy the contents of the out directory to your hosting provider.
Additional Notes
  • Ensure that API rate limits and usage quotas are respected to avoid service interruptions.
  • I had used Google Gemini 1.5 Flash for Text Generation (Rate Limit Free tier: 15 Request & 1 million token per minute)
  • I had used AssemblyAI speech to text api to transcribe media into text (Rate Limit Free Account: 5 concurrent users and 100 Hours free transcribe of speech to text api for free account).
  • This project is developed with handling small number of users not suitable for production
Contributors
License
This project is licensed under the [MIT] License - see the LICENSE file for details.
About
Convert your video to technical blog post using AI 
shark-app-n5snu.ondigitalocean.app
Resources
Readme
MIT license
Activity
Stars
3 stars
Watchers
1 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors
Languages