Stop Losing Your Digital Life: Pensieve Remembers Everything Locally

How many times this week have you stared at your screen, desperately trying to remember that one thing you saw? That critical Stack Overflow answer. The API key you generated. The design mockup your teammate shared in a fleeting Slack huddle. We live in an age of infinite information—and yet our brains are still terrible at retrieval.

Enter Pensieve, the open-source project that's making proprietary tools like Rewind and Windows Recall look like expensive privacy nightmares. Born from a simple, radical idea—what if your computer actually remembered what you did, without selling your soul to a cloud provider—Pensieve is rapidly becoming the secret weapon of developers who refuse to let their digital history vanish into the void.

This isn't just another screenshot tool. It's a complete, self-hosted memory system that records your screens, indexes every pixel with OCR and AI-powered vector search, and serves it all through a gorgeous web interface. And the kicker? Your data never leaves your machine. No sketchy data centers. No subscription traps. No wondering who's training models on your bank passwords.

If you've ever felt the cold sweat of "I know I saw that somewhere..."—keep reading. This changes everything.

What is Pensieve? The Memory Palace You Actually Control

Pensieve (previously called Memos, renamed because the name was taken) is a privacy-focused passive recording project created by developer arkohut. Inspired by commercial products like Rewind.ai and Microsoft's controversial Windows Recall feature, Pensieve takes the same core concept—continuous screen recording with AI-powered search—and strips away every element that compromises user privacy.

The project's philosophy is brutally simple: your screen history is yours alone. Where Rewind charges subscription fees and processes data through their infrastructure, and where Windows Recall sparked massive backlash over security vulnerabilities and cloud-adjacent data handling, Pensieve keeps everything local. Every screenshot, every indexed word, every vector embedding lives in ~/.memos on your own hardware.

Pensieve has exploded in popularity precisely because it solves a problem that millions of knowledge workers feel acutely: context switching amnesia. Developers jump between dozens of tabs, applications, and conversations daily. The human brain wasn't evolved for this firehose of digital stimuli. Pensieve acts as an external, searchable memory—like having a photographic recall of your entire computing life, without the cognitive overhead.

The project is built in Python, designed for extensibility through plugins, and integrates with local ML infrastructure like Ollama. It's currently stable on macOS and Windows, with Linux support actively in development. The latest versions have introduced game-changing features like agent skills for AI coding assistants, application blacklists for privacy control, and PostgreSQL backend support for massive-scale deployments.

Key Features: Why Developers Are Switching in Droves

Pensieve isn't a toy. It's a production-grade system with architectural decisions that reveal serious engineering depth:

• 🔒 Complete Data Sovereignty: Every byte stays local. Screenshots live in ~/.memos/screenshots. The database is either SQLite or your own PostgreSQL instance. No network egress, no third-party processing, no trust required.

