# Pensieve: Local Screen Recall with Searchable History

> Pensieve is a self-hosted screen recording and retrieval application for Windows and macOS users who want screenshots indexed and stored locally. It combines passive capture, OCR, metadata, full-text search, vector search, and a web interface, although Linux support remains in development.

**arkohut/pensieve** — A passive recording project allows you to have complete control over your data. Automatically take screenshots of all your screens, index them, and save them locally.

- Repository: https://github.com/arkohut/pensieve
- Stars: 1,403 · Forks: 61
- Language: Python
- License: Apache-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/arkohut-pensieve

## Pensieve's local screen recall workflow

Pensieve addresses a specific problem: people often need to recover something they saw on a screen but cannot reconstruct when or where it appeared. It records screen content passively, builds an index from the captured images, and presents historical records through a local web interface. The intended users are Windows and macOS users who want recall-style search without sending their screenshot archive to an untrusted data center.

The repository presents Pensieve as similar in purpose to Rewind and Windows Recall, but its defining distinction is storage and processing under the operator's control. The README says screenshots and processed data are stored locally, and the initialization flow places them under ~/.memos. That choice does not make capture anonymous. Screen recordings can still contain sensitive material from applications and browser pages, so local storage changes custody of the data rather than removing the need for access controls or retention planning.

Pensieve also captures metadata that can make search more useful. The documented feature list includes browser URL retrieval for web activity, interactive entity pages, and chronological navigation. Search is available in two forms: full-text and vector search. This makes the application closer to a searchable activity archive than a basic screenshot folder, although the README does not describe a retention policy, screenshot deletion schedule, or backup procedure.

## Recording, indexing, and retrieval inside Pensieve

The visible workflow has four parts. First, the service records all screens unless a configured application is excluded. Second, the capture is written under the configured local data directory. Third, Pensieve builds intelligent indices and extracts metadata. Fourth, the web service exposes those records for search and chronological browsing.

The Python package structure reflects several parts of that path. The top-level `screen_recorder` directory is separate from the `memos` package, while the web application includes a `web` directory and `memos_app.py`. The project dependencies include `mss` for screen capture, `watchdog` for filesystem watching, OCR libraries such as `rapidocr`, `onnxruntime`, and macOS-specific `ocrmac`, plus `sqlite_vec>=0.1.6`. SQLAlchemy and Alembic indicate a relational database layer and schema migrations, while FastAPI and Uvicorn provide the service side.

Machine learning support has two documented paths. Pensieve integrates with Ollama as its local machine-learning engine, and it can also work with any OpenAI API model, including Azure OpenAI and vLLM. Vector search and sentence-transformer dependencies support semantic retrieval, while OCR supports text extraction. The application blacklist introduced in version `v0.30.0` is checked during both recording and file watching, so an excluded application is not merely hidden after capture.

This architecture has a cost. The dependency list includes `torch`, `sentence-transformers`, `modelscope`, `timm`, `einops`, and computer-vision packages. Installation is therefore larger than the short command sequence suggests. The README also warns that some Python SQLite builds may lack `enable_load_extension`, which makes the Python environment an installation dependency rather than an incidental detail.

## Installing memos and starting the first capture

The README's basic installation uses the `memos` package name even though the application is now called Pensieve. First confirm that the SQLite extension-loading feature works in the selected Python environment:

```python
import sqlite3

print(f"SQLite version: {sqlite3.sqlite_version}")
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()
```

The README says to expect the supported message when the environment provides the required API. If it does not, it points to `miniconda` as an alternative environment manager. Then install the package:

```sh
pip install memos
```

Initialize the configuration file and SQLite database:

```sh
memos init
```

The README states that data will be stored in `~/.memos`. Enable the service, start it, and open the web interface:

```sh
memos enable
memos start
```

```text
http://localhost:8839
```

The service starts recording screens, starts the web service, and is configured to start on boot. The URL is for local retrieval, not a public endpoint. Before opening it, verify that the process is running and that the expected capture location is acceptable.

## Mac permissions and Windows installation constraints

Pensieve has meaningful platform-specific setup requirements. On macOS, the first `memos start` prompts for screen-recording permission. The README recommends checking the authorized interpreter without creating another prompt:

```sh
memos doctor
```

That command prints the Python interpreter path and points to the relevant macOS settings. If Python is replaced, the previous permission can become stale because the authorization is associated with the interpreter binary path. The README gives this reset procedure:

```sh
tccutil reset ScreenCapture
memos stop && memos start
```

On Windows, the README prefers an isolated tool installation over a bare global `pip install`. Two documented alternatives are available:

```powershell
uv tool install memos
```

```powershell
pip install --user pipx
python -m pipx ensurepath
pipx install memos
```

The isolated environment keeps the interpreter path stable across upgrades, which the README says helps with macOS-style permission behavior and Windows process management. It also recommends enabling long paths because some machine-learning wheels have deep paths:

