+7
🔄 Workflow Repos8r: Github Version Control User Interface for n8n Workflows
Published 1 day ago
Template description
💪 How it works
Seamlessly track, manage, and version-control your n8n workflows with an intuitive Git-style system. Whether you're making updates or creating new workflows, this tool ensures structured commits, detailed change tracking, and seamless GitHub integration—all within a Matrix-inspired UI.
🎯 Who is this for?
Perfect for:
- n8n Developers & Automation Engineers – Maintain workflow history and prevent accidental overwrites.
- Teams Collaborating on Automation – Track and commit changes with structured version control.
- DevOps & IT Professionals – Streamline deployment across multiple n8n environments.
🚀 Key Features
Version Control & Workflow Management
- Commit changes when editing existing workflows
- Create & commit new workflows from scratch
- Detect modifications with deep node comparison
- Access repo with direct links from changes window
- Workflow JSON Browser Caching **to avoid large loads on n8n"
Core Features
Workflow Management
- Workflow Selection: Easy selection of n8n workflows and GitHub workflows from dropdown menus
- Smart Caching: Client-side caching of workflows for faster loading (1-week cache duration)
- Cache Control: Manual cache clearing via hard refresh (Cmd+Shift+R)
- Matrix-Style UI: Terminal-inspired interface with glowing effects and animations
GitHub Integration
- Push to GitHub: Direct pushing of n8n workflows to GitHub repositories
- Commit Control: Automated commit message generation with workflow details
- Branch Management: Automatic branch creation and management
- Pull from GitHub: Future feature for pulling workflows from GitHub (Coming Soon)
Workflow Comparison
- Side-by-Side Comparison: Compare n8n workflows with their GitHub counterparts
- Change Detection: Automatic detection and highlighting of workflow changes
- Diff Visualization: Clear visualization of additions, deletions, and modifications
- JSON Validation: Ensures workflow JSON integrity before operations
User Experience
- System Notifications: Matrix-themed toast notifications for important alerts
- 30-second duration with manual close option
- Context-aware messages (e.g., cache refresh hints)
- Glowing effects matching system console aesthetics
- Loading Animations: Matrix-style loading indicators during operations
- Error Handling: Clear error messages and recovery suggestions
- Responsive Design: Adapts to different screen sizes
Security & Performance
- Local Storage: Efficient client-side storage for workflow data
- Header Authentication: Secure API communication with authentication tokens
- Performance Optimization: Smart caching to reduce server load
- Data Validation: Input validation and sanitization
Technical Features
Code Organization
- Modular Structure: Well-organized HTML, CSS, and JavaScript
- Component Separation: Clear separation of concerns
- CSS Variables: Consistent styling with CSS custom properties
- Event Handling: Robust event listeners and handlers
API Integration
- n8n Integration: Direct communication with n8n workflow API
- GitHub API: Seamless integration with GitHub repositories
- RESTful Endpoints: Clean API design for workflow operations
- Error Handling: Comprehensive error handling and user feedback
Development Features
- Debug Mode: Console logging for development
- Code Comments: Well-documented code sections
- CSS Animations: Smooth transitions and effects
- Browser Compatibility: Works across modern browsers
Future Enhancements
- Pull workflows from GitHub repositories
- Enhanced diff visualization
- Additional GitHub integration features
- Extended caching options
- More customization options for notifications
- Advanced workflow comparison tools
GitHub Integration
- Push workflows directly to GitHub
- Commit new workflows directly to GitHub
- Auto-generate structured commit messages
- 🔴 (Coming Soon: Pull workflows from GitHub into n8n)
Change Detection
- Identifies node additions, deletions, and property modifications
- Compares connections, settings, and configurations
- Real-time visualization of detected changes
Sleek UI for Effortless Control
- Matrix-style interface for a futuristic feel
- Clear prompts to prevent accidental overwrites
- Interactive workflow commit & sync options
🔧 Setup & Usage
- Generate your n8n API key
- Set up GitHub repository & access tokens
- Create Generic Basic Auth credentials
- Create Generic Header Auth credentials
- Set the workflow variables
- Deploy & start tracking your workflow versions
📚 Use Cases
🔹 Workflow Development – Ensure clean versioning and commit history.
🔹 Team Collaboration – Review and track modifications before deployment.
🔹 Audit & Compliance – Maintain an organized change log.
🙌 Built for the n8n Community
Created with ❤️ to bring reliable version control to the n8n community.
Share Template
More Engineering workflow templates
Creating an API endpoint
Task:
Create a simple API endpoint using the Webhook and Respond to Webhook nodes
Why:
You can prototype or replace a backend process with a single workflow
Main use cases:
Replace backend logic with a workflow
Jonathan
Joining different datasets
Task:
Merge two datasets into one based on matching rules
Why:
A powerful capability of n8n is to easily branch out the workflow in order to process different datasets. Even more powerful is the ability to join them back together with SQL-like joining logic.
Main use cases:
Appending data sets
Keep only new items
Keep only existing items
Jonathan
+11
Back Up Your n8n Workflows To Github
This workflow will backup your workflows to Github. It uses the public api to export all of the workflow data using the n8n node.
It then loops over the data checks in Github to see if a file exists that uses the workflow name. Once checked it will then update the file on Github if it exists, Create a new file if it doesn't exist and if it's the same it will ignore the file.
Config Options
repo_owner - Github owner
repo_name - Github repository name
repo_path - Path within the Github repository
>This workflow has been updated to use the n8n node and the code node so requires at least version 0.198.0 of n8n
Jonathan
+8
Scrape and store data from multiple website pages
This workflow allows extracting data from multiple pages website.
The workflow:
1) Starts in a country list at https://www.theswiftcodes.com/browse-by-country/.
2) Loads every country page (https://www.theswiftcodes.com/albania/)
3) Paginates every page in the country page.
4) Extracts data from the country page.
5) Saves data to MongoDB.
6) Paginates through all pages in all countries.
It uses getWorkflowStaticData('global') method to recover the next page (saved from the previous page), and it goes ahead with all the pages.
There is a first section where the countries list is recovered and extracted.
Later, I try to read if a local cache page is available and I recover the cached page from the disk.
Finally, I save data to MongoDB, and we paginate all the pages in the country and for all the countries.
I have applied a cache system to save a visited page to n8n local disk. If I relaunch workflow, we check if a cache file exists to discard non-required requests to the webpage.
If the data present in the website changes, you can apply a Cron node to check the website once per week.
Finally, before inserting data in MongoDB, the best way to avoid duplicates is to check that swift_code (the primary value of the collection) doesn't exist.
I recommend using a proxy for all requests to avoid IP blocks. A good solution for proxy plus IP rotation is scrapoxy.io.
This workflow is perfect for small data requirements. If you need to scrape dynamic data, you can use a Headless browser or any other service.
If you want to scrape huge lists of URIs, I recommend using Scrapy + Scrapoxy.
Miquel Colomer
+13
AI Agent To Chat With Files In Supabase Storage
Video Guide
I prepared a detailed guide explaining how to set up and implement this scenario, enabling you to chat with your documents stored in Supabase using n8n.
Youtube Link
Who is this for?
This workflow is ideal for researchers, analysts, business owners, or anyone managing a large collection of documents. It's particularly beneficial for those who need quick contextual information retrieval from text-heavy files stored in Supabase, without needing additional services like Google Drive.
What problem does this workflow solve?
Manually retrieving and analyzing specific information from large document repositories is time-consuming and inefficient. This workflow automates the process by vectorizing documents and enabling AI-powered interactions, making it easy to query and retrieve context-based information from uploaded files.
What this workflow does
The workflow integrates Supabase with an AI-powered chatbot to process, store, and query text and PDF files. The steps include:
Fetching and comparing files to avoid duplicate processing.
Handling file downloads and extracting content based on the file type.
Converting documents into vectorized data for contextual information retrieval.
Storing and querying vectorized data from a Supabase vector store.
File Extraction and Processing: Automates handling of multiple file formats (e.g., PDFs, text files), and extracts document content.
Vectorized Embeddings Creation: Generates embeddings for processed data to enable AI-driven interactions.
Dynamic Data Querying: Allows users to query their document repository conversationally using a chatbot.
Setup
N8N Workflow
Fetch File List from Supabase:
Use Supabase to retrieve the stored file list from a specified bucket.
Add logic to manage empty folder placeholders returned by Supabase, avoiding incorrect processing.
Compare and Filter Files:
Aggregate the files retrieved from storage and compare them to the existing list in the Supabase files table.
Exclude duplicates and skip placeholder files to ensure only unprocessed files are handled.
Handle File Downloads:
Download new files using detailed storage configurations for public/private access.
Adjust the storage settings and GET requests to match your Supabase setup.
File Type Processing:
Use a Switch node to target specific file types (e.g., PDFs or text files).
Employ relevant tools to process the content:
For PDFs, extract embedded content.
For text files, directly process the text data.
Content Chunking:
Break large text data into smaller chunks using the Text Splitter node.
Define chunk size (default: 500 tokens) and overlap to retain necessary context across chunks.
Vector Embedding Creation:
Generate vectorized embeddings for the processed content using OpenAI's embedding tools.
Ensure metadata, such as file ID, is included for easy data retrieval.
Store Vectorized Data:
Save the vectorized information into a dedicated Supabase vector store.
Use the default schema and table provided by Supabase for seamless setup.
AI Chatbot Integration:
Add a chatbot node to handle user input and retrieve relevant document chunks.
Use metadata like file ID for targeted queries, especially when multiple documents are involved.
Testing
Upload sample files to your Supabase bucket.
Verify if files are processed and stored successfully in the vector store.
Ask simple conversational questions about your documents using the chatbot (e.g., "What does Chapter 1 say about the Roman Empire?").
Test for accuracy and contextual relevance of retrieved results.
Mark Shcherbakov
+5
Google Maps Scraper
This workflow allows to scrape Google Maps data in an efficient way using SerpAPI.
You'll get all data from Gmaps at a cheaper cost than Google Maps API.
Add as input, your Google Maps search URL and you'll get a list of places with many data points such as:
phone number
website
rating
reviews
address
And much more.
Full guide to implement the workflow is here:
https://lempire.notion.site/Scrape-Google-Maps-places-with-n8n-b7f1785c3d474e858b7ee61ad4c21136?pvs=4
Lucas Perret
More DevOps workflow templates
+13
AI Agent To Chat With Files In Supabase Storage
Video Guide
I prepared a detailed guide explaining how to set up and implement this scenario, enabling you to chat with your documents stored in Supabase using n8n.
Youtube Link
Who is this for?
This workflow is ideal for researchers, analysts, business owners, or anyone managing a large collection of documents. It's particularly beneficial for those who need quick contextual information retrieval from text-heavy files stored in Supabase, without needing additional services like Google Drive.
What problem does this workflow solve?
Manually retrieving and analyzing specific information from large document repositories is time-consuming and inefficient. This workflow automates the process by vectorizing documents and enabling AI-powered interactions, making it easy to query and retrieve context-based information from uploaded files.
What this workflow does
The workflow integrates Supabase with an AI-powered chatbot to process, store, and query text and PDF files. The steps include:
Fetching and comparing files to avoid duplicate processing.
Handling file downloads and extracting content based on the file type.
Converting documents into vectorized data for contextual information retrieval.
Storing and querying vectorized data from a Supabase vector store.
File Extraction and Processing: Automates handling of multiple file formats (e.g., PDFs, text files), and extracts document content.
Vectorized Embeddings Creation: Generates embeddings for processed data to enable AI-driven interactions.
Dynamic Data Querying: Allows users to query their document repository conversationally using a chatbot.
Setup
N8N Workflow
Fetch File List from Supabase:
Use Supabase to retrieve the stored file list from a specified bucket.
Add logic to manage empty folder placeholders returned by Supabase, avoiding incorrect processing.
Compare and Filter Files:
Aggregate the files retrieved from storage and compare them to the existing list in the Supabase files table.
Exclude duplicates and skip placeholder files to ensure only unprocessed files are handled.
Handle File Downloads:
Download new files using detailed storage configurations for public/private access.
Adjust the storage settings and GET requests to match your Supabase setup.
File Type Processing:
Use a Switch node to target specific file types (e.g., PDFs or text files).
Employ relevant tools to process the content:
For PDFs, extract embedded content.
For text files, directly process the text data.
Content Chunking:
Break large text data into smaller chunks using the Text Splitter node.
Define chunk size (default: 500 tokens) and overlap to retain necessary context across chunks.
Vector Embedding Creation:
Generate vectorized embeddings for the processed content using OpenAI's embedding tools.
Ensure metadata, such as file ID, is included for easy data retrieval.
Store Vectorized Data:
Save the vectorized information into a dedicated Supabase vector store.
Use the default schema and table provided by Supabase for seamless setup.
AI Chatbot Integration:
Add a chatbot node to handle user input and retrieve relevant document chunks.
Use metadata like file ID for targeted queries, especially when multiple documents are involved.
Testing
Upload sample files to your Supabase bucket.
Verify if files are processed and stored successfully in the vector store.
Ask simple conversational questions about your documents using the chatbot (e.g., "What does Chapter 1 say about the Roman Empire?").
Test for accuracy and contextual relevance of retrieved results.
Mark Shcherbakov
+9
Generate SQL queries from schema only - AI-powered
This workflow is a modification of the previous template on how to create an SQL agent with LangChain and SQLite.
The key difference – the agent has access only to the database schema, not to the actual data. To achieve this, SQL queries are made outside the AI Agent node, and the results are never passed back to the agent.
This approach allows the agent to generate SQL queries based on the structure of tables and their relationships, without having to access the actual data.
This makes the process more secure and efficient, especially in cases where data confidentiality is crucial.
🚀 Setup
To get started with this workflow, you’ll need to set up a free MySQL server and import your database (check Step 1 and 2 in this tutorial).
Of course, you can switch MySQL to another SQL database such as PostgreSQL, the principle remains the same. The key is to download the schema once and save it locally to avoid repeated remote connections.
Run the top part of the workflow once to download and store the MySQL chinook database schema file on the server.
With this approach, we avoid the need to repeatedly connect to a remote db4free database and fetch the schema every time. As a result, we reach greater processing speed and efficiency.
🗣️ Chat with your data
Start a chat: send a message in the chat window.
The workflow loads the locally saved MySQL database schema, without having the ability to touch the actual data. The file contains the full structure of your MySQL database for analysis.
The Langchain AI Agent receives the schema, your input and begins to work.
The AI Agent generates SQL queries and brief comments based solely on the schema and the user’s message.
An IF node checks whether the AI Agent has generated a query. When:
Yes: the AI Agent passes the SQL query to the next MySQL node for execution.
No: You get a direct answer from the Agent without further action.
The workflow formats the results of the SQL query, ensuring they are convenient to read and easy to understand.
Once formatted, you get both the Agent answer and the query result in the chat window.
🌟 Example queries
Try these sample queries to see the schema-driven AI Agent in action:
Would you please list me all customers from Germany?
What are the music genres in the database?
What tables are available in the database?
Please describe the relationships between tables. - In this example, the AI Agent does not need to create the SQL query.
And if you prefer to keep the data private, you can manually execute the generated SQL query in your own environment using any database client or tool you trust 🗄️
💭 The AI Agent memory node does not store the actual data as we run SQL-queries outside the agent. It contains the database schema, user questions and the initial Agent reply. Actual SQL query results are passed to the chat window, but the values are not stored in the Agent memory.
Yulia
AI Agent to chat with Supabase/PostgreSQL DB
Video Guide
I prepared a detailed guide that showed the whole process of building a resume analyzer.
Who is this for?
This workflow is ideal for developers, data analysts, and business owners who want to enable conversational interactions with their database. It’s particularly useful for cases where users need to extract, analyze, or aggregate data without writing SQL queries manually.
What problem does this workflow solve?
Accessing and analyzing database data often requires SQL expertise or dedicated reports, which can be time-consuming. This workflow empowers users to interact with a database conversationally through an AI-powered agent. It dynamically generates SQL queries based on user requests, streamlining data retrieval and analysis.
What this workflow does
This workflow integrates OpenAI with a Supabase database, enabling users to interact with their data via an AI agent. The agent can:
Retrieve records from the database.
Extract and analyze JSON data stored in tables.
Provide summaries, aggregations, or specific data points based on user queries.
Dynamic SQL Querying: The agent uses user prompts to create and execute SQL queries on the database.
Understand JSON Structure: The workflow identifies JSON schema from sample records, enabling the agent to parse and analyze JSON fields effectively.
Database Schema Exploration: It provides the agent with tools to retrieve table structures, column details, and relationships for precise query generation.
Setup
Preparation
Create Accounts:
N8N: For workflow automation.
Supabase: For database hosting and management.
OpenAI: For building the conversational AI agent.
Configure Database Connection:
Set up a PostgreSQL database in Supabase.
Use appropriate credentials (username, password, host, and database name) in your workflow.
N8N Workflow
AI agent with tools:
Code Tool:
Execute SQL queries based on user input.
Database Schema Tool:
Retrieve a list of all tables in the database.
Use a predefined SQL query to fetch table definitions, including column names, types, and references.
Table Definition:
Retrieve a list of columns with types for one table.
Mark Shcherbakov
Git backup of workflows and credentials
This creates a git backup of the workflows and credentials.
It uses the n8n export command with git diff, so you can run as many times as you want, but only when there are changes they will create a commit.
Setup
You need some access to the server.
Create a repository in some remote place to host your project, like Github, Gitlab, or your favorite private repo.
Clone the repository in the server in a place that the n8n has access. In the example, it's the ., and the repository name is repo. Change it in the commands and in the workflow commands (you can set it as a variable in the wokflow). Checkout to another branch if you won't use the master one.
cd .
git clone repository
Or you could git init and then add the remote (git remote add origin YOUR_REPO_URL), whatever pleases you more.
As the server, check if everything is ok for beeing able to commit. Very likely you'll need to setup the user email and name. Try to create a commit, and push it to upstream, and everything you need (like config a user to comit) will appear in way. I strong suggest testing with exporting the commands to garantee it will work too.
cd ./repo
git commit -c "Initial commmit" --allow-empty
-u is the same as --set-upstream
git push -u origin master
Testing to push to upstream with the first exported data
npx n8n export:workflow --backup --output ./repo/workflows/
npx n8n export:credentials --backup --output repo/credentials/
cd ./repo
git add .
git commit -c "manual backup: first export"
git push
After that, if everything is ok, the workflow should work just fine.
Adjustments
Adjust the path in used in the workflow. See the the git -C PATH command is the same as cd PATH; git ....
Also, adjust the cron to run as you need. As I said in the beginning, you can run it even for every minute, but it will create commits only when there are changes.
Credentials encryption
The default for exporting the credentials is to do them encrypted. You can add the flag --decrypted to the n8n export:credentials command if you need to save them in plain. But as general rule, it's better to save the encryption key, that you only need to do that once, and them export it safely encrypted.
Allan Daemon
+4
Host your own Uptime Monitoring with Scheduled Triggers
This n8n workflow demonstrates how to build a simple uptime monitoring service using scheduled triggers.
Useful for webmasters with a handful of sites who want a cost-effective solution without the need for all the bells and whistles.
How it works
Scheduled trigger reads a list of website urls in a Google Sheet every 5 minutes
Each website url is checked using the HTTP node which determines if the website is either in the UP or DOWN state.
An email and Slack message are sent for websites which are in the DOWN state.
The Google Sheet is updated with the website's state and a log created.
Logs can be used to determine total % of UP and DOWN time over a period.
Requirements
Google Sheet for storing websites to monitor and their states
Gmail for email alerts
Slack for channel alerts
Customising the workflow
Don't use Google Sheets? This can easily be exchanged with Excel or Airtable.
Jimleuk
+10
Proxmox AI Agent with n8n and Generative AI Integration
Proxmox AI Agent with n8n and Generative AI Integration
This template automates IT operations on a Proxmox Virtual Environment (VE) using an AI-powered conversational agent built with n8n. By integrating Proxmox APIs and generative AI models (e.g., Google Gemini), the workflow converts natural language commands into API calls, enabling seamless management of your Proxmox nodes, VMs, and clusters.
Watch Video on Youtube
How It Works
Trigger Mechanism
The workflow can be triggered through multiple channels like chat (Telegram, email, or n8n's built-in chat).
Interact with the AI agent conversationally.
AI-Powered Parsing
A connected AI model (Google Gemini or other compatible models like OpenAI or Claude) processes your natural language input to determine the required Proxmox API operation.
API Call Generation
The AI parses the input and generates structured JSON output, which includes:
response_type: The HTTP method (GET, POST, PUT, DELETE).
url: The Proxmox API endpoint to execute.
details: Any required payload parameters for the API call.
Proxmox API Execution
The structured output is used to make HTTP requests to the Proxmox VE API. The workflow supports various operations, such as:
Retrieving cluster or node information.
Creating, deleting, starting, or stopping VMs.
Migrating VMs between nodes.
Updating or resizing VM configurations.
Response Formatting
The workflow formats API responses into a user-friendly summary. For example:
Success messages for operations (e.g., "VM started successfully").
Error messages with missing parameter details.
Extensibility
You can enhance the workflow by connecting additional triggers, external services, or AI models. It supports:
Telegram/Slack integration for real-time notifications.
Backup and restore workflows.
Cloud monitoring extensions.
Key Features
Multi-Channel Input**: Use chat, email, or custom triggers to communicate with the AI agent.
Low-Code Automation**: Easily customize the workflow to suit your Proxmox environment.
Generative AI Integration**: Supports advanced AI models for precise command interpretation.
Proxmox API Compatibility**: Fully adheres to Proxmox API specifications for secure and reliable operations.
Error Handling**: Detects and informs you of missing or invalid parameters in your requests.
Example Use Cases
Create a Virtual Machine
Input: "Create a VM with 4 cores, 8GB RAM, and 50GB disk on psb1."
Action: Sends a POST request to Proxmox to create the VM with specified configurations.
Start a VM
Input: "Start VM 105 on node psb2."
Action: Executes a POST request to start the specified VM.
Retrieve Node Details
Input: "Show the memory usage of psb3."
Action: Sends a GET request and returns the node's resource utilization.
Migrate a VM
Input: "Migrate VM 202 from psb1 to psb3."
Action: Executes a POST request to move the VM with optional online migration.
Pre-Requisites
Proxmox API Configuration
Enable the Proxmox API and generate API keys in the Proxmox Data Center.
Use the Authorization header with the format:
PVEAPIToken=<user>@<realm>!<token-id>=<token-value>
n8n Setup
Add Proxmox API credentials in n8n using Header Auth.
Connect a generative AI model (e.g., Google Gemini) via the relevant credential type.
Access the Workflow
Import this template into your n8n instance.
Replace placeholder credentials with your Proxmox and AI service details.
Additional Notes
This template is designed for Proxmox 7.x and above.
For advanced features like backup, VM snapshots, and detailed node monitoring, you can extend this workflow.
Always test with a non-production Proxmox environment before deploying in live systems.
Amjid Ali
More IT Ops workflow templates
+13
AI Agent To Chat With Files In Supabase Storage
Video Guide
I prepared a detailed guide explaining how to set up and implement this scenario, enabling you to chat with your documents stored in Supabase using n8n.
Youtube Link
Who is this for?
This workflow is ideal for researchers, analysts, business owners, or anyone managing a large collection of documents. It's particularly beneficial for those who need quick contextual information retrieval from text-heavy files stored in Supabase, without needing additional services like Google Drive.
What problem does this workflow solve?
Manually retrieving and analyzing specific information from large document repositories is time-consuming and inefficient. This workflow automates the process by vectorizing documents and enabling AI-powered interactions, making it easy to query and retrieve context-based information from uploaded files.
What this workflow does
The workflow integrates Supabase with an AI-powered chatbot to process, store, and query text and PDF files. The steps include:
Fetching and comparing files to avoid duplicate processing.
Handling file downloads and extracting content based on the file type.
Converting documents into vectorized data for contextual information retrieval.
Storing and querying vectorized data from a Supabase vector store.
File Extraction and Processing: Automates handling of multiple file formats (e.g., PDFs, text files), and extracts document content.
Vectorized Embeddings Creation: Generates embeddings for processed data to enable AI-driven interactions.
Dynamic Data Querying: Allows users to query their document repository conversationally using a chatbot.
Setup
N8N Workflow
Fetch File List from Supabase:
Use Supabase to retrieve the stored file list from a specified bucket.
Add logic to manage empty folder placeholders returned by Supabase, avoiding incorrect processing.
Compare and Filter Files:
Aggregate the files retrieved from storage and compare them to the existing list in the Supabase files table.
Exclude duplicates and skip placeholder files to ensure only unprocessed files are handled.
Handle File Downloads:
Download new files using detailed storage configurations for public/private access.
Adjust the storage settings and GET requests to match your Supabase setup.
File Type Processing:
Use a Switch node to target specific file types (e.g., PDFs or text files).
Employ relevant tools to process the content:
For PDFs, extract embedded content.
For text files, directly process the text data.
Content Chunking:
Break large text data into smaller chunks using the Text Splitter node.
Define chunk size (default: 500 tokens) and overlap to retain necessary context across chunks.
Vector Embedding Creation:
Generate vectorized embeddings for the processed content using OpenAI's embedding tools.
Ensure metadata, such as file ID, is included for easy data retrieval.
Store Vectorized Data:
Save the vectorized information into a dedicated Supabase vector store.
Use the default schema and table provided by Supabase for seamless setup.
AI Chatbot Integration:
Add a chatbot node to handle user input and retrieve relevant document chunks.
Use metadata like file ID for targeted queries, especially when multiple documents are involved.
Testing
Upload sample files to your Supabase bucket.
Verify if files are processed and stored successfully in the vector store.
Ask simple conversational questions about your documents using the chatbot (e.g., "What does Chapter 1 say about the Roman Empire?").
Test for accuracy and contextual relevance of retrieved results.
Mark Shcherbakov
Chat with Postgresql Database
Who is this template for?
This workflow template is designed for any professionals seeking relevent data from database using natural language.
How it works
Each time user ask's question using the n8n chat interface, the workflow runs.
Then the message is processed by AI Agent using relevent tools - Execute SQL Query, Get DB Schema and Tables List and Get Table Definition, if required. Agent uses these tool to form and run sql query which are necessary to answer the questions.
Once AI Agent has the data, it uses it to form answer and returns it to the user.
Set up instructions
Complete the Set up credentials step when you first open the workflow. You'll need a Postgresql Credentials, and OpenAI api key.
Template was created in n8n v1.77.0
KumoHQ
+6
Notion AI Assistant Generator
This n8n workflow template lets teams easily generate a custom AI chat assistant based on the schema of any Notion database. Simply provide the Notion database URL, and the workflow downloads the schema and creates a tailored AI assistant designed to interact with that specific database structure.
Set Up
Watch this quick set up video 👇
Key Features
Instant Assistant Generation**: Enter a Notion database URL, and the workflow produces an AI assistant configured to the database schema.
Advanced Querying**: The assistant performs flexible queries, filtering records by multiple fields (e.g., tags, names). It can also search inside Notion pages to pull relevant content from specific blocks.
Schema Awareness**: Understands and interacts with various Notion column types like text, dates, and tags for accurate responses.
Reference Links**: Each query returns direct links to the exact Notion pages that inform the assistant’s response, promoting transparency and easy access.
Self-Validation**: The workflow has logic to check the generated assistant, and if any errors are detected, it reruns the agent to fix them.
Ideal for
Product Managers**: Easily access and query product data across Notion databases.
Support Teams**: Quickly search through knowledge bases for precise information to enhance support accuracy.
Operations Teams**: Streamline access to HR, finance, or logistics data for fast, efficient retrieval.
Data Teams**: Automate large dataset queries across multiple properties and records.
How It Works
This AI assistant leverages two HTTP request tools—one for querying the Notion database and another for retrieving data within individual pages. It’s powered by the Anthropic LLM (or can be swapped for GPT-4) and always provides reference links for added transparency.
Max Tkacz
+3
Notion knowledge base AI assistant
Who is this for
This workflow is perfect for teams and individuals who manage extensive data in Notion and need a quick, AI-powered way to interact with their databases. If you're looking to streamline your knowledge management, automate searches, and get faster insights from your Notion databases, this workflow is for you. It’s ideal for support teams, project managers, or anyone who needs to query specific data across multiple records or within individual pages of their Notion setup.
Check out the Notion template this Assistant is set up to use: https://www.notion.so/templates/knowledge-base-ai-assistant-with-n8n
How it works
The Notion Database Assistant uses an AI Agent built with Retrieval-Augmented Generation (RAG) to query this Knowledge Base style Notion database. The assistant can search across multiple properties like tags or question and retrieves content from inside individual Notion pages for additional context.
Key features include:
Querying the database with flexible filters.
Searching within individual Notion pages and extracting relevant blocks.
Providing a reference link to the exact Notion pages used to inform its responses, ensuring transparency and easy verification.
This assistant uses two HTTP request tools—one for querying the Notion database and another for pulling data from within specific pages. It streamlines knowledge retrieval, offering a conversational, AI-driven way to interact with large datasets.
Set up
Find basic set up instructions inside the workflow itself or watch a quickstart video 👇
Max Tkacz
+3
Backup n8n workflows to Google Drive
Temporary solution using the undocumented REST API for backups using Google drive.
Please note that there are issues with this workflow. It does not support versioning, so please know that it will create multiple copies of the workflows so if you run this daily it will make the folder grow quickly. Once I figure out how to version in Gdrive I'll update it here.
Angel Menendez
+8
Advanced Telegram Bot, Ticketing System, LiveChat, User Management, Broadcasting
A robust n8n workflow designed to enhance Telegram bot functionality for user management and broadcasting. It facilitates automatic support ticket creation, efficient user data storage in Redis, and a sophisticated system for message forwarding and broadcasting.
How It Works
Telegram Bot Setup: Initiate the workflow with a Telegram bot configured for handling different chat types (private, supergroup, channel).
User Data Management: Formats and updates user data, storing it in a Redis database for efficient retrieval and management.
Support Ticket Creation: Automatically generates chat tickets for user messages and saves the corresponding topic IDs in Redis.
Message Forwarding: Forwards new messages to the appropriate chat thread, or creates a new thread if none exists.
Support Forum Management: Handles messages within a support forum, differentiating between various chat types and user statuses.
Broadcasting System: Implements a broadcasting mechanism that sends channel posts to all previous bot users, with a system to filter out blocked users.
Blocked User Management: Identifies and manages blocked users, preventing them from receiving broadcasted messages.
Versatile Channel Handling: Ensures that messages from verified channels are properly managed and broadcasted to relevant users.
Set Up Steps
Estimated Time**: Around 30 minutes.
Requirements**: A Telegram bot, a Redis database, and Telegram group/channel IDs are necessary.
Configuration**: Input the Telegram bot token and relevant group/channel IDs. Configure message handling and user data processing according to your needs.
Detailed Instructions**: Sticky notes within the workflow provide extensive setup information and guidance.
Live Demo Workflow
Bot: Telegram Bot Link (Click here)
Support Group: Telegram Group Link (Click here)
Broadcasting Channel: Telegram Channel Link (Click here)
Keywords: n8n workflow, Telegram bot, chat ticket system, Redis database, message broadcasting, user data management, support forum automation
Nskha
