# MineContext: a local-first desktop agent that turns screenshots into proactive summaries

> MineContext is an Electron and Python desktop app from volcengine that captures screenshots, stores them locally, and pushes daily and weekly summaries, tips and todos back to your home screen. The architecture is interesting; the packaging and the model dependency are the parts to check before you commit.

**volcengine/MineContext** — MineContext is your proactive context-aware AI partner（Context-Engineering+ChatGPT Pulse）

- Repository: https://github.com/volcengine/MineContext
- Stars: 5,533 · Forks: 415
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/volcengine-minecontext

## What MineContext actually captures, and who it is for

The README describes MineContext as a proactive context-aware AI partner. The mechanism it starts from is screen capture plus content comprehension. The application watches what you do on screen, sends that material through a processing pipeline, and then delivers back what it calls insights, daily and weekly summaries, to-do lists, and activity records. The repository topics list vision-language-model, embedding-models, vector-database and rag, which matches that description: images go in, embeddings and retrieved context come out.

The target user is someone whose work lives in a browser and a handful of desktop apps, and who wants a written record of the day without keeping notes. The README's own framing is clarity from chaos, and the four features it lists are collection, resurfacing, proactive delivery, and a context engineering architecture. The last one matters more than the marketing wording: the project claims to cover capture, processing, storage, management, retrieval and consumption, and to generate six types of intelligent context. That is a pipeline claim, not a single feature.

It is not a note-taking app and it is not a general assistant you prompt. The README's comparison section positions it against ChatGPT Pulse and Dayflow, both of which are also proactive rather than chat-first. If you want to ask questions about your files, this is not the shape of tool you are looking for.

## How the capture, storage and retrieval pipeline is put together

Two processes are visible in the repository layout. The frontend directory holds an Electron application, and the opencontext package holds the Python backend. The pyproject.toml entry point registers opencontext = "opencontext.cli:main", so the backend can be started on its own from the command line, separate from the packaged app.

The dependency list tells you the shape of the pipeline. Screenshots come from mss, images are handled with pillow, and imagehash is present, which suggests near-duplicate frames are filtered before they reach a model. Text and documents are handled by pypdf, pypdfium2, python-docx and openpyxl. Retrieval runs on chromadb and qdrant-client, two vector stores rather than one. Model access goes through the openai client plus the volcengine SDK, and playwright is a dependency, which points at web content being fetched or rendered somewhere in the processing path. FastAPI and uvicorn serve the backend, and jinja2 plus json-repair handle prompt templating and malformed model output.

The examples directory mirrors that pipeline stage by stage: example_screenshot_processor.py, example_document_processor.py, example_weblink_processor.py, example_screenshot_to_insights.py, example_todo_deduplication.py, verify_folder_monitor.py and regenerate_debug_file.py. If you want to understand the data flow before running the app, those files are the shortest path. json-repair being a dependency is itself informative: the pipeline expects structured model output and has a repair step for when a model returns something close but not valid.

## Installing MineContext and getting one summary out of it

The README gives two installation paths. For the packaged application, download the release build for your platform from the GitHub releases page. Starting from v0.1.8 the assets are MineContext-0.1.8.dmg for Mac and MineContext-0.1.8-setup.exe for Windows. The README notes that from v0.1.5 onward the Mac build is notarized, so the quarantine attribute no longer has to be removed by hand; older versions need the instructions in the 0.1.4 README.

The README states that the first run installs the backend environment and may take about two minutes. After that, the application asks for an API key. Supported providers are Doubao, OpenAI, and custom models, including any local or third-party service that speaks the OpenAI API format. The README recommends LMStudio for local models and, on cost and performance grounds, recommends the Doubao model.

If you would rather run the backend yourself, the pyproject.toml exposes a console script. Install the package from the repository root and start the server:

```bash
pip install -e .
opencontext
```

The README's backend section covers installation, configuration and running the server, and the configuration lives under the config directory in the repository root. The application stores its data locally at this path by default:

```
~/Library/Application Support/MineContext/Data
```

Before trusting a full day of capture, point the app at one screen and confirm that a summary appears on the home screen. The README's own quick start sequence ends with forget it, which is the intended mode of use: you configure it once and stop interacting with it deliberately.

The project also ships a hook-opencontext.py file and an opencontext.spec for packaging, which are the integration points if you want MineContext invoked from another tool rather than launched by hand.

## The model dependency is the real cost of running MineContext

MineContext is local-first in storage, not in computation. The README is explicit that all data is stored locally by default, and that custom model services based on the OpenAI API protocol are supported so that data does not leave your environment. Those are two separate claims, and the second one only holds if you actually run a local model.

In practice, the screenshot pipeline needs a vision-capable model. The README recommends Doubao, which is a hosted API key generated in the volcengine console, and it recommends LMStudio for local inference. A local vision model large enough to read screenshots and produce structured JSON needs real hardware, and the README does not state any minimum specification. If your machine cannot run one, the local-first privacy claim degrades to local storage with remote inference, and every screenshot you take becomes an outbound request.

There is a second constraint in the dependency list. json-repair is present because model output is parsed as structured data. A model that is good at describing an image but unreliable at emitting the expected JSON will produce repaired, partial or discarded results. The README does not document what happens when the repair step fails, and it does not document a fallback path. That is the failure mode to test first: run the app against your intended model and watch whether summaries actually appear, rather than assuming any OpenAI-compatible endpoint will do.

