Database Connectors in AACFlow: Supabase, PostgreSQL, MySQL, MongoDB for AI Workflow Persistence

Every connector follows the same AACFlow block contract: authenticate once, drag into your workflow, wire outputs to the next block. No SDK installation. No credential juggling per environment.

Writing AI Results to PostgreSQL

The most common pattern is deceptively simple: an AI Agent block processes data, and the output goes straight into a database row. Here is what that looks like with the PostgreSQL connector.

Suppose your workflow receives a customer support ticket, runs it through an AI Agent that extracts sentiment, category, and priority, then stores everything for your analytics dashboard:

In AACFlow you wire this query's parameters — $1 through $5 — directly to the AI Agent block's output fields. The connector uses parameterized queries by default, so SQL injection is structurally impossible: user-supplied text never touches the query string itself.

The PostgreSQL connector also supports multi-statement transactions. If your workflow needs to update a parent record and insert a child record atomically, wrap them in a single block call with BEGIN / COMMIT. If the second statement fails, the connector rolls back automatically.

Supabase Realtime as a Workflow Trigger

Supabase does something most databases cannot: it exposes Postgres LISTEN/NOTIFY as a WebSocket subscription. AACFlow's Supabase connector can listen to a table's INSERT, UPDATE, or DELETE events and fire a workflow the moment a row changes — without polling.

A concrete example: your e-commerce backend inserts a new order into Supabase the moment a customer checks out. AACFlow subscribes to orders table inserts. The workflow fires instantly, runs the order through an AI categorization block, enriches the record with predicted lifetime value, then writes the result back to a orders_enriched table. The whole round-trip — new row to enriched row — takes under two seconds.

To set this up in AACFlow:

1. Add a Supabase trigger block and configure the realtime subscription to orders on INSERT.
2. Pass new.order_id and new.cart_json to an AI Agent block.
3. Wire the AI Agent's category and ltv_estimate outputs to a second Supabase block set to Insert on orders_enriched.

No server to maintain. No polling loop. The workflow sleeps until Supabase wakes it.

Building a Custom Analytics Pipeline

Let's walk through a slightly more complex case: a customer support analytics pipeline that combines MongoDB, PostgreSQL, and pgvector.

Your support system logs conversations in MongoDB. When a conversation closes, an AACFlow workflow fires:

1. MongoDB block: find the conversation document by session ID, pull the full message array.
2. AI Agent block: summarize the conversation, extract topics and resolution status.
3. PostgreSQL block: insert the summary and metadata into a conversation_summaries table.
4. PostgreSQL block (second): run a pgvector embedding insert so future AI searches can retrieve similar past cases.

The pgvector insert looks like this:

where $3 is the float array returned by your embedding model block — passed directly from the AI Agent output. AACFlow's type system handles the array serialization automatically.

This pipeline turns every closed ticket into a searchable, queryable knowledge artifact — no manual tagging, no human review required.

Redis as a Fast Cache Layer

For high-volume workflows, hitting PostgreSQL on every step adds latency. The Redis connector gives you a fast cache alongside your primary database.

A common pattern: your AI workflow checks Redis for a cached result before calling an expensive LLM. If the cache misses, the LLM block runs, and the result gets written to Redis with a TTL alongside the permanent PostgreSQL insert. Subsequent identical requests skip the LLM entirely.

AACFlow's Redis connector supports GET, SET with TTL, DEL, LPUSH / RPOP for queues, and HSET / HGET for hash maps. It is genuinely useful as a rate-limit counter, a deduplication store (have we processed this event ID before?), and a temporary buffer for streaming aggregations.

Conclusion

AACFlow's database connectors close the gap between AI reasoning and durable data. Supabase realtime lets database changes launch workflows instantly. PostgreSQL and MySQL give you full SQL power with injection-safe parameterization. MongoDB handles unstructured document data with its native aggregation pipeline. Redis adds a low-latency cache and queue layer. pgvector turns your PostgreSQL instance into a vector search engine your AI agents can query natively.

The result is that AI workflows in AACFlow can now do what production software has always done: read from a source of truth, write results back, and react to changes in real time — without a separate backend, without custom glue code, and without managing connection pools by hand.

If you are building a workflow that needs to remember something, the database connectors are where you start.