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.

Proton offers a free tier with 1 GB storage. For serious research workflows, the Proton Unlimited plan gives you 500 GB across Drive, Mail, Calendar, and VPN — and PrivateAI readers get 100% commission-back on the first month when you use our link.

Step 5: Archive Sensitive Research with Tresorit

Proton Drive is excellent for day-to-day sync. For long-term encrypted archival of sensitive research — think: client deliverables, proprietary analysis, competitive intelligence — Tresorit is the stronger enterprise pick.

Tresorit is end-to-end encrypted, Swiss-jurisdiction, and has granular access controls that Proton currently lacks: you can share a specific folder with a contractor, revoke access instantly, and audit who opened what file and when.

The workflow:

Active research → Proton Drive (fast sync, daily access)
Completed project archives → Tresorit (access-controlled, auditable, long-term retention)

Set up a simple folder convention:

```

~/ProtonDrive/AI-Research/active/ # live projects

~/Tresorit/AI-Research/archive/YYYY/ # completed, by year

```

Once a project is closed, move its folder from Proton Drive active to Tresorit archive. Both are encrypted at rest and in transit. Neither provider can hand your files to a third party without your key.

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

Perplexity Pro is $20/month. For research-heavy workflows, the time savings alone make it worth it — and Private Mode makes it the most defensible cloud AI tool in this stack.

Putting It All Together: A Daily Research Workflow

Here's what this looks like in practice for a developer doing competitive intelligence research:

Morning research session:

Open Hollama or Open WebUI → select llama3.1:8b
Open Perplexity Pro in private mode for any current-events lookups
Paste relevant web content into your local LLM for analysis — never into Perplexity or any cloud AI
Save conversation export to ~/ProtonDrive/AI-Research/active/[project-name]/

End of day:

Review and clean up AI output files
Push final summaries to Proton Drive
Close any completed project folders into Tresorit archive

Monthly:

Rotate which model you're using — check Ollama's model registry for new releases
Review Proton Drive usage and archive anything older than 30 days to Tresorit
Audit Tresorit shared folders — revoke access for any expired collaborators

Common Mistakes and How to Avoid Them

Mistake: Running Ollama with --host 0.0.0.0

This exposes your local LLM to your entire network. Anyone on your WiFi can query your model and potentially access uploaded documents. Keep Ollama bound to localhost unless you have a specific use case and a firewall rule to match.

Mistake: Storing model files in synced cloud folders

Model files are 4-40 GB each. Putting them in Dropbox or iCloud is wasteful and often breaks Ollama's file locking. Store models in Ollama's default path (~/.ollama/models) and only sync your outputs and configs.

Mistake: Using browser extensions with your local UI

Browser extensions can read page content, including your conversations with Open WebUI. Use a privacy-focused browser (Firefox with uBlock Origin, or Brave) and disable extensions when using your local AI interface.

Mistake: Trusting "privacy mode" in cloud AI tools

Most cloud AI "privacy modes" mean your conversations aren't used for training. They don't mean your data isn't stored, logged, or accessible to the vendor. For genuinely sensitive work, local inference is the only real answer.

Hardware Upgrade Path

If you're running on a 16 GB machine and want better performance:

Short-term: An external GPU (NVIDIA 4070 Ti or 4090) connected via Thunderbolt gives you fast inference without replacing your machine
Medium-term: A Mac Studio with M4 Max (128 GB unified memory) runs 70B models at practical speeds
Long-term: A dedicated local AI server — a used workstation with a 3090 or 4090 can be had for under $1,500 and handles any open-source model available today

The economics flip quickly: a $1,200 GPU purchase pays for itself vs. $20/month Perplexity Pro + $25/month ChatGPT Plus in under 3 years — and you get complete data sovereignty forever.

Get Notified When We Publish New Privacy Stack Guides

We cover local AI tools, encrypted workflows, and data sovereignty for tech workers. New guides drop weekly — no tracking pixels, no ad retargeting, just the email.

Stay Updated

New local AI guides, tool reviews, and privacy workflows in your inbox. Unsubscribe any time.