## Platform coverage and the state of the project

The download links in the README cover macOS and Windows only. There is no Linux build listed, and the repository does not describe one. If your team is standardized on Linux desktops, MineContext is not usable as a packaged application, and the Python backend alone does not give you the capture layer.

The version history is short. The releases list v0.1.6, v0.1.7 and v0.1.8, with v0.1.8 published on 2026-01-28. The last push to the default branch was on 2026-05-07, which is more than four months before today. The repository is not archived, but that gap means you should treat the code as it stands rather than expect fixes on a short cycle. The pyproject.toml classifier says Development Status :: 4 - Beta, and the project version there is 0.1.0, which does not match the release tags. That kind of drift is normal in a young project and also a sign that the packaging metadata is not the priority.

One more thing worth noting for anyone planning to build on it: the README links to a related project, OpenViking, described as an open-source context database for AI agents. MineContext is the application; OpenViking is the infrastructure layer. If your actual goal is to build context management into your own agent, the application is not the piece you want.

## How MineContext differs from ChatGPT Pulse and Dayflow

The README compares MineContext with two other proactive tools, and the comparison is the most useful part of the documentation because it makes the architectural difference explicit.

ChatGPT Pulse is a hosted feature inside ChatGPT. Its capture and its inference both live on OpenAI's side, and you get the summaries through that product. MineContext takes the opposite approach on storage: the screenshots and the derived data stay in a local directory, and the model endpoint is configurable, including a local one. The trade-off is that you supply and pay for inference, and you maintain the application yourself. Pulse asks nothing of you beyond a subscription; MineContext asks for a model key and a machine that can run the app.

Dayflow is closer in shape, since it is also a desktop recorder, but the README positions MineContext around its context engineering architecture rather than around the recording itself. The concrete difference visible in the repository is the pipeline breadth: documents, web links and spreadsheets have their own example processors alongside screenshots, and the storage layer supports two vector databases. Whether that breadth is realized in the shipped build is something the README asserts and the examples illustrate, but it is a claim about the framework rather than about what a new user sees on day one.

## Licence, upgrade cost and what to check before rolling it out

MineContext is licensed under Apache-2.0, stated both in the LICENSE file and in the pyproject.toml metadata. That is a permissive licence with a patent grant and no copyleft obligation on your own code, which matters if you intend to modify the backend for internal use. It does not settle the question of the model you connect to it: a hosted provider's terms apply to whatever you send it, and the README's local-first claim covers storage, not inference. This is a description of the licence, not legal advice.

Upgrade cost is currently low because the release cadence is slow and the surface is small. The application bundles its own backend environment, so upgrading means replacing the app rather than resolving Python dependencies yourself. The risk sits in the data directory. The README gives the default local path but does not document a migration step between versions, and it does not document rollback. Before upgrading, copy ~/Library/Application Support/MineContext/Data somewhere else, because nothing in the documentation promises that an older build can read data written by a newer one.

The repository includes a SECURITY.md and a CONTRIBUTING.md, and the README points at issue reporting and a feedback form. If you are evaluating it for a team rather than for yourself, the thing to verify first is the model endpoint, since that is the part you will have to support.

## Conclusion

MineContext fits people who work long sessions on a Mac or Windows machine, want a local record of their day, and are willing to supply an OpenAI-compatible model endpoint, either a hosted Doubao key or a local server such as LMStudio. Skip it if you need Linux support, if you cannot run a vision model locally or pay for one, or if you expect a stable plugin API today. Before adopting, verify three things: that the first-run backend environment install completes on your machine, that your chosen model endpoint accepts images and returns the JSON the pipeline expects, and that the data directory at ~/Library/Application Support/MineContext/Data is where your screenshots actually land. The project is a beta at v0.1.8, and the opencontext CLI entry point exposes the backend directly, so the fastest way to judge it is to run that server and watch what the processing pipeline does with one screenshot before you trust it with a full day.

## FAQ

### What is MineContext?

It is an open-source, proactive context-aware AI partner from volcengine. It captures screenshots and other context, processes them through a context engineering pipeline, and delivers insights, daily and weekly summaries, to-do lists and activity records to your home screen. The repository describes it as a desktop application with an Electron frontend and a Python backend.

### How do I install MineContext on Windows or Mac?

Download the release build from the GitHub releases page: MineContext-0.1.8.dmg for Mac or MineContext-0.1.8-setup.exe for Windows. The README states that the first run installs the backend environment and may take about two minutes, after which the app asks for an API key. From v0.1.5 the Mac build is notarized, so the quarantine attribute does not need to be removed.

### Does MineContext require an API key or can it run fully locally?

It requires a model endpoint either way. The README says Doubao, OpenAI and custom OpenAI-compatible services are supported, and recommends LMStudio for running local models. Storage is local by default at ~/Library/Application Support/MineContext/Data, but the README does not state minimum hardware for local vision inference.

### Where does MineContext store my data?

By default all data is stored locally at ~/Library/Application Support/MineContext/Data, according to the README's privacy section. The README does not document a migration or rollback path for that directory between versions.

## Sources

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

---

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