← All work

Case study

An intelligent conversational chatbot for the SRI Congress

One assistant, three kinds of question: precise operational data, summaries of past editions, and live content from the official website.

Partner
Sustainability Research & Innovation Congress
Status
Deployed
Region
Global
Stack
n8n · Supabase (pgvector) · OpenAI · FastAPI · Scrapling · Docker
The SRI Congress chatbot widget embedded on the congress website
The assistant embedded as a widget on the SRI Congress website.

01

Executive summary

Arcane Technology Incubator designed and built a conversational assistant for the Sustainability Research & Innovation (SRI) Congress, embedded directly as a widget on the event's WordPress website. Within a single conversation, the bot can answer questions about operational data, summarize past editions and sessions, and surface current content published on the official website.

The solution runs on n8n as the orchestration engine, combining a vector database for retrieval-augmented generation (RAG), an OpenAI-based intent classifier, and a custom AI-driven scraping microservice. Two architectural decisions proved decisive for getting the project into production: replacing Azure AI Search with Supabase (pgvector) for embedding storage, and replacing n8n's native scraping node with Scrapling, an open-source library, to reliably extract dynamic content that would otherwise be lost.

02

Context and the challenge

The SRI Congress needed website visitors to be able to get their questions answered without depending on a human team being available at all times. The challenge wasn't simply answering generic questions: the bot had to handle three very different kinds of needs within the same conversation.

On one hand, precise operational questions that live in a database, such as how many sessions were logged in a given month of a congress edition. On another, summaries of past sessions, such as opening sessions from previous editions. And finally, current information published on the official website, such as the date of the next edition or the content of a specific program page. A single language model answering directly wasn't enough: each type of question required a different source and a different retrieval method.

03

Overall solution architecture

The solution is orchestrated entirely in n8n, running in Docker containers alongside a Python scraping microservice (FastAPI) and a Cloudflare tunnel that exposes the system securely. The chatbot lives embedded inside the SRI Congress's WordPress site, so any visitor can start a conversation without leaving the page.

Every incoming message first goes through an intent-classification step before the system decides which path to follow, allowing very different types of questions to be resolved with the most appropriate method in each case.

Key decision 1

From Azure AI Search to Supabase (pgvector)

The first version of the retrieval system used Azure AI Search as the vector database. At the contracted tier, that service imposed a 60 MB limit on indexes. When converting the SRI Congress's historical content into embeddings, the data volume consistently exceeded that limit, which blocked full content uploads and forced information to be truncated.

Operating cost was the second factor behind the change. Azure AI Search carried a fixed cost from the very start of the project, at a stage when the product and the data volume were not yet stable. Supabase, by contrast, offered a generous free tier that covered the project's needs at that early stage, with the option to scale up to a paid plan later, once the product and the data had reached a more consistent volume. That flexibility — starting at no cost and growing only once the project justified it — weighed as much as the technical 60 MB limitation.

The team evaluated Supabase as an alternative: beyond offering a full Postgres database, it includes the pgvector extension to store and query embeddings directly within the same relational database, with no size ceiling like Azure's. The migration eliminated the capacity limitation entirely, reduced operating costs in the project's early phase, and, in the process, simplified the architecture by unifying both relational and vector data in a single database.

Key decision 2

Intent-classification engine

Before responding, every user question is evaluated by an OpenAI model whose sole job is to determine the intent behind the message. The system recognizes four categories:

  • Database queryQuestions that can be answered with a precise query over structured data, such as the number of sessions in a specific month and year.
  • Event informationQuestions about what happened in a past session, answered with a summary generated from stored content.
  • Website informationQuestions about current content published on the official page, such as the date of the next event, resolved through the scraping service.
  • Greeting or general conversationMessages such as greetings, which get a direct conversational reply without triggering any of the routes above.

This upfront classification keeps the bot from having to "guess" the right source, and lets each type of question be resolved with the most appropriate and most response-time-efficient method.

Key decision 3

AI-driven scraping instead of n8n's native node

To answer questions about the website, the team first evaluated n8n's native scraping node, but ruled it out for two concrete reasons.

First, the native node didn't navigate on its own across the site's different menu sections (home, program, etc.): it only pulled content from the URL explicitly given to it. If the answer lived on another page of the same site, the bot couldn't find it, and it kept returning the same link or a "no relevant information found" message.

Second, a large share of the site's relevant content was embedded inside <script> tags, and the native node's HTML-to-markdown sanitization step discarded exactly those tags, losing information that was actually relevant to the user.

The solution was to build a custom Python microservice, exposed as an API, that uses Scrapling — an open-source scraping library available on GitHub — instead of the native node. The service works in four steps: first it extracts all the links available on the page; then it asks an OpenAI model to pick which of those links is most likely to contain the answer to the user's question; next it automatically navigates to that page and extracts its full text, excluding scripts, styles, menus, and footers while keeping the actual content; and finally, the same OpenAI model analyzes that text and drafts the response. The result is cached for 24 hours to avoid repeating navigation unnecessarily.

This approach solved both the cross-page navigation problem and the loss of content embedded in scripts — two limitations the native node didn't cover.

04

Results and impact

With this architecture, the SRI Congress chatbot handles precise operational questions and open-ended questions about past sessions and web content within the same conversation, without the user needing to know which system each answer comes from. The migration to Supabase completely eliminated upload errors caused by the embedding size limit and kept operating costs under control during the project's early phase, while the custom Scrapling-based scraping service made it possible to correctly answer questions that previously returned empty responses or the wrong link.

05

Conclusions

This case illustrates a useful principle for any conversational AI project: not every question should be solved with the same mechanism. Classifying intent before responding, and choosing the right tool for each type of data source — relational database, precomputed summaries, or live web content — produces a system that's more accurate and easier to debug than trying to force a single model or a single pipeline to solve everything.

Equally important: when a standard tool from an automation platform doesn't cover real business cases — such as content embedded in <script> tags or multi-page navigation — it's worth investing in a purpose-built microservice rather than forcing the generic tool to fit.

Have a problem shaped like this one?

Tell us what you need built. We scope it in a call and tell you plainly whether we're the right team.