Description
Overview
This AI Agent to chat with files in Supabase Storage automates semantic search by processing stored documents through an advanced vectorization pipeline. This no-code integration workflow facilitates efficient retrieval and contextual querying of text and PDF files stored in Supabase private storage, triggered manually via a test workflow initiation node.
Key Benefits
- Automates file retrieval and filtering from Supabase storage with precise duplication checks.
- Supports multi-format document processing including PDF extraction and raw text handling.
- Enables chunked text splitting for improved semantic embedding and context retention.
- Integrates OpenAI embedding models to generate vector representations for semantic search.
- Stores and manages vectorized data in Supabase vector store for scalable document querying.
- Facilitates AI-driven chat interactions linked directly to processed document content.
Product Overview
This automation workflow begins with a manual trigger node to initiate file processing. It first queries the Supabase database table “files” to obtain a current list of processed documents, ensuring no duplication during ingestion. The workflow then sends a POST request to the Supabase Storage API to retrieve an alphabetically sorted list of up to 100 files from a private bucket, excluding placeholder entries.
Files are processed sequentially in batches of one. Each new file is downloaded securely using authenticated HTTP requests. A switch node determines file type: PDFs are routed through a dedicated extraction node to parse text content, while text files proceed directly. Extracted or raw text data is merged with metadata before a record is created in the Supabase “files” table.
Text content is segmented into overlapping chunks by a recursive character splitter to preserve context for semantic embeddings. Using OpenAI’s “text-embedding-3-small” model, the workflow generates vector embeddings tagged with file identifiers. These embeddings are inserted into a Supabase vector store table named “documents,” enabling semantic search capabilities.
The workflow concludes with an AI agent node that accepts chat messages, querying the vector store for relevant document segments to support context-aware responses. Error handling and retries rely on platform defaults, with no persistent data stored beyond Supabase tables and vector store entries.
Features and Outcomes
Core Automation
The automation workflow orchestrates a no-code integration pipeline that inputs file lists from Supabase storage, filters new entries, downloads content, and processes documents based on type. It applies conditional logic through an If node to exclude duplicates and placeholders, ensuring deterministic processing of each unique file.
- Single-pass evaluation of new files against existing database records.
- Type-based branching for PDF extraction versus raw text processing.
- Chunk-based text splitting with configurable size and overlap parameters.
Integrations and Intake
This orchestration pipeline integrates tightly with Supabase Storage and Database via authenticated HTTP requests and native Supabase nodes. It uses predefined credential types for secure access and handles up to 100 files per execution, sorted alphabetically without prefix filtering.
- Supabase Storage POST API to list private bucket contents.
- Supabase Database node to query and create file metadata records.
- OpenAI API with API key authentication for embedding generation.
Outputs and Consumption
Outputs include newly created file records in the Supabase database and inserted vector embeddings into the Supabase vector store. The AI agent node consumes these embeddings asynchronously to provide context-aware chat responses based on vector similarity search.
- Supabase “files” table entries with file name and storage ID.
- Vector store entries in the “documents” table with embedded metadata.
- AI chatbot response generated from vector similarity queries.
Workflow — End-to-End Execution
Step 1: Trigger
The workflow starts with a manual trigger node named “When clicking ‘Test workflow’,” requiring explicit user initiation. This controlled start ensures processing occurs on demand rather than event-driven or scheduled basis.
Step 2: Processing
After trigger, the workflow retrieves all file records from the Supabase “files” table, then requests the current file list from Supabase Storage via a POST HTTP call. Files are iterated one-by-one using a splitInBatches node. The If node applies strict presence checks to exclude duplicates and placeholder files before download.
Step 3: Analysis
File content processing depends on file type detected by the Switch node. PDFs undergo extraction using a dedicated extractFromFile node. Text files are passed directly. Subsequently, text is split into chunks with overlap to support contextual embedding. OpenAI embedding nodes generate vector representations, annotated with file IDs for traceability.
Step 4: Delivery
Processed files are registered in the Supabase database, and vector embeddings are inserted into the Supabase vector store “documents” table. The workflow supports asynchronous consumption by an AI chatbot node that queries the vector store for nearest matching content based on user input.
Use Cases
Scenario 1
Organizations managing large document repositories need efficient retrieval. This workflow automates detection of new files in Supabase storage, extracts or processes content, and vectorizes it for semantic search. The result is immediate availability of searchable knowledge without manual indexing or metadata entry.
Scenario 2
Teams requiring AI-powered chat access to internal documents face challenges integrating multiple systems. By combining Supabase storage with OpenAI embeddings and a chatbot agent, this orchestration pipeline delivers context-aware responses referencing specific document segments, improving information discovery accuracy.
Scenario 3
Developers building no-code integrations seek reusable workflows for document ingestion and semantic search. This pipeline provides a modular approach to fetching, processing, chunking, embedding, and storing documents with clear separation of steps and credential management, enabling scalable knowledge base creation.
How to use
To deploy this product, import the workflow into your n8n instance and configure Supabase credentials for storage and database access. Replace storage bucket names and database table IDs accordingly. Ensure OpenAI API credentials are set for embedding generation. Trigger the workflow manually to process up to 100 files per run. Monitor logs for errors and verify new file records and vector embeddings are created. Use the integrated AI chatbot node to query uploaded documents interactively.
Comparison — Manual Process vs. Automation Workflow
| Attribute | Manual/Alternative | This Workflow |
|---|---|---|
| Steps required | Multiple manual steps: download, extract, embed, store | Automated sequential processing with conditional logic |
| Consistency | Prone to human error and omissions | Deterministic file filtering and processing rules |
| Scalability | Limited by manual throughput and coordination | Batch processing with scalable vector storage |
| Maintenance | High effort to update tools and reprocess files | Centralized configuration and credential management |
Technical Specifications
| Environment | n8n automation platform with Supabase and OpenAI integration |
|---|---|
| Tools / APIs | Supabase Storage & Database APIs, OpenAI Embeddings API |
| Execution Model | Manual trigger with batch file processing |
| Input Formats | PDF and plain text files from Supabase private storage |
| Output Formats | Supabase database records, vector embeddings in vector store |
| Data Handling | Transient processing with metadata annotation, no external persistence |
| Known Constraints | Limited to 100 files per execution, manual trigger required |
| Credentials | Supabase API key, OpenAI API key with embedding model access |
Implementation Requirements
- Valid Supabase account with access to private storage bucket and database tables.
- OpenAI API credentials authorized for embedding generation.
- Configured n8n environment with network access to Supabase and OpenAI endpoints.
Configuration & Validation
- Import the workflow and set Supabase credentials for storage and database nodes.
- Replace storage bucket name and database table identifiers to match your environment.
- Test the workflow manually to confirm file retrieval, processing, and vector insertion.
Data Provenance
- Trigger node: manual trigger “When clicking ‘Test workflow’” initiates the process.
- File retrieval: “Get All files” HTTP Request node calls Supabase Storage API with POST method.
- Embedding generation: “Embeddings OpenAI” node uses OpenAI’s text-embedding-3-small model.
FAQ
How is the AI Agent to chat with files automation workflow triggered?
It is triggered manually via the “When clicking ‘Test workflow’” node, requiring explicit user initiation within n8n.
Which tools or models does the orchestration pipeline use?
The workflow integrates Supabase Storage and Database APIs with OpenAI’s embedding model “text-embedding-3-small” for vectorization.
What does the response look like for client consumption?
Responses are context-aware chat outputs generated by an AI agent node querying vector embeddings stored in Supabase.
Is any data persisted by the workflow?
Document metadata and vector embeddings are stored in Supabase tables; transient processing data is not persisted externally.
How are errors handled in this integration flow?
Error handling relies on n8n platform defaults; no explicit retry or backoff logic is configured in the workflow.
Conclusion
This AI Agent to chat with files in Supabase Storage workflow automates the ingestion, processing, and vectorization of documents stored in Supabase private storage, enabling semantic search and interactive AI querying. It delivers deterministic processing by filtering duplicates and handling multiple file types with clear metadata management. A key constraint is its manual trigger design and file processing limit of 100 per run, which requires operator initiation. Overall, it provides a structured, maintainable integration pipeline that leverages OpenAI embeddings and Supabase vector store for scalable knowledge management within the n8n environment.
Reviews
There are no reviews yet.