PMB - local-first persistent memory for Cursor (MCP, no cloud, no API keys)

Showcase Built for Cursor
,
1

Cursor forgets everything between sessions, so you keep re-explaining the same decisions, lessons and project context. I built PMB to fix that: a local-first memory that lives in SQLite on your machine and feeds the right context back to the agent over MCP. No cloud, no API keys, no LLM call on the read path.

dashboard-map
dashboard-map1918×911 154 KB

Your project’s memory, visualized - entities and connections captured automatically as you work.

:link: GitHub: GitHub - oleksiijko/pmb: Local-first persistent memory for AI coding agents (Claude Code, Cursor, Codex) over MCP. Decisions, lessons and facts live in one SQLite file on your disk. Offline, multilingual. · GitHub
:link: Site: https://pmbai.dev

:sparkles: What it does

  • Remembers decisions, lessons (“we use X, never Y”), personal facts, project structure, even PDFs - across restarts, model switches and agent switches.
  • Hybrid recall (BM25 + vectors + entity graph) in ~35 ms warm; writes return in under a millisecond.
  • Multilingual out of the box - a Russian query finds an English fact, no per-language setup.
  • Honest about impact: a local dashboard shows which lessons actually changed outcomes, instead of claiming “+X%”.

:electric_plug: Using it with Cursor

Cursor is MCP-native, so wiring it is one command:

pip install pmb-ai
pmb connect cursor      # adds the MCP server + appends the read-first rules
pmb warmup              # preload the model so the first recall is instant

Cursor has no lifecycle hooks (unlike Claude Code), so on Cursor PMB works two ways: the agent calls recall() / prepare() itself (the rules pmb connect writes nudge it to), and a git observer captures the write side automatically:

pmb ambient-watch .     # journals your work as you edit, no manual record step
pmb dashboard           # local web UI: graph, timeline, lessons (127.0.0.1 only)

dashboard-timeline
dashboard-timeline1918×911 138 KB

Timeline - everything the agent did and learned, newest first.

:locked: Why local-first

The whole workspace is a folder under ~/.pmb/. 100% offline, zero telemetry, secrets auto-redacted at write time. Copy it to a USB stick, sync it, or push the encrypted bundle to a public repo - your call. Apache-2.0.

Would love feedback from Cursor users - especially on the MCP-only ambient-write flow. Happy to answer anything in the thread. :star: if it saves you a re-explanation.

1 Like
3

The local-first part is the most interesting bit to me.

For coding agents, memory only becomes useful if it can be inspected, corrected, and moved with the project. A SQLite file plus MCP feels closer to that than a hidden cloud memory layer, especially if the dashboard can show which facts actually changed a later decision.

1 Like
5

This is the thesis exactly. The gamble here is that the unopenable, unfixed, unmovable memory is not actually yours – thus a simple SQLite file readable by anything, the local dashboard allows to see/fix/forget any of the facts, and pmb workspace export (git-sync) includes this memory with the codebase.

The part you left at the end of your comment is the one that interests me the most. The dashboard does not just list the facts; it shows which lessons were revealed to be important and followed by the agent, allowing to see how well a rule is doing its job (and remove rules that never made a difference). “Did this particular fact make a difference in future decisions” is the entire premise of my adherence chart.

1 Like
6

It gives me an error when trying to start the webui dashboard:

