All work

Stienen · R&D

AI assistant for product documentation

An assistant that answers questions about our product manuals, used by colleagues and in customer demos. I took it from a Python prototype to a .NET service in the team's platform.

Developer (R&D, part-time)mostly solo, inside the platform teamMay 2026 – now.NET 10, PostgreSQL + pgvector, Gemini via Microsoft.Extensions.AIIn use: internally and in customer demos, still in development

architecture: from manual to answer
  1. Product manualslong PDFs with complex tables
  2. Conversion to Markdown5 approaches compared(my part)
  3. Chunks + embeddingsPostgreSQL + pgvector(my part)
  4. Retrieval + tool callingGemini via Microsoft.Extensions.AI(my part)
  5. Streamed answerwith feedback on each answer(my part)
Highlighted steps are the parts I built.

The problem

Stienen makes climate controllers for barns. The product documentation for them is a set of long PDF manuals, full of complex tables and images. Colleagues need quick, correct answers from those manuals, for themselves and when they show the product to customers. Searching a stack of PDFs doesn’t give you that.

How it works

The manuals are converted to Markdown and split into chunks. Each chunk gets an embedding and is stored in PostgreSQL with pgvector. When someone asks a question, the service retrieves the chunks that match, and the model answers from them. It can call tools along the way, and the answer is streamed back while it’s being written. Users can give feedback on every answer.

The service is written in .NET 10 with a clean architecture: separate layers for the API, the application logic, the infrastructure and the ingestion of documents. It talks to Gemini through Microsoft.Extensions.AI, so the model sits behind an abstraction instead of being wired into the code.

Decisions

Measure the conversion before choosing it

Everything depends on the first step: if a table comes out of the PDF wrong, every answer built on it is wrong too. So I tried five ways to turn the manuals into Markdown, and compared them on accuracy and on whether they were fast enough to use.

conversion: five approaches compared
Approach What happened Decision
Word to Markdown Tables came out poorly Dropped
Docling More structure, still not accurate enough Dropped
Self-hosted vision model Too simple for these pages Dropped
Qwen 3 VL 32B, self-hosted Fairly accurate, but too slow on a MacBook M4 Pro Dropped
Gemini 2 small errors in 13 test pages Chosen
The conversion has to run for the people who write the manuals, so a model that only works on a fast machine wasn't an option.

From a prototype to a service in the platform

I started with a Python prototype that used a local model through LM Studio. That made it cheap to try ideas. LM Studio is also the tool I had written a small .NET library for in 2024. Once the approach worked, I rebuilt it as a .NET service in its own repository, and then moved it into the team’s main repository, with the team’s house style and pipelines.

Fit in, instead of standing next to it

A tool that only runs on my machine doesn’t help anyone. The service uses the platform’s role-based access, logging and health checks, and it has architecture tests that keep the layers apart. It ships through the same pipelines as the rest of the platform.

Stream, and let people say what’s wrong

Answers are streamed, so people see the response build up instead of waiting for the whole thing. Every answer can get feedback, which shows where the documentation or the retrieval falls short.

The plan around it

I wrote a feasibility report with a plan in three phases: first a static knowledge base, then connecting live data, and finally an assistant that can take actions. It also compares models, looks at costs in three scenarios, and lists the risks: privacy, hallucinations and liability. The report isn’t finished yet.

What didn’t work

  • Four of the five conversion approaches didn’t make it. The tables were the hard part every time.
  • The most accurate local model was too slow on a fast laptop, so it would have been unusable for the people who write the manuals.

My part and the team’s

I built the assistant mostly on my own, inside the platform team: the prototype, the conversion, the retrieval, the service and the fit into the platform. The platform itself, its house style and its pipelines were the team’s, and the service follows them.

Status

In use by colleagues and in demos for (future) customers, and still in development.