@LEOM

It is OVER!
Shipping!
What a project man- I am sure I’ll actually use this. Maybe my second ship could be an integration with ALEXA/Google Home to have a physical assistant? I’d keep an eye out for that, but for now, this is my first ship!

Hey again :D
Quick update: MemoryMap is now basically done.
All core systems are in place and working together as expected. The full pipeline from camera input → detection → merging → storage → query is stable. I also went through the remaining edge cases that were causing inconsistent object histories, especially around duplicate merges and stale updates.
Most of the time this session was spent on tightening things up instead of adding new features. That included cleaning logs, fixing a few timing issues in the frame handler, and making sure the memory store stays consistent under continuous input. The system now holds up under longer runs without breaking state or losing tracked objects.
The query layer is also in a usable state. You can ask questions like where an object was last seen and get a reliable answer based on stored history, not just the latest frame. That part took a bit of tuning to make responses consistent.
Right now I’m not planning any more big changes. The project is in final testing mode. I’m running longer sessions across different rooms to check stability, accuracy, and performance under real use.
Next step is just validation and small fixes if anything shows up during testing.
Feels good to see it reach this stage.

Hey again :D

This one was less about fixing bugs and more about actually building out the pipeline.

MemoryMap is now split into separate modules instead of everything being stuffed together. The project currently consists of:

frame_reader.py: receives and processes incoming video frames
detector.py: handles object detection
handler.py: coordinates detections and memory updates
store.py: persistent memory storage
object_record.py: object history tracking
merge.py: combines duplicate observations
main.py: starts and manages everything

The biggest addition this session was the detection pipeline itself.

Previously, I had the memory system working, but there wasn’t really a complete path from camera feed → object detection → stored memory. That’s now connected together. Frames arrive, detections are produced, records are updated, and the information is written into MemoryStore automatically.

I also started work on observation merging. One issue with object tracking is that the same object can appear multiple times across different frames, creating fragmented records. The merge layer now attempts to consolidate those observations into a single memory entry, making the stored data much cleaner and more useful when querying later.

Another thing I spent time on was restructuring the codebase. It doesn’t sound exciting, but getting clear separation between frame capture, detection, storage, and record management will make future work much easier. Debugging individual components is already significantly simpler.

The project is starting to look less like a prototype and more like an actual system!

Next steps are improving location accuracy, expanding object history tracking, and building the query layer so MemoryMap can start answering natural questions such as:

“Where did I leave my headphones?”

or

“When was the last time the wallet was seen?”

Still a lot to build, but the foundations are finally coming together.

More soon. 🚀

Hello :D
Firstly, I did say I wanted to update both object_record.py and get everything running. Done and done.

In object_record.py, the function “update()” would overwrite the history before saving it, thus creating just one history per object, which isn’t much when we need to know when and how objects have been moved. This is now fixed, while main.py was facing a circular importing error, which has now been sorted out too.

And here comes the fun part: Phone camera integration!
Originally, we were going to use a webcam for recording purposes. It will work fine on a desk but what about the other areas of the house? Well, there is always the phone! Simply go from room to room pointing it at the surroundings for 10 seconds.

Now the server has an additional WebSocket receiver listening at port 8001. Start by entering on phone, use the URL displayed to connect to the web server with your phone, and just the web browser, no special app required; use Safari or Chrome. It starts sending video feeds through Wi-Fi straight from your phone’s rear camera. Added a location label field so that each location gets labeled as you scan it. No longer will the results say “somewhere left of centre frame,” instead they’ll now read “kitchen”.

Switched from using YOLOv8 to YOLOv10. Main improvement with v10? None other than the complete removal of non-maximum suppression post-processing. No duplicates, even better for a system like ours which relies heavily on memory. Good trade-off.

Completed 28 tests, all successful. Memory layer is ready to go.

The thing powers up, retains data, you walk around your house, and you get answers. Basic functionality is there. Now, everything else is about polish.

More details soon.

Hey, welcome to the first devlog for MemoryMap!

I’ve been wanting to build this for a while and I finally started with this perfect opportunity!

Fair warning: this is very much a “day one” post, things are rough, bugs, and not everything compiles :/

So what is MemoryMap?
You know that feeling when you’re late and you can’t find your keys or your wallet and you wish your house could just tell you where they are? That’s the whole idea. Point a camera at your space (either through “memory” or persistent view), let the system watch continuously and build a memory of where objects are, then ask it questions, like “where are my headphones?” and get an instant answer based on the last time they were actually seen. No more searching the same three spots over and over.

The core of the project: store.py, the MemoryStore class. This is the memory layer everything else will depend on.
It handles three things.

1. Ingestion: every camera frame hands in a list of detections, and the store either updates an existing record or creates a new one, all thread-safe.

2. Staleness: objects don’t vanish when they leave frame, they get marked stale after a configurable number of hours, so last-known location is always preserved.

3. Persistence: a background thread periodically flushes everything to disk as JSON, atomically obviously, so memory survives restarts.

The other two files (object_record.py and main.py) are started but still buggy. They’ll get their moment in a future devlog.

Next up: fix object_record.py and get the whole thing to actually boot :D