```powershell
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1
```

The same section warns against Microsoft Store Python and notes that OneDrive redirection can sync roughly 400 MB of screenshots per day. In that situation, change `base_dir` in `~/.memos/config.yaml` to a local, non-synced path.

## What Pensieve leaves unresolved

The clearest product limitation is platform support. Pensieve supports Mac and Windows, while Linux support is in development. A Linux engineer who needs a production-ready capture service cannot treat the current documentation as a completed Linux installation path.

The README does not document rollback behavior, automatic screenshot retention, backup and restore, or deletion of captured browser activity. It also does not provide a security model for the local web service beyond describing local operation. The default address is `http://localhost:8839`, but the documentation excerpt does not explain authentication, multi-user access, or safe exposure beyond the local machine.

The blacklist is useful, but it is not a complete privacy filter. It excludes selected applications and is applied during recording and file watching. It does not, based on the available documentation, prevent sensitive information from being captured inside an allowed application or from being retained after the original window closes. Pensieve is therefore a poor choice as the sole control for regulated or highly confidential screens unless the operator verifies the capture settings and operating-system permissions.

The local-first approach also creates a storage burden. Screenshots accumulate under the configured directory, and the Windows notes give a cloud-sync warning. Without a documented retention policy, users must decide how much history to retain and where to store it. A self-managed archive gives control, but it also transfers backup, disk-capacity, and deletion work to the person running it.

## Pensieve versus Rewind and Windows Recall

Pensieve identifies Rewind and Windows Recall as conceptual references. The documented difference is data custody: Pensieve says it avoids transferring data to untrusted data centers and keeps processing local.

The distinction is architectural rather than merely branding. Pensieve exposes a Python command-line tool, a local database, a local web interface, pluggable OCR and machine-learning integrations, and local or OpenAI-compatible model choices. Pensieve does not document Windows Recall compatibility or feature parity, so the comparison should not be read as a claim of equivalent recall quality.

For teams, the trade-off is control versus operational responsibility. A hosted recall service can simplify account setup and service operation, while Pensieve requires permission handling, Python installation, machine-learning dependencies, local storage, and model configuration. Pensieve fits users who already accept that work in exchange for self-managed data.

## Maintenance, releases, and upgrade considerations

Pensieve is not archived. Its last push was on 2026-07-19, and the recent release list includes `v0.37.0` from 2026-06-19, `v0.36.0` from 2026-05-15, and `v0.35.1` from 2026-05-14. Those dated release and repository facts indicate recent project changes, but the README does not define a support policy for older releases.

The project is licensed under Apache-2.0. The `pyproject.toml` file identifies the package as `memos`, sets the version to `0.37.0`, and requires Python `>=3.10`. It also exposes both `memos` and `pen` as command aliases. A user following older instructions may therefore encounter the former package name even when working with current Pensieve documentation.

Upgrading can involve more than replacing a small CLI package because the project depends on Python, database migrations, local models, and machine-learning wheels. The README documents `memos stop` and `memos start`, but the available documentation does not describe an upgrade command or rollback procedure. Before upgrading an existing archive, the operator should preserve the configuration and database files under `~/.memos` and verify the target package's release notes.

## Conclusion

Adopt Pensieve if local control, searchable screen history, and Mac or Windows support are your priorities. Do not adopt it if Linux support, verified server-side deployment, or a fully documented rollback process is mandatory. Before installation, verify that your Python build supports sqlite3 enable_load_extension, that the operating system grants the required permissions, and that ~/.memos is stored on a path suitable for continuous screenshot writes.

## FAQ

### How do I install Pensieve on Windows or macOS?

The README gives `pip install memos` as the basic installation command, followed by `memos init`, `memos enable`, and `memos start`. On Windows, it also documents `uv tool install memos` and a `pipx` alternative for an isolated environment.

### Where does Pensieve store screenshots?

The README states that initialization stores data in `~/.memos`. On Windows, it warns that a redirected `%USERPROFILE%` may cause screenshots to sync through OneDrive and recommends changing `base_dir` in `~/.memos/config.yaml` to a local, non-synced path.

### Does Pensieve support Linux?

No completed Linux support is documented. The README lists Mac and Windows as supported and says Linux support is in development.

### Can Pensieve search screenshots with AI models?

Yes, according to the README. Pensieve integrates with Ollama and supports OpenAI API-compatible models such as OpenAI, Azure OpenAI, and vLLM, alongside full-text and vector search.

## Sources

- [arkohut/pensieve on GitHub](https://github.com/arkohut/pensieve)
- [Issues](https://github.com/arkohut/pensieve/issues)
- [License: Apache-2.0](https://github.com/arkohut/pensieve/blob/master/LICENSE)
- [README](https://github.com/arkohut/pensieve/blob/master/README.md)
- [Releases](https://github.com/arkohut/pensieve/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/arkohut-pensieve