C:\Windows\System32>pmb dashboard
┌───────────────────────────────────────── Traceback (most recent call last) ─────────────────────────────────────────┐
│ C:\Users\XXXX\AppData\Local\Programs\Python\Python312\Lib\site-packages\pmb\cli\commands\capture.py:74 in       │
│ dashboard                                                                                                           │
│                                                                                                                     │
│    71 │   │   import threading                                                                                      │
│    72 │   │   import webbrowser                                                                                     │
│    73 │   │   threading.Timer(1.2, lambda: webbrowser.open(f"http://{host}:{port}")).start()                        │
│ >  74 │   run_dashboard(eng, host=host, port=port)                                                                  │
│    75                                                                                                               │
│    76                                                                                                               │
│    77 @app.command()                                                                                                │
│                                                                                                                     │
│ C:\Users\XXXX\AppData\Local\Programs\Python\Python312\Lib\site-packages\pmb\dashboard\server.py:778 in          │
│ run_dashboard                                                                                                       │
│                                                                                                                     │
│   775 def run_dashboard(engine, host: str = "127.0.0.1", port: int = 8765) -> None:                                 │
│   776 │   """Blocking - runs until KeyboardInterrupt."""                                                            │
│   777 │   handler = make_handler(engine)                                                                            │
│ > 778 │   server = ThreadingHTTPServer((host, port), handler)                                                       │
│   779 │   print(f"PMB dashboard at http://{host}:{port}")                                                           │
│   780 │   print(f"Workspace: {engine.workspace.name} ({engine.workspace.id})")                                      │
│   781 │   print("Press Ctrl+C to stop.")                                                                            │
│                                                                                                                     │
│ C:\Users\XXXX\AppData\Local\Programs\Python\Python312\Lib\socketserver.py:457 in __init__                       │
│                                                                                                                     │
│   454 │   │   │   │   │   │   │   │   │   self.socket_type)                                                         │
│   455 │   │   if bind_and_activate:                                                                                 │
│   456 │   │   │   try:                                                                                              │
│ > 457 │   │   │   │   self.server_bind()                                                                            │
│   458 │   │   │   │   self.server_activate()                                                                        │
│   459 │   │   │   except:                                                                                           │
│   460 │   │   │   │   self.server_close()                                                                           │
│                                                                                                                     │
│ C:\Users\XXXX\AppData\Local\Programs\Python\Python312\Lib\http\server.py:136 in server_bind                     │
│                                                                                                                     │
│    133 │                                                                                                            │
│    134 │   def server_bind(self):                                                                                   │
│    135 │   │   """Override server_bind to store the server name."""                                                 │
│ >  136 │   │   socketserver.TCPServer.server_bind(self)                                                             │
│    137 │   │   host, port = self.server_address[:2]                                                                 │
│    138 │   │   self.server_name = socket.getfqdn(host)                                                              │
│    139 │   │   self.server_port = port                                                                              │
│                                                                                                                     │
│ C:\Users\XXXX\AppData\Local\Programs\Python\Python312\Lib\socketserver.py:478 in server_bind                    │
│                                                                                                                     │
│   475 │   │   │   and self.address_family in (socket.AF_INET, socket.AF_INET6)                                      │
│   476 │   │   ):                                                                                                    │
│   477 │   │   │   self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)                                 │
│ > 478 │   │   self.socket.bind(self.server_address)                                                                 │
│   479 │   │   self.server_address = self.socket.getsockname()                                                       │
│   480 │                                                                                                             │
│   481 │   def server_activate(self):                                                                                │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
PermissionError: [WinError 10013] An attempt was made to access a socket in a way forbidden by its access permissions

C:\Windows\System32>

Would have been nice with some built-in way to configure “pmb ambient-watch .” targets and run those in one command rather then spawning multiple command windows (and inevitably forgetting some of them on restart)

7

Hey, try to start on other port like pmb dashboard --port 4444

And overall thanks for idea and bug, will add to my list !

8

Yeah that seem to start the UI, but there are no events or any data in it from the looks of it. I have a watch running that have observed changes, but still nothing anywhere.

Seems interesting, but this tool is really not for me in the current state I think, I just want to run max 1 command to have things running, or alternatively just double click an icon.

9

Thanks for trying it and for the honest feedback. That’s fair.

If the UI starts but shows no events while watch says it observed changes, that’s exactly the kind of onboarding gap I need to fix. PMB should make it obvious which workspace is active, what is being watched, how many events were captured, and why the dashboard is empty if nothing was stored.

And I agree with the “one command” point. The goal should be closer to pmb start: daemon, watch, and dashboard running together, with a clear status screen. A desktop/icon flow would also make sense later.

Really appreciate you calling this out. The memory idea only works if the first-run experience is boringly simple.