• 🔍 Hybrid Search Architecture: Pensieve combines full-text search (for exact matches on OCR'd text) with dense vector search (for semantic similarity). This dual approach means you can find "that React error about hydration" even if you only remember it was "something with water and components."

• 🤖 Local ML Integration: Through Ollama, Pensieve can run multimodal vision-language models (like minicpm-v) to describe image contents—not just read text. This enables true visual search: "show me when I was looking at dark-themed dashboards."

• 🌐 Smart Metadata Capture: The system automatically extracts browser URLs, application names, and timestamps. Your search isn't just "screenshots with cats"—it's "screenshots from GitHub issues I viewed last Tuesday while in VS Code."

• 🔌 Plugin Extensibility: The architecture supports custom plugins. Default plugins include OCR and VLM, but the system is designed for community extensions.

• 📊 Interactive Timeline Navigation: The entity detail view (v0.29.0+) provides chronological context navigation—browse forward and backward through your digital history like scrubbing a video timeline.

• 🤖 Agent Skill Integration (v0.33.0): This is where it gets wild. Pensieve now exposes a skill file that lets AI coding assistants—Claude Code, Codex, opencode—query your screen history in natural language. Your AI pair programmer can literally see what you've been working on.

• ⚡ Adaptive Processing: Pensieve dynamically adjusts indexing frequency based on your system's capabilities. On battery? It throttles. On a beefy workstation with NVIDIA GPU? It cranks through embeddings at full speed.

Use Cases: Where Pensieve Becomes Indispensable

1. The Debugging Time Machine

You're three hours into debugging a race condition. You know you saw a relevant GitHub issue... was it yesterday? Last week? With Pensieve, you search "race condition asyncio" and instantly surface every moment that text appeared on your screen, complete with the URL and surrounding context.

2. Compliance and Audit Documentation

Freelancers and contractors often need to prove work was done. Instead of manual time-tracking, Pensieve provides an objective, searchable record of actual work performed. Search for "invoice" or "client-name" and reconstruct your project timeline with screenshot evidence.

3. Learning and Research Synthesis

Consuming a 50-page technical paper? Watching a dense conference talk? Pensieve captures every frame. Later, search concepts that appeared in diagrams, terminal outputs, or slides—even if you never manually noted them. It's like having searchable video of your entire research process.

4. Security Incident Response

Suspect you clicked a phishing link? With Pensieve, you can reconstruct the exact sequence: which Slack message contained the link, what the landing page looked like, what credentials you may have entered. This level of forensic detail is impossible with traditional logging.

5. AI-Augmented Development Workflows

Using the Agent Skill, Claude Code can query your recent work: "Find where I was configuring the Docker networking yesterday"—and receive ranked results with direct links to screenshot detail pages. Your AI assistant gains situational awareness of your actual work patterns.

Step-by-Step Installation & Setup Guide

Prerequisites: Verify Your Python Environment

Before installation, confirm your Python's SQLite supports extensions. Run this diagnostic:

import sqlite3

# Check sqlite version
print(f"SQLite version: {sqlite3.sqlite_version}")

# Test if enable_load_extension is supported
try:
    conn = sqlite3.connect(':memory:')
    conn.enable_load_extension(True)
    print("enable_load_extension is supported")
except AttributeError:
    print("enable_load_extension is not supported")
finally:
    conn.close()

If this fails, install miniconda for a compatible Python environment.

Standard Installation (macOS/Linux)

# Install the package
pip install memos

# Initialize configuration and database
memos init
# Data will be stored in ~/.memos

# Enable auto-start and launch services
memos enable
memos start

This single command sequence:

• Begins recording all connected screens
• Starts the web service on port 8839
• Configures the service to start on boot

Access your memory archive at: http://localhost:8839

Windows Installation (Recommended Method)

Windows users should avoid bare pip install to prevent permission and path issues:

# Option A: uv (fastest, single binary)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
uv tool install memos

# Option B: pipx (isolated environment)
pip install --user pipx
python -m pipx ensurepath
pipx install memos

Critical Windows pre-configuration (run in Admin PowerShell):

# Enable long paths for ML wheel compatibility
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1

# Exclude ~/.memos from Windows Defender real-time scanning
Add-MpPreference -ExclusionPath "$env:USERPROFILE\.memos"

macOS Permission Configuration

First run of memos start triggers macOS screen recording permission prompt—allow it.

To verify permissions without triggering prompts:

memos doctor

This prints the exact Python interpreter path needing authorization, and where to find it in System Settings → Privacy & Security → Screen & System Audio Recording.

Pro tip: If you upgrade Python (brew, pyenv, conda recreation), TCC permissions break because they're keyed to binary paths. Fix with:

tccutil reset ScreenCapture
memos stop && memos start

Avoid this entirely by using pipx or uv tool install—both pin the interpreter path across upgrades.

REAL Code Examples: From the Repository

Example 1: PostgreSQL Migration with Docker

For production deployments or large archives, PostgreSQL with pgvector dramatically outperforms SQLite. Here's the exact Docker setup from the repository:

# Linux/macOS — create persistent pgvector container
docker run -d \
    --name pensieve-pgvector \
    --restart always \
    -p 5432:5432 \
    -e POSTGRES_PASSWORD=mysecretpassword \
    -v pensieve-pgdata:/var/lib/postgresql/data \
    pgvector/pgvector:pg17

What's happening here? This launches PostgreSQL 17 with the pgvector extension pre-installed. The named volume pensieve-pgdata ensures your data survives container restarts. Port 5432 is exposed for Pensieve connection. The --restart always policy means your memory system survives reboots automatically.

Then configure Pensieve to use it by editing ~/.memos/config.yaml:

# Replace SQLite path with PostgreSQL connection string
database_path: postgresql://postgres:mysecretpassword@localhost:5432/postgres

Example 2: Embedding Model Configuration

Pensieve's search quality depends heavily on embedding model selection. Here's the exact configuration for English-language semantic search:

embedding:
  use_local: true
  model: jinaai/jina-embeddings-v2-base-en   # English-optimized 768-dim model
  num_dim: 768                               # Must match model's output dimensions
  use_modelscope: false                      # Use HuggingFace, not ModelScope mirror

Critical details: The jina-embeddings-v2-base-en model is specifically chosen for English text—using the Chinese variant (-zh) for English content would severely degrade search quality. The num_dim: 768 must exactly match the model's architecture; mismatch causes silent indexing failures.

After changing models, force a complete reindex:

memos reindex --force
# --force rebuilds index table and purges stale embeddings

Example 3: VLM Integration with Ollama for Visual Understanding

This is where Pensieve transcends OCR limitations. The configuration enables true image comprehension:

vlm:
  endpoint: http://localhost:11434  # Ollama's default local API port
  modelname: minicpm-v              # Lightweight multimodal model (~5.5GB)
  force_jpeg: true                  # Normalize formats for model compatibility
  prompt: Please describe the content of this image, including the layout and visual elements

Then activate the VLM plugin in ~/.memos/plugins/vlm/config.yaml:

default_plugins:
- builtin_ocr    # Keep text extraction
- builtin_vlm    # Add visual description

Performance reality check: This requires NVIDIA GPU with 8GB+ VRAM or Apple Silicon. CPU-only operation is technically possible but creates severe system lag. The minicpm-v model generates natural language descriptions of screenshots—enabling searches like "dashboards with red error banners" that pure OCR cannot handle.

Example 4: Agent Skill for AI Coding Assistants

Pensieve v0.33.0's most futuristic feature—exposing your memory to AI agents. The skill file at skills/pensieve-search/SKILL.md teaches any compatible agent to query your history.

Install for Claude Code:

# Create skills directory
mkdir -p ~/.claude/skills/pensieve-search/

# Symlink or copy the skill file
ln -s /path/to/pensieve/skills/pensieve-search/SKILL.md ~/.claude/skills/pensieve-search/

Now your agent understands natural language queries like: "find that thing I looked at last week" or "show me when I was working on the Mastra integration". The skill translates these to /api/search calls with appropriate text, time window, and active_app filters—then returns ranked results with direct links to /entities/<id> for verification.

Example 5: Adaptive Sampling Configuration

For systems struggling to keep pace with screenshot generation, fine-tune the processing strategy:

watch:
  rate_window_size: 10    # Samples for rate calculation
  sparsity_factor: 3.0    # Higher = less frequent processing (minimum 1.0)
  processing_interval: 12 # Process 1 of every 12 screenshots initially

To process every screenshot aggressively (for high-powered workstations):

watch:
  rate_window_size: 10
  sparsity_factor: 1.0    # No sparsity—process every file
  processing_interval: 1  # Initial 1:1 ratio, auto-adjusts if overwhelmed

Remember: memos stop && memos start to apply configuration changes.

Advanced Usage & Best Practices

Storage Management: At 2560×1440 resolution, expect ~400MB/day for 10 hours of single-screen usage. Multi-monitor setups scale linearly. The deduplication engine helps—static content (reading, document editing) generates minimal new data. For OneDrive users: redirect base_dir in ~/.memos/config.yaml away from synced folders, or you'll upload ~12GB/month to cloud storage.

Power Optimization: Pensieve intelligently throttles on battery. For desktop workstations, consider scheduling intensive memos scan operations during off-hours using the idle processing window:

watch:
  idle_timeout: 300                    # 5 minutes to idle detection
  idle_process_interval: ["00:00", "07:00"]  # Midnight to 7am processing window

Database Scaling: SQLite handles ~100K screenshots comfortably (~2.2GB database). Beyond that, migrate to PostgreSQL. The migration command preserves all data:

memos migrate \
  --sqlite-url "sqlite:///~/.memos/database.db" \
  --pg-url "postgresql://postgres:mysecretpassword@localhost:5432/postgres"

Privacy Hardening: Use the application blacklist (v0.30.0+) to exclude password managers, banking sites, or sensitive applications from recording entirely. Configure through the web UI at http://localhost:8839/config.

Comparison with Alternatives

The verdict: Rewind offers polish but demands trust and recurring payment. Windows Recall carries enterprise risk perception and limited platform reach. Pensieve delivers comparable core functionality with absolute control, zero subscription, and community-driven evolution.

FAQ: What Developers Ask Most

Q: Does Pensieve slow down my machine? A: It adapts to your hardware. On battery, it throttles. Without GPU, it samples processing. The OCR is optimized per-OS (macOS Vision framework, Windows Tesseract). You control the tradeoff via sparsity_factor and processing_interval.

Q: How secure is local storage against malware? A: Better than cloud alternatives, but not magic. Screenshots live in ~/.memos with your user permissions. Encrypt your disk (FileVault/BitLocker) for defense-in-depth. The blacklist feature excludes sensitive apps from recording.

Q: Can I search across multiple machines? A: Not natively—by design. Each instance is sovereign. For multi-machine search, you'd need to architect a shared PostgreSQL backend and synchronized storage, which the project doesn't currently support.

Q: What happens when I hit 1 million screenshots? A: SQLite will struggle. Migrate to PostgreSQL using the built-in migration tool. PostgreSQL with pgvector maintains performance at scale. Consider the idle processing strategy to catch up on backlog.

Q: Is my data ever transmitted? A: Never, unless you explicitly configure external services. Default embedding models download from HuggingFace on first use, but run locally thereafter. Ollama integration is localhost-only. The code is auditable Python.

Q: How does this compare to browser history? A: Browser history captures URLs. Pensieve captures everything—terminal output, IDE state, design tools, video calls, PDFs. It's the difference between knowing you visited a page and remembering exactly what you saw.

Q: Can I contribute or extend functionality? A: Absolutely. The plugin architecture is designed for community extensions. The project welcomes contributions, especially around privacy enhancements and platform support.

Conclusion: Your Digital Memory, Finally Yours

Pensieve represents something rare in modern software: a genuinely empowering tool that respects its users as sovereign individuals, not data reservoirs. In an era where every productivity app demands cloud dependency and subscription rent, Pensieve stands apart—open, local, and completely under your control.

The technical architecture is thoughtful. The privacy posture is uncompromising. And the latest features—especially the agent skill integration—point toward a future where your AI assistants don't just guess your context, but genuinely remember your work.

Is it perfect? No. Linux support is in development. The setup requires more technical comfort than commercial alternatives. But for developers who value autonomy over convenience, auditability over polish, and zero trust over blind faith, Pensieve is already indispensable.

Stop letting your digital history evaporate. Start building your own memory palace today.

👉 Get started: github.com/arkohut/pensieve

Install with pip install memos, run memos init && memos start, and never lose another idea to the void.