The starting point
ID Interactive automates the writing of its monthly SEO reports by combining a Python script that pre-calculates KPIs, a Qwen3-32B language model running locally via Ollama, and the OpenWebUI interface, all without any external API. Production time per report has fallen from 30 minutes to around 3 minutes, a 90% time saving.
ID Interactive, digital agency based in Vannes, produces Google ranking reports every month for its many clients. These reports, based on Semrush exports, are an essential deliverable: they show how rankings on strategic keywords are changing, explain gains, flag drops and guide the following month's actions.
For a long time, each report was written manually. For one client, this represented around 30 minutes of analysis and writing per month. Across the entire client portfolio over 12 months, the cumulative workload amounted to several hundred hours a year spent on a repetitive task with little intellectual added value.
With the arrival of local language models able to run on our own infrastructure, the question became obvious: can we automate this writing without compromising quality or letting our clients' data leave our systems? This account describes the three weeks of iterations that led us to a stable, validated workflow, now in production across all our accounts.
The agency's AI infrastructure
Why local rather than cloud
A Local AI infrastructure is preferable to the cloud for agencies handling sensitive client data for two decisive reasons: confidentiality (data never leaves the agency's servers) and an almost zero marginal cost per request once the infrastructure has paid for itself, compared with hundreds of euros a month in tokens for a comparable production volume.
The hardware core: the DGX Spark
We invested in an NVIDIA DGX Spark.
The NVIDIA DGX Spark is a compact AI workstation launched in 2025, designed for inference of large language models in a local environment. It incorporates NVIDIA's Grace Blackwell GB10 SoC and offers 128 GB of unified memory shared between CPU and GPU, which sets it apart from conventional GPU configurations where VRAM is limited to 24 or 32 GB.
For our uses (writing, document analysis, long-form content generation), it is the configuration offering the best capacity-to-footprint ratio on the market in 2026.

The software layer: Ollama + OpenWebUI
Ollama is an open-source inference engine, available under the MIT licence, that runs large language models (LLMs) locally on Mac, Linux and Windows. It handles downloading, quantisation and exposing an OpenAI-compatible API on localhost:11434.' A single command is enough to install a new model: ollama pull qwen3:32b.
OpenWebUI is the web interface built on top of Ollama. It offers an experience comparable to ChatGPT: conversations organised by folder, system prompts per model, document uploads and, above all for us, a system of Python functions that can be called from the chat, which proved decisive for our final workflow.
Choosing the model
We tested several candidates: Mistral Small 3.1 (24B), GPT OSS 20B, Qwen3-30B-A3B (MoE) and dense Qwen3-32B. The first three showed their limits on this specific task. The model that eventually won out is dense Qwen3-32B, for a structural reason: all 32 billion of its parameters are activated for every token, unlike MoE (Mixture of Experts) models, which activate only a fraction of them. This difference is crucial for conditional counting tasks, which are everywhere in an SEO report ("how many high-volume keywords are in the Top 3?").
Qwen3:30B-A3B is an open-source artificial intelligence model developed by Alibaba Cloud. It belongs to the third generation of Qwen models and uses a Mixture of Experts (MoE) architecture. The model has around 30 billion parameters, but only 3 billion are activated for each request, which greatly improves efficiency and reduces hardware requirements. Qwen3:30B-A3B is particularly well suited to reasoning, code generation, AI assistants and multilingual tasks. It can run locally with tools such as Ollama, vLLM, LM Studio or Hugging Face on modern GPU configurations.
The term MoE stands for Mixture of Experts. It is an architecture used in some artificial intelligence models to improve performance while reducing computing costs. Instead of activating the entire neural network for each request, the system selects only a few specialised sub-models called "experts". Each expert is optimised for certain types of tasks, such as reasoning, code or natural language. A routing mechanism chooses which experts to use depending on the input received. This approach produces models that are very powerful, fast and memory-efficient compared with conventional dense architectures.
The workflow objectives
Before diving into the iterations, let us set out clearly what we were trying to achieve.
- Reduce writing time per report from 30 minutes to less than 5 minutes.
- Maintain professional client deliverable quality: fluent prose, clear structure, a tone suited to the month.
- Guarantee 100% reliability on figures (SEO KPIs, rankings, changes), with no hallucinations tolerated.
- Build a workflow that scales to the agency's 100 clients without changing the code for each new client.
- Remain 100% local: no client data leaves the agency's infrastructure.
- Document the process so that a non-developer colleague can use it independently.
This last requirement weighed most heavily on our architecture choices. A brilliant workflow that only its designer can use has no value in an agency. SEO consultants needed to be able to produce a reliable report in two clicks without understanding either Python or Ollama's settings.
The journey: seven phases of iterations
The final workflow hides three weeks of back and forth, false leads and corrections. Here is the full journey, phase by phase.
Phase 1 - Failure with Mistral Small and GPT OSS 20B
LLM hallucinations on tabular data rarely come from the prompt: in this experiment, 80% of errors had identified infrastructure causes: OpenWebUI's default RAG chunking, Ollama's context window limited to 2,048 tokens by default, and the model's unsuitability for conditional counting. Optimising the infrastructure had a far greater impact than rewriting the prompt ten times.
Our first instinct was logical: load the month's Semrush report (in markdown format, 32 keyword blocks) into OpenWebUI, write a system prompt explaining what we wanted, and let the model write.
The results were disastrous. On a reference report with 17 keywords in the Top 3, the model reported 12 or 23. Search volumes were invented. Ranking changes were systematically reversed. Some keywords never appeared, others were mentioned three times.
The diagnosis took time. At first we thought it was a prompt problem: too many open instructions, not enough constraints. We rewrote the system prompt several times, added explicit anti-hallucination rules and defined numerical thresholds for qualifications. No significant effect.
The real problem lay elsewhere, on three levels:
First level: OpenWebUI's RAG chunking. By default, OpenWebUI splits uploaded documents into chunks of a few hundred tokens to embed them. This logic, designed for narrative documents, destroys the structure of an SEO report: a chunk may contain the name of a keyword without its ranking, or rankings without the associated volume. The model only sees decontextualised fragments.
Second level: Ollama's default num_ctx. By default, Ollama limits the context window to 2048 tokens. A 32-keyword report in verbose markdown format weighs around 4000 tokens. Half of the file was simply truncated on input to the model, which saw the first 15 keywords and had to guess the rest, hence the massive hallucinations.
Third level: the intrinsic limits of 20-24B models. Mistral Small 3.1 (24B) and GPT OSS 20B have a known tendency to loop on the first items of a long list and to make things up to "fill the gaps". On an extraction and conditional counting exercise, they are unreliable whatever the prompt.
Phase 2 - First structural fix: pre-calculating the table
In light of these findings, we radically changed our approach. Rather than asking the model to extract data from the Semrush report, we wrote a Python script that does this extraction upstream and produces a summary table. The model now only receives a 32-row table ready for commentary.
This approach eliminated extraction hallucinations. But it revealed a new problem: Mistral Small loops on markdown table format as soon as there are more than a dozen rows. It conscientiously writes the first row, then the second, then starts the first again in a loop. However much the prompt insisted "there are 32 keywords, you must cover them all", the model lost track.
It was time to change models.
Phase 3 - Switching to Qwen3 and discovering thinking mode
Separating extraction from writing is the architectural principle that eliminates 100% of statistical hallucinations. A Python script calculates the KPIs and produces a locked JSON; the LLM only writes from pre-validated sentences. The JSON acts as a contract: the model mathematically cannot invent a figure it has not calculated.
We switched to Qwen3-30B-A3B, a Mixture of Experts model that seemed ideal: 30 billion parameters in total but only 3 billion activated per token, making it a fast, lightweight model. The icing on the cake: Qwen3 introduces an explicit switch between two modes: /think, which activates an internal reasoning phase before the answer, and /no_think, which disables this phase for a direct answer.
This dual mode proved valuable. We designed a two-step workflow:
- Step 1, /think mode: the model receives the report and extracts all the KPIs into a structured JSON. Reasoning mode allows it to check its counts internally before producing the JSON.
- Step 2, /no_think mode: the model receives the validated JSON and writes the report in fluent prose. No reasoning needed, just structured writing.
The JSON plays a central role: it is a contract that the model cannot break in step 2. The figures are locked. Statistical hallucinations disappear.
Phase 4 - The MoE trap in conditional counting
With Qwen3-30B-A3B, gross hallucinations disappeared, but a subtler problem emerged: the model regularly got conditional counts wrong. It reported "17 keywords in the Top 3, 0 of them high-volume" when 5 were high-volume, or "4 drop-outs" when there were 3.
After several analyses, the diagnosis became clear.
MoE (Mixture of Experts) models such as Qwen3-30B-A3B activate a different subset of parameters for each token generated. For a conditional counting task, such as "how many keywords are in the Top 3 with a high search volume?", this variable activation can lead to inconsistencies along the list and make the model "forget" the running count.
Conversely, a dense model such as Qwen3-32B activates all its parameters for every token. This architecture proved structurally more reliable for our SEO workflow, where counts had to be flawlessly consistent across long, highly conditional lists.
So we switched to dense Qwen3-32B. The results were immediate: KPIs became 100% reliable in the extraction and counting phases.
Phase 5 - The infrastructure fix that unlocked everything
Two little-documented OpenWebUI settings are essential for a workflow on structured documents: Bypass Embedding and Retrieval (disables RAG chunking and sends the raw document to the model) and Full Context Mode (guarantees that the whole document is injected into the context). Combined with Ollama's num_ctx parameter raised to 32,768 tokens, they eliminate truncation and partial extraction problems.
Phase 6 - The Python script + Qwen writer architecture
Even with dense Qwen3-32B and full context, we still observed some variation between reports. Two times out of ten, the model got a minor KPI wrong or left out a section. For a production workflow, two errors out of ten is unacceptable.
The final structural change was to move all KPI calculation out of the model. A Python script analyses the Semrush report and produces a JSON containing not only the raw figures but also pre-written sentences for each KPI. Example of the output:
"phrase_top3": "17 keywords in the Top 3, 5 of them high-volume"
"phrase_couverture": "6 of our 9 high-volume keywords are on the first page of Google, i.e. 67%"
The model now only writes from sentences that have already been validated. The JSON also contains a ready-to-use grouping by volume level (high / moderate / low), which directly structures the sections of the report.
We integrated this Python script as an OpenWebUI tool via the function calling mechanism. The user sends their Semrush report and the model automatically calls the extraction function before writing. Everything happens in a single smooth conversation for the consultant.
Phase 7 - Rolling it out to all clients
Once the workflow was stable, we extended it to other clients. First problem: data volumes and structures were very different. One client has 32 keywords, 9 of them high-volume, with few alerts per month, whereas for another, 57 keywords are tracked, 36 of them high-volume, and difficult months have more than 30 critical alerts.
We had initially designed the script with a concept of "thematic families" specific to each client (geographical areas for Arteco, destinations for Saona). This sector-specific customisation would have required configuring each new client. Faced with the prospect of maintaining 100 configurations, we made a strategic decision: drop the thematic families and structure the report solely by search volume, which is universal and applies to any sector.
This decision cut 200 lines from the script. Above all, it made the workflow truly scalable: each new client is now configured in 2 minutes by changing three fields (name, one-line sector description, URL) in a universal folder prompt.
The final architecture
In production at ID Interactive, the SEO report automation workflow relies on four fixed components common to all clients (a Python script calculating 14 KPIs and 11 pre-written sentences, a Qwen3-32B model configured with a temperature of 0.15 and a context window of 20,480 tokens, a system prompt, and two conversation prompts) and on just three variables per client: name, one-line sector description, URL.

What is fixed (identical for all clients)
- A Python extraction script that calculates 14 KPIs, produces 11 pre-written sentences and groups alerts by volume level.
- A custom Ollama model based on Qwen3-32B with a temperature of 0.15, num_ctx 20480 and a repeat_penalty of 1.12.
- A system prompt that sets the model's general stance.
- Two conversation prompts (/extraction-seo and /rapport-seo) that trigger the two steps of the workflow.
What varies by client (2 minutes of configuration)
- A custom folder prompt with three variables: client name, one-line business sector, website URL.
- An OpenWebUI folder grouping that client's monthly conversations.
The monthly workflow for consultants
- Download the month's Semrush report in markdown format.
- Open the client's folder in OpenWebUI and start a new conversation.
- Load the folder prompt by typing /nom-client-seo.
- Upload the .md file and type /extraction-seo. The Python script is called automatically and the JSON appears with the validated KPIs.
- Check in 10 seconds that the KPIs match expectations.
- Type /rapport-seo to generate the client commentary in prose.
- Proofread in 30 seconds and send to the client.
Total time: around 3 minutes, compared with 30 minutes before. Measured productivity gain: 90%.
Results and validation
Before going into production, we validated the workflow on five consecutive reports covering two clients with very different profiles and four months of history.

Across all the tests, every KPI was correct. The reports can be published after less than a minute of proofreading, compared with 30 minutes of writing before. The only remaining imperfections are cosmetic: a keyword occasionally mentioned twice across two sections, a slightly imprecise "mainly high volume", a missing reassurance sentence. Nothing that cannot be fixed in a few seconds of proofreading.
Ten lessons learned
1. Model hallucinations on tabular data are not inevitable
The first instinct when a model hallucinates is to blame its size. In our case, 80% of hallucinations came from three infrastructure causes (RAG chunking, num_ctx, unsuitable model) and 20% from the prompt. Adjusting the infrastructure had a far greater impact than rewriting the prompt ten times.
2. Separating extraction and writing eliminates 100% of statistical hallucinations
When the Python script calculates the figures and the LLM only writes from pre-validated sentences, there is mathematically no longer any way to invent a KPI. The JSON is a contract the model cannot break.
3. Dense models are better than MoE models for conditional counting
For any task that involves keeping a count across a long list ("how many X are also Y?"), a dense model is structurally more reliable. MoE models shine on speed and versatility, not on arithmetic consistency.
4. The input data format matters more than the prompt
A markdown report with 32 blocks of 7 lines each makes small models loop. A compact 32-row table leaves them unfazed. Before rewriting a prompt, ask yourself whether the input format suits the size of the model.
5. OpenWebUI has two little-documented critical settings
Bypass Embedding and Retrieval and Full Context Mode radically change the system's behaviour on structured documents. Enable them for any workflow that is not classic document search.
6. Never leave num_ctx at its default value
Ollama sets num_ctx to 2048 by default. For any structured document longer than a few paragraphs, you need to go up to 16k, 20k or 32k. Forgetting this setting means sending truncated documents to the model.
7. Universal beats sector-specific for long-term maintenance
We were tempted to customise the logic per client (geographical families, thematic clusters). This sophistication would have cost hours of maintenance a month for 100 clients. A universal grouping by search volume cut 200 lines from the code and made the workflow truly scalable.
8. Human proofreading remains essential
Even with a workflow where 100% of KPIs are correct, 1 or 2 small imperfections remain per report. A 30-second proofreading checklist guarantees a flawless client deliverable. The goal is not to remove the human, but to save them 95% of their time.
9. OpenWebUI function calling is a game changer
Turning a Python script into a tool the model can call radically smooths the user experience. The consultant no longer runs commands; they have a conversation. The AI orchestrates the technical calls in the background.
10. Iterate, but know when to stop
We made 25 major iterations on this project. After a while, each new version of the prompt risked breaking what worked in order to gain 1% on a cosmetic detail. Knowing when to say "that's it, we're going into production" is a skill in itself.
The return on investment
Let us put a concrete figure on the gain.
Thanks to this local AI workflow, the time needed to write an SEO report has fallen from around 30 minutes to 3 minutes per client, a productivity gain of almost 90%.
Across a portfolio of 100 clients, this represents:
- monthly time cut from 50 hours to around 5 hours;
- almost 540 hours freed up per year;
- 100% reliable KPIs thanks to automated calculation in Python;
- complete confidentiality of client data thanks to a 100% local infrastructure.
These hundreds of hours saved are now reinvested in higher value-added work: competitor analysis, SEO optimisation, strategic support and content production.
The workflow does not replace SEO consultants; it automates the repetitive part so that they can spend more time on expertise and advice.

Next steps
This workflow is only the beginning. The DGX Spark + Ollama + OpenWebUI infrastructure is now in place, and the lessons learned from the SEO project can be transferred directly to other uses.
We are currently working on extending the same principle (script / LLM separation, JSON as a contract, universal prompts) to other recurring agency deliverables: Google Analytics reports, summaries of SEA campaigns, social media performance analyses. The expected gain in these areas is of the same order as for SEO.
More broadly, this experience has convinced us that the "cloud AI versus local AI" debate has no single answer. For agencies that handle sensitive client data and have recurring, well-defined use cases, a well-configured local AI infrastructure offers a cost / control / quality ratio that the cloud cannot match. For occasional uses or tasks requiring the capabilities of frontier models, the cloud remains relevant. The two approaches complement each other; they are not in opposition.
To conclude
The best code is the code you do not write. The best prompt is the one you no longer need to iterate on. The best workflow is the one any colleague can use without having built it.
This SEO project taught me more about AI workflow engineering than three years of technology watch. Above all, it reminded me of something easily forgotten amid the excitement of frontier models: AI in business is only worth the use you can make of it in a reliable, reproducible and documented way. The rest is just a demo.
At ID Interactive, we are now equipped to integrate local AI into all our production processes that lend themselves to it. If you run an agency, are a digital consultant or an SEO manager and this account resonates with you, feel free to contact us; feedback on this kind of project is always a rich source of shared lessons.
Eric Doyen
Director of ID Interactive
Frequently asked questions
Dense Qwen3-32B needs at least 64 GB of unified memory to run comfortably. ID Interactive uses an NVIDIA DGX Spark with 128 GB of unified memory (Grace Blackwell architecture), which can load models of up to 70 billion parameters. Consumer GPUs limited to 24 or 32 GB of VRAM cannot load this model without aggressive quantisation, which degrades performance on conditional counting.
Yes. The Python extraction script is designed to analyse a markdown file structured in keyword blocks. Any Google ranking export tool (Ahrefs, SE Ranking, Sistrix…) can feed the workflow, provided the export is converted to the same markdown format. The Ollama model and OpenWebUI remain the same.
Since the universal version of the workflow (structured by search volume rather than thematic families), setting up a new client takes around 2 minutes: you simply change three fields in an OpenWebUI folder prompt: client name, one-line business sector, website URL.
Yes. The entire workflow runs on the agency's local infrastructure. No data (keywords, rankings, URLs, search volumes) passes through a third-party cloud service. Ollama exposes an API only on localhost:11434, and OpenWebUI has no outgoing connection to external models in this configuration.
Related case studies: the SEO overhaul on a proprietary CMS and rebuilding Google Ads conversion tracking.
