Blindspot is AI search that answers your question without the server ever seeing it. Your laptop encrypts the question. The document server finds and returns the right passages without learning the question, the relevance scores, or which passages you read. A model on your laptop writes a cited answer.

  • 4 live document servers: consumer health, genetics, federal leave law, public-health guidance
  • No accuracy cost from the encryption: encrypted ranking matched plaintext ranking in our integration test
  • 91% of test questions found the right page in the top 10, vs 92% with no privacy at all
  • ~6 ms of cryptography per question
  • 17 / 17 questions that should be declined were declined, with 0 wrong answers

Inspiration

In the U.S., 32% of adults used an AI chatbot for health information in the past year, up from 16% a year earlier. 41% of them uploaded personal medical information, and 36% said they picked AI partly for privacy.

But the server reads every question, and stored questions get out:

  • Kaiser Permanente told 13.4 million members and patients that tracking code on its website and apps may have sent what they searched and read to third parties.
  • In 2025 a federal court ordered OpenAI to keep ChatGPT chats that users had deleted.
  • In 2006 AOL released "anonymized" search logs, and reporters identified user #4417749 by name from her searches alone.

Privacy policies, delete buttons and HTTPS don't change the basic fact: the server has your question in readable form. We wanted a server that can't read it, so there's nothing to leak, sell or subpoena.

What it does

You ask a question in a normal chat and choose which libraries to search. Then:

  1. Your laptop encrypts the question with a one-time key that never leaves the device.
  2. Each server scores every passage against the encrypted question and sends back encrypted scores it can't read.
  3. Your laptop decrypts the scores, picks the top 10, and fetches those passages privately. The server can't tell which 10 you wanted.
  4. A local model writes the answer with citations. If no source is good enough, it says so instead of guessing.

The server can see that a query happened, when, from which IP address, and how big the request was. It never sees the question, the search results or their ranking, which passages you read, or the answer. A breach, an insider or a court order can only get what the server has.

Who would run it: any organization that wants to answer sensitive questions without collecting them. Think hospitals and health sites, HR and benefits teams, universities (Title IX, counseling), and legal-aid groups. The provider runs the Blindspot server over its own documents, much as websites once had to adopt HTTPS.

What you'll see in the demo

The app has two tabs.

  • Chat is what a real user sees. Ask "Can I take FMLA leave for a pregnancy complication?" and you get an answer drawn from the federal regulations, with links to the exact sections it used.
  • Live demo is the proof. It sends one question two ways at once: to an ordinary search server, and to Blindspot. A recorder sits between the app and both servers and saves every byte they receive. Side by side, the ordinary server's log shows your question word for word. Blindspot's server log shows only a time, an endpoint, a response size and a latency, and its recorded traffic contains no trace of the question. The attacker console on the same tab lets you search everything the server stored. The question isn't there.

The four libraries are MedlinePlus, MedlinePlus Genetics, the federal FMLA regulations (29 CFR Part 825) and MyHealthfinder. All are public-domain, and each runs as a separate hosted server.

How we built it

Preparing a library (provider's side, once, before any question). The provider downloads its public pages, splits them into passages, and turns each passage into a list of 384 numbers with an embedding model (bge-small-en-v1.5). The numbers are rounded to 8-bit integers and stored on the server as a matrix D, alongside the passage text. This is ordinary preprocessing on public documents. No user is involved yet.

Asking (your laptop, every question). Your laptop runs the same embedding model on your question to get its own list of 384 numbers, q. A passage's relevance is the dot product of the two lists:

$$s_{i} = \mathbf{q} \cdot \mathbf{d}{i} = \sum{j=1}^{384} q_{j} d_{ij}$$

That is only multiplication and addition. Lattice-based encryption (Learning With Errors, LWE) lets a server multiply and add numbers it can't read. LWE is believed to hold up against quantum computers as well as today's. It belongs to the same family of lattice problems as NIST's post-quantum encryption standard (ML-KEM).

Encrypted scoring. The laptop rounds the question vector to 8-bit integers and encrypts it as c = As + e + Δq. Here s is a fresh secret key, A is public, e is small random noise, and Δ is a scaling factor. The server multiplies its passage matrix D by c without decrypting anything. The laptop has downloaded a public hint H = DA once per library, so it can strip out the key term:

$$D\mathbf{c} - H\mathbf{s} = D\mathbf{e} + \Delta D\hat{\mathbf{q}}$$

Rounding removes the noise and leaves the exact scores for every passage. The encryption adds no error, so encrypted ranking equals plaintext ranking.

Private fetch. To get a passage, the laptop sends an encrypted list with a 1 at the wanted position and 0 everywhere else. The server multiplies every record by its slot and adds them up. The zeros erase everything except the wanted passage, which comes back still encrypted. The server touches every record equally, so it learns nothing. This is private information retrieval (SimplePIR). We always fetch exactly 10 passages, so even the number of good matches stays hidden.

Answering on the laptop. A local cross-encoder reranks the 10 passages, and llama3.2:3b (through Ollama) answers only from the best 5, with citations. Three checks sit on top:

  • A citation checker deletes any sentence no passage supports.
  • A fixed rule adds a 988/911 notice to urgent questions.
  • A calibrated threshold makes it decline when nothing relevant was found.

What we used vs. what we built. The encryption and PIR primitives come from Tiptoe's underhood and SimplePIR, built on Microsoft SEAL. Both are research code, which we vendored and patched. We built the rest:

  • the Go document server and a local key helper
  • ingestion for four corpora
  • the client pipeline and the answer-safety layer
  • the evaluation harness, wiretap relay and React web UI
  • deployment of four independent servers, each loading its library from a Databricks Unity Catalog volume and checking it against a pinned hash

Parameters, the threat model and the design notes are in the repo.

Accomplishments that we're proud of

Measured on 96 test questions (79 answerable, 17 that should be declined):

Result
Right page in top 10, no privacy (float embeddings) 73 / 79 (92%)
Right page in top 10, Blindspot (int8) 72 / 79 (91%)
Encrypted top 10 vs. plaintext top 10 Identical in our integration test
Should-decline questions declined 17 / 17 (100%)
Wrong answers where it should have declined 0 / 17
Urgent 988/911 notice correct 96 / 96 (100%)
Unsupported sentences removed by the citation checker 89

Privacy costs one percentage point of recall, and the cause is rounding the embeddings to 8 bits, not the encryption. The cryptography takes about 6 ms per question and under 10 ms of server CPU, after a one-time hint download per library. Almost all of the wait is the 3B model writing the answer on the laptop.

Our team wrote the test questions; clinicians did not review them. The sample is small.

Challenges we ran into

Our biggest problem: the crypto was too slow to use. Once Tiptoe's research library built (it didn't compile on current Go, so we vendored and patched it), encrypted search worked. But every question required a fresh token of about 33 MB. In practice that meant about 34 MB uploaded and about 2.7 s per question. That's fine for a paper and unusable for a chat.

