SQL That Reads Between the Lines

What If GROUP BY Could Think?

DuckDB is great at aggregating numbers. SUM, AVG, COUNT — these work on structured data. But what about thousands of free-text reviews?

We built aggregate functions that call Claude during the GROUP BY. Text goes in, structured intelligence comes out:

SELECT month,
       qf_llm_summarize(
           review_text,
           'Analyze for the owner. Return JSON with
            momentum, strengths, issues, actions.'
       )
FROM reviews
GROUP BY month;

That's it. 133 months of reviews → 133 structured analyses with scores, severity-rated issues, and action items. Each month's reviews get accumulated, then Claude reads them all and produces a JSON assessment.

The Hard Part: 700 Labels, One Taxonomy

When you ask an LLM to categorize 133 months of reviews independently, you get ~700 unique labels. "weekend-brunch-slow-pacing", "brunch-service-delays", "sunday-brunch-understaffed" — all the same issue.

Our second aggregate function, qf_llm_distill, fixes this in one call:

SELECT qf_llm_distill(label, [30, 6])
FROM all_labels;

700 labels → 30 categories → 6 themes. Every label mapped. The function chunks, normalizes, consolidates, and validates internally — re-submitting any labels the LLM missed, merging groups that overshoot the target.

The Pattern

It's the same mechanism at every level. Reviews become summaries. Labels become categories. Categories become themes. GROUP BY handles the structure, the LLM handles the meaning.

SQL already knows how to group data. Now the LLM knows how to make sense of each group.

Under the Hood

class SummarizeFunction(AggregateFunction[SummarizeState]):

    class Meta:
        name = "qf_llm_summarize"

    def update(cls, states, group_ids, text, prompt):
        # Accumulate text. No LLM calls.
        for i in range(len(group_ids)):
            s = states[group_ids[i].as_py()]
            states[gid] = SummarizeState(
                texts=s.texts + "\n---\n" + text[i].as_py(),
                prompt=prompt[i].as_py(),
            )

    def combine(cls, source, target, params):
        # Merge parallel workers
        return SummarizeState(
            texts=target.texts + "\n---\n" + source.texts)

    def finalize(cls, group_ids, states, params):
        # Call Claude — once per group
        results = []
        for gid in group_ids:
            s = states[gid.as_py()]
            resp = anthropic.Anthropic().messages.create(
                model="claude-sonnet-4-20250514",
                messages=[{"content": s.prompt + s.texts}])
            results.append(resp.content[0].text)
        return pa.record_batch({"result": pa.array(results)})