Supabase + OpenAI: database answers in plain English
Getting a “quick answer” from your database rarely stays quick. You ask a question, someone writes SQL, the result needs tweaking, then you repeat the whole loop because the question changed slightly.
This Supabase OpenAI automation hits hardest when decisions depend on data now, not after a backlog clears. Marketing leads trying to sanity-check campaign numbers feel it. Agency owners doing client reporting feel it too. Same frustration, different dashboards.
This workflow turns plain-English questions into safe, targeted database queries, then returns the answer right in the chat. You’ll learn what it does, what you need, and how to run it without living in SQL.
How This Automation Works
Here’s the complete workflow you’ll be setting up:
n8n Workflow Template: Supabase + OpenAI: database answers in plain English
flowchart LR
subgraph sg0["When chat message received Flow"]
direction LR
n0@{ icon: "mdi:play-circle", form: "rounded", label: "When chat message received", pos: "b", h: 48 }
n1@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model", pos: "b", h: 48 }
n2@{ icon: "mdi:database", form: "rounded", label: "DB Schema", pos: "b", h: 48 }
n3@{ icon: "mdi:database", form: "rounded", label: "Get table definition", pos: "b", h: 48 }
n4@{ icon: "mdi:robot", form: "rounded", label: "AI Agent", pos: "b", h: 48 }
n5@{ icon: "mdi:database", form: "rounded", label: "Run SQL Query", pos: "b", h: 48 }
n2 -.-> n4
n5 -.-> n4
n1 -.-> n4
n3 -.-> n4
n0 --> n4
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n0 trigger
class n4 ai
class n1 aiModel
class n2,n3,n5 database
Why This Matters: Getting Answers Shouldn’t Require SQL
Most teams don’t have a database problem. They have a “getting answers out of the database” problem. The data exists in Supabase (PostgreSQL), but every new question becomes a mini project: find the right table, figure out the joins, remember the JSON shape, and then translate the result back into human language. It’s slow, and it’s easy to lose trust when two people run slightly different queries and get slightly different answers. Honestly, the constant back-and-forth is what drains momentum.
The friction compounds. Here’s where it breaks down in real life:
- Simple questions like “how many new customers this week?” turn into a Slack thread and a delayed response.
- JSON fields inside tables add a second layer of complexity, so people avoid using the data they already store.
- Ad-hoc SQL gets copied around, tweaked, and reused incorrectly, which means decision meetings start with “are we sure this is right?”
- Analysts become a bottleneck for lookups, leaving higher-value work (real analysis) waiting.
What You’ll Build: A Chat Interface for Supabase Answers
You’ll set up an n8n workflow that lets someone ask a question in plain English and receive a database-backed answer in the same conversation. It starts when a message hits a chat-style webhook trigger, which passes the question into an AI agent powered by an OpenAI chat model. The agent doesn’t guess randomly; it has tools to inspect your database schema, fetch table structures, and then generate a SQL statement that fits your request. Once the SQL is generated, the workflow executes it against Supabase’s Postgres database and returns the results back to the requester. Over time, simple memory in the workflow helps the agent keep context, so follow-up questions work like a real conversation.
The workflow begins with a chat message and routes it into a conversational agent. The agent checks schema and table structure when it needs to, then creates and runs SQL through Postgres tools connected to Supabase. Finally, the workflow responds to the webhook with a clean, human-readable answer (not a wall of raw rows).
What You’re Building
| What Gets Automated | What You’ll Achieve |
|---|---|
|
|
Expected Results
Let’s say your team asks 10 “quick data questions” a day. Manually, even a fast analyst usually spends about 10 minutes per request between clarifying the question, writing SQL, and sending a readable summary, which is roughly 100 minutes daily. With this workflow, the question is submitted once via chat, the agent generates and runs the SQL, and you get the response back in about a minute or two. That’s around an hour back each day, and the answers arrive while the question still matters.
Before You Start
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- Supabase for your Postgres database and credentials
- OpenAI to generate and interpret SQL safely
- OpenAI API key (get it from the OpenAI dashboard)
Skill level: Intermediate. You don’t need to code, but you should be comfortable adding credentials and knowing which database you’re pointing at.
Want someone to build this for you? Talk to an automation expert (free 15-minute consultation).
Step by Step
A chat message triggers the workflow. The “Incoming Chat Trigger” node receives a user question like “Which plan had the most upgrades last month?” and packages it into a request the agent can use.
The AI model provides the reasoning engine. The OpenAI conversation model gives the agent the language understanding to interpret what the person means, not just what they typed.
Schema and table structure get pulled when needed. The agent can call tools that retrieve the database schema and fetch a specific table’s columns and types, which helps it generate SQL that actually matches your Supabase setup (including JSON fields).
SQL is generated and executed, then the result is returned. The workflow runs the final SQL statement via a Postgres tool, then responds back through the webhook with a clear answer you can paste into a doc or send to a client.
You can easily modify the agent’s allowed tables to limit access, or adjust the response formatting to return a short summary instead of full rows. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the Chat Trigger
Set up the chat entry point so user messages can start the workflow.
- Add the Incoming Chat Trigger node to your canvas.
- Leave Options empty (defaults are used).
- Copy the generated chat webhook URL from Incoming Chat Trigger for testing later.
Step 2: Connect OpenAI
Attach the language model that powers the conversational agent.
- Add the OpenAI Conversation Model node.
- Credential Required: Connect your openAiApi credentials.
- Connect OpenAI Conversation Model to Conversational DB Agent as the language model.
Step 3: Set Up Conversational DB Agent
Configure the agent to interpret chat input and decide which database tools to run.
- Add the Conversational DB Agent node and connect it to Incoming Chat Trigger.
- Set Text to
={{ $('Incoming Chat Trigger').item.json.chatInput }}. - Set Agent to
openAiFunctionsAgentand Prompt Type todefine. - In System Message, paste the provided instructions about running SQL queries and using database knowledge.
Step 4: Configure Database Tools
Attach PostgreSQL tools so the agent can inspect schema and execute SQL.
- Add the Retrieve DB Schema node and set Query to
SELECT table_schema, table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE' AND table_schema = 'public';. - Add the Fetch Table Structure node and set Query to
SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, tc.constraint_type, ccu.table_name AS referenced_table, ccu.column_name AS referenced_column FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON c.table_name = kcu.table_name AND c.column_name = kcu.column_name LEFT JOIN information_schema.table_constraints tc ON kcu.constraint_name = tc.constraint_name AND tc.constraint_type = 'FOREIGN KEY' LEFT JOIN information_schema.constraint_column_usage ccu ON tc.constraint_name = ccu.constraint_name WHERE c.table_name = '{{ $fromAI("table_name") }}' -- Your table name AND c.table_schema = 'public' -- Ensure it's in the right schema ORDER BY c.ordinal_position;. - Add the Execute SQL Statement node and set Query to
{{ $fromAI("query","SQL query for PostgreSQL DB in Supabase") }}. - Connect all three tools to Conversational DB Agent as AI Tool connections.
- Credential Required: Connect your postgres credentials. These tools are used by Conversational DB Agent, so ensure Postgres credentials are available to the agent’s tool configuration.
Step 5: Test and Activate Your Workflow
Validate the end-to-end conversation flow and then enable the workflow.
- Click Execute Workflow and send a test message to the Incoming Chat Trigger webhook URL.
- Confirm Conversational DB Agent receives the chat input and invokes Retrieve DB Schema, Fetch Table Structure, or Execute SQL Statement as needed.
- Verify the response is grounded in actual database results (tables list, column definitions, or query output).
- When satisfied, toggle the workflow to Active for production use.
Troubleshooting Tips
- Supabase credentials can expire or be pointed at the wrong project. If things break, check your database host, password, and allowed IP/network settings in the Supabase project settings first.
- If you rely on schema discovery and your database changed recently, cached assumptions can cause bad queries. Re-run the schema/tool nodes after migrations, or have the agent fetch schema more often.
- OpenAI prompts that are too generic will produce “technically correct” answers that don’t match your business language. Add your naming conventions (like what “customer” means) early, or you will be editing outputs forever.
Quick Answers
About 30 minutes if your Supabase and OpenAI credentials are ready.
No coding required. You will connect Supabase and OpenAI, then adjust the agent instructions for your schema.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in OpenAI API costs, which are usually a few cents per question for typical prompts.
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
Yes, and you should. Most teams customize the Conversational DB Agent instructions to restrict which tables can be queried, then adjust the Retrieve DB Schema and Fetch Table Structure tools to match naming conventions. You can also change the output style so it returns a short executive summary, a table of rows, or both. If you’re using JSON columns heavily, make the agent always request a sample record first so it understands the shape.
Usually it’s incorrect database credentials or the workflow is pointing at the wrong Supabase project. Double-check the host, database name, username, and password in the Postgres tool node, then confirm your Supabase network/access settings allow the connection. If it fails only under load, rate limits or too many concurrent queries can also be part of the story.
On most n8n setups, it can handle dozens of questions per hour comfortably, and more if your database and OpenAI limits allow it.
For this use case, n8n is usually the better fit because the workflow relies on an AI agent with tools, schema lookups, and branching logic that gets awkward (and expensive) in simpler automation builders. You can keep everything on a self-hosted instance if you need more control, and you’re not forced into per-step pricing the moment the flow grows. Zapier or Make can still work if you only want a basic “question in, response out” path with minimal logic. The moment you need schema exploration, JSON handling, or stricter guardrails, n8n pulls ahead. Talk to an automation expert if you’re not sure which fits.
Once this is running, “Can someone pull that number?” stops being a distraction. The workflow handles the repetitive querying so you can stay focused on what the data means.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.
