How to Build an AI Chatbot That Queries Your Baserow Database with n8n

Your team keeps pinging you with the same questions: “What’s the status on the Carter account?” or “How many orders came in from Texas last week?” The answers already live in your database — the problem is that nobody wants to learn how to query it. What if they could just ask, in plain English, and get the answer back in seconds? That’s exactly what you’ll build in this guide: an AI chatbot powered by n8n, OpenAI GPT-4o Mini, and Baserow that lets anyone on your team talk to your data without writing a single query.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A user opens the n8n chat widget and types a question like “Show me all pending orders from California.”
2. An AI agent interprets the question, queries your Baserow database for matching records, and formats the results.
3. The chatbot replies with a clear, readable answer — no SQL, no filters, no training needed.
4. Follow-up questions work naturally because the chatbot remembers the conversation context.

How It Works — The Big Picture

The whole system is a single n8n workflow with four connected components. The Chat Trigger receives the user’s message, passes it to an AI Agent that decides what to look up, queries Baserow through a built-in tool, and streams the answer back — all while keeping a memory buffer so the conversation flows naturally.

┌──────────────────────────────────────────────────────────────────────┐
│  AI CHATBOT — QUERY BASEROW DATABASE                                │
│                                                                      │
│  [Chat Trigger] ──→ [Database Query Agent] ──→ Chat Response         │
│                           │       │                                  │
│                    ┌──────┘       └──────┐                           │
│                    ↓                     ↓                           │
│           [OpenAI GPT-4o Mini]   [Conversation Memory]               │
│                                         │                            │
│                                  [Query Baserow]                     │
│                                    (AI Tool)                         │
└──────────────────────────────────────────────────────────────────────┘
  

What You’ll Need

• A self-hosted or cloud n8n instance (version 1.0 or later)
• An OpenAI account with an API key — GPT-4o Mini costs roughly $0.15 per million input tokens, so this is very affordable
• A Baserow account (free tier works) with at least one database table containing the data you want to query
• About 15 minutes to set everything up from scratch

Estimated build time: 15–20 minutes from scratch, or under 5 minutes with the template.

Building the Chatbot — Step by Step

1 Chat Trigger (Chat Trigger Node)

This is the entry point. The Chat Trigger node creates a built-in chat widget inside n8n where users can type their questions. When someone sends a message, the node captures the text and passes it downstream.

1. In your n8n canvas, click Add node and search for Chat Trigger.
2. Drop it on the canvas. The default settings work — no configuration needed.
3. This node will automatically generate a chat URL you can share, or you can embed the widget on any page.

After this node fires, the data looks like this:

{
  "chatInput": "Show me all pending orders from California",
  "sessionId": "a7f3e2b1-9c4d-4e8a-b5f6-1234567890ab"
}

2 Database Query Agent (AI Agent Node)

The AI Agent is the brain of this workflow. It receives the user’s question, decides whether it needs to query the database, calls the Baserow tool if needed, and composes a human-readable response. Think of it as a smart middleman between your user and your data.

1. Add an AI Agent node and connect it to the Chat Trigger’s output.
2. Open the node settings and find the System Message field under Options.
3. Paste this system prompt (customize it to describe your specific data):

You are a helpful data assistant. Your job is to answer user questions by querying the connected Baserow database.

Rules:
1. Always use the Baserow tool to look up real data before answering.
2. If the user asks a question you cannot answer from the database, say so clearly.
3. Format numbers, dates, and lists in a readable way.
4. Keep answers concise — summarize large result sets instead of dumping raw rows.
5. If the query returns no results, suggest the user rephrase or check their filters.

3 OpenAI GPT-4o Mini (Chat Model Node)

This node provides the language model that powers the agent’s reasoning. GPT-4o Mini is the sweet spot here — it’s fast, cheap (fractions of a cent per query), and accurate enough for database lookups and conversational responses.

1. Add an OpenAI Chat Model node (@n8n/n8n-nodes-langchain.lmChatOpenAi).
2. Connect it to the AI Language Model input on the Agent node (the bottom-left connector).
3. Set the Model to gpt-4o-mini.
4. Under Options, set Temperature to 0.3 — you want factual, consistent answers, not creative ones.
5. Set Max Tokens to 2048 — enough for detailed responses without runaway costs.
6. Select your OpenAI credential (or create a new one by pasting your API key).

4 Conversation Memory (Buffer Window Memory Node)

