What this is about
There are reports of a trade secrets dispute between OpenAI and Apple in which both sides make accusations against each other. The details are not important for this article and are not assessed here. What is interesting is the general lesson: whoever sends content to a third-party AI service gives it out of hand, and protection against misuse then depends on contracts and on the provider's diligence, no longer on you.
For a monitoring pipeline this is concrete. Classification sends texts from feeds to a language model. With public sources that is harmless, with others it is not.
Which content is delicate
- Internal mailing lists and forums that are not publicly readable.
- Confidential repositories and ticket systems, even as a mere notification.
- Research material for clients or employers.
- Anything covered by a non-disclosure agreement.
Even short excerpts can contain sensitive details. News sites and public release lists, by contrast, are uncritical.
The rule: what is confidential stays local
The simplest reliable rule is: sensitive content does not leave the machine. It is classified exclusively with a locally operated model, for example through Ollama. Public content may still go to a cloud API where quality is better.
This principle should be built into the architecture and not only into an agreement. A marker per feed makes it enforceable.
Hybrid routing with a flag per feed
Every feed gets a column in SQLite that determines whether it is sensitive. Classification reads it and chooses the backend.
import sqlite3
from dataclasses import dataclass
@dataclass(frozen=True)
class FeedPolicy:
feed_id: int
name: str
sensitive: bool
def load_policies(db: sqlite3.Connection) -> dict[int, FeedPolicy]:
rows = db.execute(
"SELECT id, name, sensitive FROM feeds WHERE active = 1").fetchall()
return {r[0]: FeedPolicy(r[0], r[1], bool(r[2])) for r in rows}
def classify(text: str, policy: FeedPolicy, local, cloud) -> str | None:
if policy.sensitive:
return local(text) # niemals in die Cloud
return cloud(text) or local(text)
The functions local and cloud stand for your own calls. What matters is the path for sensitive feeds: it has no way out into the cloud, not even as a fallback during an outage. If the local model fails, the entry is deferred.
Pre-set the column safely
New feeds should count as sensitive by default. That way a forgotten entry does not end up in the cloud by accident.
ALTER TABLE feeds ADD COLUMN sensitive INTEGER NOT NULL DEFAULT 1;
Only when you deliberately classify a feed as public do you set the value to 0.
Traceability
Store with every classification which backend produced it. Then you can later prove that sensitive feeds were never in the cloud, and you see how the ratio develops. In the daily heartbeat the distribution can be shown in a single line.
Also check whether logs contain sensitive texts. A log that prints the whole entry bypasses the protection by another route.
When it is worth it (and when not)
The separation is worth it as soon as a source contains content that is not meant for third parties. Then it is not an exaggeration but basic hygiene. The effort is small: one column, one branch and a local model.
It is not needed when all sources are public and only costs matter. Then a cloud API is enough, and a second backend would be unnecessary complexity. Also do not let individual reports lead you to a blanket verdict on cloud services: what matters is which data you send, not which provider is currently in the news.