Bottom line up front: If you use ChatGPT, Claude.ai, or any cloud AI tool for research involving confidential work, client data, or anything you wouldn't paste into a public Slack channel — you have a data problem. This guide shows you how to build a self-contained, encrypted private AI research stack using tools you can run entirely on your own hardware.

No API calls to OpenAI. No conversation logs stored on someone else's server. No vendor reading your prompts to train their next model.

Here's the stack we're building:

Ollama — local LLM runtime (free, open-source)
A capable local model — Mistral 7B, Llama 3.1, or Qwen 2.5
Proton Drive — zero-knowledge encrypted sync for AI outputs and configs
Tresorit — end-to-end encrypted backup of sensitive research archives
Perplexity Pro — for the rare cases when you need live web research (with privacy settings locked down)

Last updated: 2026-06-22

Why "Private by Default" Matters More Than You Think

Most tech workers assume they're already careful. They use a password manager, they have 2FA on everything. But they paste SQL schemas into ChatGPT to debug queries. They summarize client emails with Claude. They drop proprietary code into Copilot.

Every one of those interactions is logged, associated with your account, and potentially used for model training or reviewed by human contractors — depending on the platform's terms of service (which change without notice).

The risk isn't hypothetical. In 2023, Samsung engineers leaked proprietary chip designs through ChatGPT. In 2024, a healthcare startup exposed patient intake summaries by integrating a cloud AI API without reviewing the provider's data retention policy.

For a privacy-conscious developer, the answer isn't "use the privacy toggle." The answer is: never send sensitive data to a cloud model in the first place.

What You Need Before You Start

Hardware minimum:

16 GB RAM (8 GB technically works but you'll be limited to smaller models)
20 GB free disk space per model
Apple Silicon, or a modern AMD/Intel CPU (GPU optional for CPU-only inference)

For GPU acceleration:

NVIDIA GPU with 8+ GB VRAM (4060 Ti / 3080 or better for practical speeds)
Apple Silicon Macs use unified memory — M2 Pro and above run 13B models well

This guide assumes macOS or Linux. Windows users can follow along with WSL2 or the native Ollama installer.

Step 1: Install Ollama

Ollama is the cleanest way to run local LLMs. It handles model downloads, GGUF quantization, and serving a local REST API — all without touching cloud infrastructure.

```bash

macOS (via Homebrew)

brew install ollama

Linux

curl -fsSL https://ollama.com/install.sh | sh

```

Start the Ollama service:

```bash

ollama serve

```

Ollama binds to localhost:11434 by default. It never makes outbound connections except to pull models from the Ollama registry during setup. After that, it's fully offline.

Verify your install:

```bash

curl http://localhost:11434/api/tags

```

You should get a JSON response listing installed models. Empty list is fine at this point.

Step 2: Pull a Model That Fits Your Hardware

Model selection is a trade-off between capability and memory footprint. Here's a practical guide:

| Model | RAM Needed | Good For |

|-------|-----------|----------|

| Mistral 7B Q4 | ~5 GB | Fast summarization, quick Q&A |

| Llama 3.1 8B | ~6 GB | Strong reasoning, code, writing |

| Qwen 2.5 14B | ~10 GB | Deeper analysis, multilingual |

| Llama 3.3 70B Q4 | ~40 GB | Near-GPT-4 quality on strong hardware |

For most 16 GB MacBooks or developer workstations, llama3.1:8b hits the sweet spot:

```bash

ollama pull llama3.1:8b

```

If you have a beefy machine with 32+ GB RAM, try:

```bash

ollama pull qwen2.5:14b

```

Test it immediately:

```bash

ollama run llama3.1:8b "Summarize the key privacy risks of cloud AI tools in 3 bullet points."

```

Watch it respond entirely locally. Nothing left your machine.

Step 3: Wire Up a Chat Interface

The CLI is fine for quick tests, but you want a UI for sustained research sessions. Two solid options:

Open WebUI — The most full-featured local UI. Supports multi-model switching, conversation history, document uploads (RAG), and a plugin system. Install with Docker:

```bash

docker run -d -p 3000:8080 \

--add-host=host.docker.internal:host-gateway \

-v open-webui:/app/backend/data \

--name open-webui \

ghcr.io/open-webui/open-webui:main

```

Then open http://localhost:3000 in your browser.

Hollama — Lightweight, no-Docker option for macOS:

```bash

brew install hollama

```

Both options store conversation history locally on your filesystem. Neither phones home.

Step 4: Encrypt and Sync Your AI Outputs with Proton Drive

Here's where most local LLM guides stop — and where the actual security gap starts.

You're generating valuable research outputs: summaries, analysis, code snippets, notes. If those files sit unencrypted on your laptop, a stolen machine means a data breach. If you sync them to standard iCloud or Dropbox, you've just moved the privacy problem upstream.

Proton Drive solves this with zero-knowledge encryption. Unlike iCloud or Google Drive, Proton cannot read your files — they're encrypted client-side before upload. Your encryption keys never touch Proton's servers.

Setup for AI research workflows:

Install Proton Drive desktop app (macOS, Windows, Linux)
Create a dedicated folder: ~/ProtonDrive/AI-Research/
Configure Open WebUI or Hollama to export conversation archives to this folder
Set your text editor to autosave AI-assisted research drafts here

For Open WebUI, you can find the conversation export under Settings → Data → Export. Set up a weekly cron or shortcut to dump to your Proton Drive folder.

Affiliate Disclosure: This article may contain affiliate links. If you make a purchase through these links, we may earn a small commission at no extra cost to you. We only recommend products we genuinely believe in. This helps support our work and allows us to continue providing free content.

Tresorit Business starts at $15/user/month and includes admin controls, remote wipe, and compliance reporting. PrivateAI readers get 25% off recurring for 12 months.

Step 6: Handle Web Research Without Leaking Your Queries

Local LLMs have a hard limit: their knowledge has a training cutoff. When you need live web information — current news, recent papers, pricing, SEC filings — you have to make a choice.

The privacy-unsafe default is Googling it yourself and pasting results into your local model. That works, but it's manual and you're still leaving search query traces on Google's servers.

The better option for privacy-conscious users is Perplexity Pro with a few critical settings adjusted:

Go to Settings → Privacy
Disable AI training data opt-in
Enable Private Mode (available on Pro tier — queries are not stored or used for training)

Perplexity's private mode means your research queries aren't logged to a profile. You get cited, up-to-date answers without the surveillance model of Google Search.

The hybrid workflow:

Use local LLM for: analyzing documents you upload, drafting, summarizing your own notes, brainstorming, writing code
Use Perplexity Pro (private mode) for: current events, finding sources, fact-checking against live web
Never paste Perplexity results directly into a cloud AI tool — paste them into your local model instead