MemoLens

Inspiration

We were inspired by a simple but frustrating problem: most people already have a huge personal photo library, but turning that library into something useful still takes too much manual effort. You scroll through folders, compare similar shots, try to remember where a photo came from, and then still have to write the caption yourself.

We wanted to build a tool that feels more like a desktop creative assistant than a file browser. Instead of making users dig through images one by one, MemoLens helps them search a local photo library in natural language, surface the strongest images, and shape those results into something they can actually use.

What it does

MemoLens is a desktop-oriented AI photo curation app for local image libraries.

Users can select a folder of photos, build a local index, and then describe what they want in plain English. MemoLens interprets the prompt, searches the indexed library, pulls the strongest matches, curates a tighter set, and generates a polished title, caption, and notes.

It also keeps the workflow resilient:

• if the backend is online, it runs real retrieval against the indexed library
• if the backend is offline, the UI falls back to a local mock curation flow so the product still feels usable

That makes MemoLens feel like a real desktop product instead of a fragile demo.

How we built it

We built MemoLens as a hybrid local desktop stack:

• Electron provides the desktop shell and access to local folders
• React + Vite + TypeScript power the UI
• Flask provides backend routes for health checks, indexing, retrieval, and file serving
• SQLite stores the local image index and metadata
• AI planning and copy generation turn natural-language intent into structured search and post-ready writing

The Electron layer handles desktop-specific behavior such as:

• picking a local image folder
• starting indexing runs
• pausing and resuming indexing
• tracking progress
• storing indexed image records in a local SQLite database

The backend handles image indexing and retrieval APIs. It processes images into searchable records with metadata like filenames, descriptions, tags, dates, locations, and embeddings. The frontend then calls those APIs, maps the results into a curated visual draft, and displays the selected images with generated editorial copy.

A big part of the product was making the system feel guided rather than opaque, so the interface exposes the steps of interpretation, search, curation, and draft preparation instead of hiding everything behind a single loading spinner.

Challenges we ran into

One challenge was balancing a local-first desktop experience with AI-powered retrieval. We wanted the product to work with real personal photo folders, but that meant dealing with local paths, local database storage, indexing jobs, and platform-specific desktop issues.

Another challenge was making the result feel curated instead of merely relevant. A normal search system can return matching files, but creators do not want a pile of matches. They want a small set that feels intentional and publishable.

We also ran into desktop-specific engineering issues:

• handling folder selection and database path management cleanly
• building progress reporting for long indexing runs
• supporting pause and resume behavior
• dealing with Electron sandbox constraints on Linux development environments
• keeping the UI usable even when the backend is unreachable

Accomplishments that we're proud of

We are proud that MemoLens already behaves like a real product and not just a search prototype.

It can:

• select a real local image folder
• build and maintain a local image index
• query that index with natural-language prompts
• return real image results through the backend
• generate a curated draft with title, caption, and notes
• keep functioning with a fallback flow when live retrieval is unavailable

We are also proud of the architecture. The Electron shell, frontend UI, backend service, and indexing logic are clearly separated, which gives the project room to grow into a more complete desktop application.

Most importantly, we are proud that the product framing is strong: MemoLens is not just about finding photos, but about helping users turn a messy library into something ready to share.

What we learned

We learned that local AI products live or die on trust and responsiveness. Users are much more willing to use AI on personal media when the workflow stays grounded in their own files and when the app clearly shows what it is doing.

We also learned that retrieval alone is not enough. The useful experience comes from combining:

• search
• curation
• sequencing
• copy generation

In other words, the value is not just “find me photos,” but “help me turn these photos into a finished draft.”

We also learned that building desktop AI software introduces a very different set of constraints from a browser-only app. File access, runtime environment, indexing progress, and local storage all become first-class product concerns.

What's next for MemoLens

Next, we want to make MemoLens feel even more like a true local creative copilot.

Our next steps are:

• moving more query orchestration into the frontend-side desktop boundary
• adding stronger local filtering and reranking
• improving export and copy workflows
• making indexing and search session state more robust
• packaging the app more cleanly for desktop distribution
• moving default storage into the app's user-data directory for production builds
• expanding the curation workflow from “search and draft” into a fuller photo management and creator workflow

Long term, we want MemoLens to become the layer between a personal photo archive and a finished piece of content: local, private, searchable, and much more useful than a raw folder of files.

Built With

• ai-image-retrieval
• along-with-pytorch-and-hugging-face-transformers-for-embedding-based-retrieval.-on-the-model-side
• and-flask-+-python-for-the-backend-api-and-indexing-pipeline.-we-used-sqlite-as-the-local-database
• and-nomic-text-embeddings
• clip
• css
• dinov2
• electron
• electron-for-the-desktop-shell
• embeddings
• flask
• html
• hugging-face-transformers
• local-first-desktop-app
• minimax-api
• nomic-embed
• openai-api
• openstreetmap-nominatim
• photon
• python
• pytorch
• react
• reverse
• sql
• sqlite
• the-project-uses-dinov2
• typescript
• vite