Without memory, every message would be a brand-new conversation. The Buffer Window Memory node stores the last 12 exchanges so the agent understands context. When a user asks “What about New York?” right after asking about California orders, the agent knows they mean orders from New York.

1. Add a Window Buffer Memory node.
2. Connect it to the AI Memory input on the Agent node (the bottom-center connector).
3. Set Session ID Type to From Input — this uses the Chat Trigger’s session ID automatically.
4. Set Context Window Length to 12. This means the agent remembers the last 12 messages (6 pairs of user + assistant).

5 Query Baserow (Baserow Tool Node)

This is where the magic happens. The Baserow Tool node gives the AI Agent the ability to search, filter, and read rows from your Baserow table. The agent decides when to use it and what to search for — you just need to point it at the right table.

1. Add a Baserow node (specifically the Baserow Tool variant for AI agents).
2. Connect it to the AI Tool input on the Agent node (the bottom-right connector).
3. Select your Baserow credential (API token — you’ll find this in your Baserow account settings).
4. Set the Database ID — you can find this in your Baserow URL: https://baserow.io/database/YOUR_ID.
5. Set the Table ID — click into any table and check the URL for the table number.

When the agent calls this tool, it gets back rows like this:

[
  {
    "id": 142,
    "order_id": "ORD-2026-0891",
    "customer_name": "James Carter",
    "customer_email": "james.carter@gmail.com",
    "customer_state": "CA",
    "order_status": "Pending",
    "total_amount": 249.99,
    "created_at": "2026-04-07"
  },
  {
    "id": 143,
    "order_id": "ORD-2026-0892",
    "customer_name": "Emily Rodriguez",
    "customer_email": "emily.rodriguez@outlook.com",
    "customer_state": "CA",
    "order_status": "Pending",
    "total_amount": 89.50,
    "created_at": "2026-04-08"
  }
]

The agent then reads this data, formats it, and responds to the user with something like: “There are 2 pending orders from California — one for James Carter ($249.99) and one for Emily Rodriguez ($89.50), totaling $339.49.”

The Data Structure

Your Baserow table is the foundation of this whole system. The chatbot can only answer questions about data that exists in your table, so the schema matters. Here’s an example for an order tracking table:

Here’s what the data lifecycle looks like with a few sample rows:

Full System Flow

┌─────────────────────────────────────────────────────────────────────────┐
│                                                                         │
│  USER types question          n8n CHAT WIDGET                           │
│  "Show pending CA orders"  →  [Chat Trigger]                            │
│                                     │                                   │
│                                     ▼                                   │
│                            [Database Query Agent]                       │
│                             GPT-4o Mini brain                           │
│                                │         │                              │
│                      ┌─────────┘         └──────────┐                   │
│                      ▼                              ▼                   │
│             [Conversation Memory]          [Query Baserow]              │
│              12-message window              Reads table rows            │
│                                                    │                    │
│                                                    ▼                    │
│                                          ┌─────────────────┐           │
│                                          │  BASEROW TABLE   │           │
│                                          │  Orders, Leads,  │           │
│                                          │  Inventory, etc. │           │
│                                          └─────────────────┘           │
│                                                    │                    │
│                      ▼                             │                    │
│           Agent formats answer  ◄──────────────────┘                    │
│                      │                                                  │
│                      ▼                                                  │
│  USER receives      "There are 2 pending orders                         │
│  formatted answer    from California totaling $339.49"                  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘
  

Testing Your Workflow

1. Save your workflow and make sure all four nodes are connected (Chat Trigger → Agent, with the model, memory, and tool feeding into the Agent’s sub-connectors).
2. Click Chat in the bottom-right of the n8n canvas to open the built-in chat panel.
3. Type a simple question: How many rows are in the table? — This tests the basic connection.
4. Ask a filtered question: Show me all orders from California — This tests the agent’s ability to apply filters.
5. Ask a follow-up: Which of those are still pending? — This tests conversation memory.
6. Ask something the database can’t answer: What's the weather in Chicago? — The agent should politely decline.

Frequently Asked Questions

What’s Next?

• Add a Slack or Telegram interface — replace the Chat Trigger with a Slack or Telegram trigger so your team can query the database directly from their messaging app.
• Connect multiple data sources — add Airtable, Google Sheets, or a Postgres database alongside Baserow to build a unified data assistant.
• Add write capabilities — extend the agent with a Baserow “create row” tool so users can add or update records through the chat (e.g., “Mark order ORD-2026-0891 as shipped”).
• Schedule automated reports — add a Schedule Trigger that runs a predefined query every morning and sends the results to your team channel.