Data pipelines
LLM Supplier Enrichment
Turned raw supplier pages into structured profiles with an open-source LLM running on our own GPU, and more than doubled its throughput.
Data engineer, solo
Jun 2026
In numbers
- domains/s, 1 process
- 2 → 4.8
- domains/s, 1 process
- domains/s, 3 processes
- ~8
- domains/s, 3 processes
- of pilot pages on the fast path
- 98.9%
- of pilot pages on the fast path
- domains the pipeline was built for
- 537K
- domains the pipeline was built for
The problem
For each supplier we now had raw text from up to seven key pages. We needed structured records that answer the questions buyers actually ask: what does this company make, which certifications does it hold, where is it based? Sending half a million companies' text to a paid API would have been expensive, and the data would have left our own infrastructure.
What I did
- 1
Run our own model
I set up a Google Cloud VM with a single A100 and ran SGLang on it. SGLang is an inference server for open models: it caches shared prompt prefixes and can force the output to match a JSON schema. I used the FP8 build of Qwen3-8B, which halves memory, and switched off its long "thinking" step.
- 2
Stop the model from leaving fields blank
In the first pilot every schema field was optional, and the model took the easy way out by returning nulls. I made every field required and told it to write "Unknown" when the answer genuinely wasn't there. Because SGLang enforces the schema, empty fields simply stopped happening.
- 3
Replace batches with a queue
The first version sent work in batches and waited for each batch to finish: 2 domains a second. I rebuilt it around a queue. One producer keeps pulling work from the database while 96 async workers take jobs as they free up, so the GPU never sits idle. Throughput went to 4.8 domains a second with the GPU pinned at 100%.
- 4
Push the giants to the end
Sites with more than 35,000 characters of text were running the GPU out of memory. I skipped them on the first pass and ran them in a separate, slower pass afterwards.
- 5
Write in bulk, away from production
Results went out in batches of 250 to a separate staging table, never straight into production tables.
Result
Throughput went from 2 to 4.8 domains a second on one process, and close to 8 with three running in parallel. The pilot picked out procurement-critical certifications such as IATF 16949, ISO 14001 and TISAX correctly. I'd planned to rent extra GPUs to go faster, but none were available in three regions, so I got everything I could out of the one card we had.
How it works
PostgreSQL
Classified pages; a producer keeps pulling work
asyncio queue → 96 workers
Each worker takes the next job as soon as it's free
SGLang on one A100
Qwen3-8B FP8, output forced to a JSON schema. Pages over 35K characters wait for a separate, slower pass
Staging table
Batches of 250, production tables untouched
What I learned
Giving an LLM room to improvise lowers quality; a strict schema fixes it. And you can't always rent more hardware, so get the most out of what you have first.
Stack
- SGLang
- Qwen3-8B (FP8)
- GCP · NVIDIA A100
- Docker
- Python asyncio
- PostgreSQL