The fix came from looking at what the token was for. Most of the expensive work, the hint H = DA, depends only on the library's matrix D and a public random matrix A. It is identical for every user and every question. So instead of rebuilding it per question, the server publishes it and the laptop downloads it once per library and caches it. Each question then shrinks to the key-dependent part.

To keep that one-time download to 17 MB, we dropped the hint's low 32 bits. That adds rounding error, so we checked that the worst-case error (2^42) stays below the limit where decryption fails (2^46). Encrypted rankings still matched plaintext exactly.

It also made key handling critical. With the hint fixed, reusing a secret key across questions would leak information. A local key helper prepares fresh keys in the background and refuses to use any key twice.

Result: the cryptography for a question went from about 2.7 s to about 6 ms. We applied the same batching idea to private fetch, sending all 10 requests at once, and cut it from about 0.5 s to about 25 ms locally.

We also had to stop a small 3B model from improvising (a citation checker removed 89 unsupported sentences) and close leaks around the math (pinned corpus hashes, identical client headers, rate limits, no telemetry). Details are in the repo.

What we learned

  • Private search needs only linearly homomorphic encryption, because relevance scoring is just multiplication and addition. We didn't need full homomorphic encryption.
  • At thousands of documents, scoring every passage is cheap. It also avoids the accuracy loss that web-scale private search takes from only searching some clusters.
  • The encryption was the easy part to explain. The hard part was everything around it: logs, headers, key reuse and response sizes can each leak what the math protects.

Limits

  • The server still sees that you asked, when, and your IP address. A VPN or Tor hides that today.
  • The documents are not hidden from the person asking, so this suits public or shareable collections.
  • It's built for thousands of documents, not millions.
  • The cryptographic libraries are research code and haven't had a security review.
  • Blindspot gives information with citations, not medical or legal advice.

What's next for Blindspot

  • Ship it as a package. Today Blindspot runs as our demo app. We're turning it into a Python library (pip install) with two halves: a client with a single ask() call that handles encryption, private fetch and the cited answer, and a server kit that turns any folder of documents into a Blindspot server with one command. Then any developer can add private search to their own app.
  • Hide metadata: route queries through an Oblivious HTTP relay, always query every library, and send dummy queries.
  • Scale to millions of documents with graph-based private search (Pacmann).
  • Protect private collections with symmetric PIR, so a hospital could serve internal documents.
  • Signed manifests and verifiable computation, so a malicious server can't quietly return wrong results.

Private RAG is an active research area (Tiptoe, PIR-RAG, RemoteRAG, PRAG), and we don't claim a new technique. Our contribution is the working product: deployable servers, cited answers on your own device, safe declines, and a demo that shows exactly what the server saw.

Built With

  • bge-small-en-v1.5
  • cross-encoder
  • databricks
  • docker
  • fastapi
  • go
  • homomorphic-encryption
  • lattice-cryptography
  • llama-3.2
  • medlineplus
  • microsoft-seal
  • ollama
  • private-information-retrieval
  • python
  • react
  • render
  • sentence-transformers
  • simplepir
  • tailwindcss
  • three.js
  • tiptoe
  • typescript
  • uvicorn
  • vite
Share this project:

Updates

Submission history