personal-brain 0.1.0__tar.gz

personal_brain-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Private data: LinkedIn export, enriched data, secrets, your own labels
+*LinkedInDataExport*
+data/
+.env
+my_brain.json
+*.zip
+
+# Not part of the code
+slides/
+.DS_Store
+__pycache__/
+.venv/
+dist/

personal_brain-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Liz Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

personal_brain-0.1.0/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.5
+Name: personal-brain
+Version: 0.1.0
+Summary: Your LinkedIn network as agent memory in FalkorDB: MCP tools to remember, find, ask and forget, plus a 3D viewer.
+Project-URL: Homepage, https://github.com/zhang-liz/personal-brain
+Project-URL: Demo, https://zhang-liz.github.io/personal-brain/
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-memory,falkordb,knowledge-graph,linkedin,mcp
+Requires-Python: >=3.10
+Requires-Dist: falkordb==1.2.0
+Requires-Dist: igraph==0.11.8
+Requires-Dist: mcp<3,>=2.3
+Requires-Dist: redis
+Description-Content-Type: text/markdown
+
+# Personal Brain
+
+Turn your LinkedIn network into a graph you can ask questions, stored in
+[FalkorDB](https://www.falkordb.com/), and fly through it in 3D.
+
+[![Personal Brain demo: a galaxy of 19k nodes answering questions](https://raw.githubusercontent.com/zhang-liz/personal-brain/main/docs/demo.gif)](https://zhang-liz.github.io/personal-brain/)
+
+**[Try the live demo](https://zhang-liz.github.io/personal-brain/)**. All connections in it are made up, and its companies and events are only example names. To rebuild it, see `scripts/build_demo.py`.
+
+After every event you meet people. Two weeks later you forget who they were,
+what they work on, and who could introduce you to whom. Personal Brain keeps
+that memory as a graph: people, companies, schools, skills, events, topics,
+investors and cities, plus inferred "who knows whom" links.
+
+What the viewer does:
+
+- Shows your whole network as a galaxy in WebGL (tested with 19k nodes and 117k edges), with a 2D / 3D toggle.
+- **Time-lapse**: watch your network grow, connection by connection, with your events popping up.
+- **Ask the graph**: a question types itself, then its Cypher query, then the answer lights up with light pulses along the paths. Example questions:
+  - Which founders did I meet at events this year?
+  - Who in my network works at big tech?
+  - Who can warm-intro me to people at well-funded startups?
+  - Which startups host AI events, and who do I know there?
+  - Who should I invite to my podcast on agents and memory?
+  - Which upcoming agent events can I speak at through people I know?
+- **Shortlists**: ranked tables (and CSVs) of co-hosts & sponsors, podcast guests, upcoming events to speak at, and organizers you know. Every row says why it ranks there.
+- **Remember**: type "Met Maya from Supabase at AI Engineer Summit, runs developer events" and it is written to FalkorDB live and appears in the galaxy.
+- **Demo mode**: the whole show hands-free (press `D`).
+- **Agent memory (MCP)**: Claude Code, or any MCP client, can find people, ask the graph, remember who you met and forget on request.
+
+Everything runs on your laptop. The viewer works offline (three.js is vendored).
+
+## Quick start: a sample network in 5 minutes
+
+You need [uv](https://docs.astral.sh/uv/getting-started/installation/) and FalkorDB. `uvx` downloads the right Python for you.
+
+The made-up sample network has 241 invented people, startups and events, in the same file formats as a real LinkedIn export. You can try everything before you download your own data.
+
+**1. Start FalkorDB.** Run it in Docker, or see [FalkorDB Cloud](#falkordb-cloud):
+
+```bash
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+```
+
+**2. Load the sample, and add the server to Claude Code:**
+
+```bash
+uvx personal-brain load --sample
+claude mcp add personal-brain -- uvx personal-brain mcp
+```
+
+Try:
+
+- "Who in my network works at Kestrel Graph?"
+- "Who could introduce me to someone at a well-funded startup?"
+- "I met Oskar Mensah at the Graph & RAG Meetup. He's building agent memory." (There are two Oskar Mensahs, so it asks which one.)
+- "Forget that note."
+
+**Other MCP clients:** use command `uvx`, arguments `personal-brain mcp` (stdio).
+
+### FalkorDB Cloud
+
+A free [FalkorDB Cloud](https://app.falkordb.cloud/) instance works without Docker. Pass its URL to the server, and add `--cloud` to `load` and `export`:
+
+```bash
+export FALKORDB_URL='falkors://user:password@host:port'
+uvx personal-brain load --sample --cloud
+claude mcp add personal-brain -e FALKORDB_URL="$FALKORDB_URL" -- uvx personal-brain mcp
+```
+
+Or put `FALKORDB_URL=...` in `~/.personal-brain/.env`.
+
+## Use it as your agent's memory (MCP)
+
+`uvx personal-brain mcp` gives your agent four tools on one graph:
+
+| Tool | What it does |
+|---|---|
+| `remember` | Saves who you met, where they work and where you met. Matches the name to people already in the graph. When it is not sure which person you mean, it saves nothing and asks. A new company ends the old job and keeps it in the history. |
+| `find` | Finds people, companies and events by name, in any script, typos and missing accents included. |
+| `ask` | Runs a read-only Cypher query (FalkorDB refuses writes), with a 5 second limit and at most 50 rows. The tool description carries the schema. |
+| `forget` | Forgets one note and everything it added, one relationship, or one person. A forgotten person stays out of future rebuilds. |
+
+Every write hangs off a `Note` node, so you can trace each fact to the note that made it. `PB_GRAPH` picks the graph (default `network`). If FalkorDB is not running, the server still starts, and each tool says how to start it. Windows is not tested.
+
+## How it works
+
+```
+LinkedIn data export ──┐
+                       ├─> load_graph.py ──> FalkorDB ──┬─> mcp_server.py ──> your agent
+data/enriched/ ────────┘   (graph "network")            ├─> export_graph.py ──> layout_graph.py ──> viewer
+(optional)                                              ├─> export_stories.py, export_shortlists.py ──> viewer
+                                                        └─> server.py (live "Remember" API) ──> viewer
+```
+
+1. **Your LinkedIn export** gives connections (with the date you connected), your messages (only counts are used, never text), your posts, jobs and schools.
+2. **Optional files in `data/enriched/`** add each connection's full job history, schools and skills, company funding, and upcoming events. They use the JSON format of `sample_data/enriched/`. This repo has no tool to collect them; everything works without them.
+3. **load_graph.py** builds the graph and infers:
+   - `KNOWS` between two connections who worked at the same company or studied at the same school for 3+ months at the same time (at big schools, same start year only), who work at the same company now (when there is no job history), or who are in the same group chat.
+   - `Event` nodes: days when you added 5+ connections are probably events. Name them in `my_brain.json`.
+   - `Topic` interests (AI agents, agent memory, knowledge graphs, founders, investors, podcasts…) from headlines and skills.
+   - With enriched files only:
+     - Years of experience per technology from job titles and descriptions.
+     - `well_funded` startups: private, active, at most 5,000 people, and a Series round or 8+ investors.
+     - `City` from each profile's location, at metro level ("Berlin Metropolitan Area" and "Berlin" are one city; Palo Alto and San Jose are "SF Bay Area").
+     - Who hosts each upcoming event: a host who is your connection (LinkedIn match), or a company where you know people (host is the company, a host works there, or the title names it, like "Notion x Clover").
+4. **export_graph.py + layout_graph.py** export the graph to JSON and compute a 2D layout (igraph DrL). In 3D, each node type sits on its own layer.
+5. **export_stories.py** runs the "Ask the graph" Cypher queries on FalkorDB and saves the answers and timings for the viewer.
+6. **export_shortlists.py** ranks co-hosts, podcast guests and places to speak with a simple score you can read and change.
+
+### Graph schema
+
+| Nodes | Edges |
+|---|---|
+| `Me`, `Person`, `Company`, `School`, `Skill`, `Topic`, `Event`, `Investor`, `City`, `Note` | `(Me)-[:CONNECTED]->(Person)`, `(Person)-[:WORKED_AT {title, start, end, current}]->(Company)`, `(Person)-[:STUDIED_AT]->(School)`, `(Person)-[:HAS_SKILL]->(Skill)`, `(Person)-[:HAS_EXPERIENCE {years}]->(Skill)`, `(Person)-[:INTO]->(Topic)`, `(Person)-[:KNOWS {via, place}]-(Person)`, `(Me)-[:ATTENDED]->(Event)`, `(Person)-[:MET_AT]->(Event)`, `(Company)-[:FUNDED_BY {lead, round}]->(Investor)`, `(Person)-[:LIVES_IN]->(City)`, `(Event {upcoming})-[:HOSTED_BY {via}]->(Person or Company)`, `(Event)-[:ABOUT]->(Topic)`, `(Event)-[:HELD_IN]->(City)`, `(Me)-[:MET]->(Person)` and `(Me)-[:WROTE]->(Note)-[:ABOUT]->(Person)` (from Remember) |
+
+## Build your own
+
+**1. Get your LinkedIn data.** LinkedIn > Settings > Data privacy > Get a copy of your data.
+Two choices:
+
+- **Connections only**: usually ready in about 10 minutes. You get people, their current company and title, and the day you connected. That is enough for the graph, events and the agent tools.
+- **Download larger data archive**: ready in about a day. It adds your messages (only counts are used), posts, jobs and schools.
+
+Unzip it into `~/.personal-brain` (the folder name contains `LinkedInDataExport`). `personal-brain --help` shows your data folder. To use another folder, set `PB_HOME`.
+
+**Or start empty.** Skip the import. The MCP server creates you in an empty graph, and the graph grows as you tell your agent who you met.
+
+Optional: copy [`my_brain.example.json`](my_brain.example.json) to `~/.personal-brain/my_brain.json` to name your events and list competitors.
+
+**2. Build the graph and the viewer data.** Add `--cloud` to both when you use FalkorDB Cloud:
+
+```bash
+uvx personal-brain load
+uvx personal-brain export
+```
+
+**3. Open it.**
+
+```bash
+uvx personal-brain view
+```
+
+Open http://127.0.0.1:8765 (shortlists: http://127.0.0.1:8765/shortlists.html). Keys: `2` / `3` switch views, `T` time-lapse, `B` big bang, `D` demo, `Esc` reset.
+
+To explore in the FalkorDB Browser instead, see `docs/demo_queries.cypher`.
+
+## Work on the code
+
+You need Python 3.10 or newer, [uv](https://docs.astral.sh/uv/getting-started/installation/) and Docker. In a clone, your data folder is the clone itself, and Claude Code reads `.mcp.json` from any folder inside it.
+
+```bash
+git clone https://github.com/zhang-liz/personal-brain && cd personal-brain
+python3 -m venv .venv && .venv/bin/pip install -e .
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+```
+
+Then, in another terminal, run the tests. They use throwaway graphs:
+
+```bash
+.venv/bin/python tests/test_memory.py       # the memory tools (add --cloud to use FALKORDB_URL)
+.venv/bin/python tests/test_mcp_server.py   # the server, started the way an agent starts it
+.venv/bin/python tests/test_package.py      # the built package, used from another folder
+```
+
+## Your data stays yours
+
+- Your data stays in `~/.personal-brain`, outside the package. Only you can open that folder. In a clone, the export, `data/`, `.env` and `my_brain.json` are in `.gitignore`. Never commit them.
+- Message text is never read into the graph, only how many messages you exchanged with each person.
+- `data/viewer/graph.json` and the shortlists in your data folder hold real names. Share screenshots, not those files.
+- The local server listens on `127.0.0.1` only and serves only `data/viewer/`.
+
+## Files
+
+| Path | What it does |
+|---|---|
+| `src/personal_brain/cli.py` | The `personal-brain` command |
+| `src/personal_brain/paths.py` | Where your data folder is |
+| `src/personal_brain/load_graph.py` | Builds the FalkorDB graph and all inferred links |
+| `src/personal_brain/export_graph.py` | Exports every node and edge to `data/viewer/graph.json` |
+| `src/personal_brain/layout_graph.py` | Precomputes the layout |
+| `src/personal_brain/export_stories.py` | The "Ask the graph" questions and their Cypher |
+| `src/personal_brain/export_shortlists.py` | Ranked shortlists: co-hosts & sponsors, podcast guests, places to speak |
+| `src/personal_brain/viewer/shortlists.html` | The shortlists page (filter, download CSV) |
+| `src/personal_brain/server.py` | Serves the viewer and the live Remember / Forget API |
+| `src/personal_brain/memory.py` | The memory itself: remember, find, ask, forget (used by the MCP server and the viewer) |
+| `src/personal_brain/mcp_server.py` | The MCP server for Claude Code and other agents |
+| `.mcp.json` | Tells Claude Code how to start the MCP server in a clone |
+| `tests/` | End-to-end checks of the memory tools, the MCP server and the built package, on throwaway graphs |
+| `src/personal_brain/sample_data/` | The made-up sample network |
+| `scripts/make_sample_data.py` | Writes `sample_data/` |
+| `src/personal_brain/viewer/index.html` | The WebGL viewer (three.js r170, MIT, vendored) |
+| `docs/demo_queries.cypher` | Queries to paste into the FalkorDB Browser |
+
+This is a demo-quality build made at a hackathon, not a product.
+
+## License
+
+MIT, see [LICENSE](LICENSE). three.js in `src/personal_brain/viewer/vendor/` is MIT too (its own LICENSE file).

personal_brain-0.1.0/README.md

@@ -0,0 +1,199 @@
+# Personal Brain
+
+Turn your LinkedIn network into a graph you can ask questions, stored in
+[FalkorDB](https://www.falkordb.com/), and fly through it in 3D.
+
+[![Personal Brain demo: a galaxy of 19k nodes answering questions](https://raw.githubusercontent.com/zhang-liz/personal-brain/main/docs/demo.gif)](https://zhang-liz.github.io/personal-brain/)
+
+**[Try the live demo](https://zhang-liz.github.io/personal-brain/)**. All connections in it are made up, and its companies and events are only example names. To rebuild it, see `scripts/build_demo.py`.
+
+After every event you meet people. Two weeks later you forget who they were,
+what they work on, and who could introduce you to whom. Personal Brain keeps
+that memory as a graph: people, companies, schools, skills, events, topics,
+investors and cities, plus inferred "who knows whom" links.
+
+What the viewer does:
+
+- Shows your whole network as a galaxy in WebGL (tested with 19k nodes and 117k edges), with a 2D / 3D toggle.
+- **Time-lapse**: watch your network grow, connection by connection, with your events popping up.
+- **Ask the graph**: a question types itself, then its Cypher query, then the answer lights up with light pulses along the paths. Example questions:
+  - Which founders did I meet at events this year?
+  - Who in my network works at big tech?
+  - Who can warm-intro me to people at well-funded startups?
+  - Which startups host AI events, and who do I know there?
+  - Who should I invite to my podcast on agents and memory?
+  - Which upcoming agent events can I speak at through people I know?
+- **Shortlists**: ranked tables (and CSVs) of co-hosts & sponsors, podcast guests, upcoming events to speak at, and organizers you know. Every row says why it ranks there.
+- **Remember**: type "Met Maya from Supabase at AI Engineer Summit, runs developer events" and it is written to FalkorDB live and appears in the galaxy.
+- **Demo mode**: the whole show hands-free (press `D`).
+- **Agent memory (MCP)**: Claude Code, or any MCP client, can find people, ask the graph, remember who you met and forget on request.
+
+Everything runs on your laptop. The viewer works offline (three.js is vendored).
+
+## Quick start: a sample network in 5 minutes
+
+You need [uv](https://docs.astral.sh/uv/getting-started/installation/) and FalkorDB. `uvx` downloads the right Python for you.
+
+The made-up sample network has 241 invented people, startups and events, in the same file formats as a real LinkedIn export. You can try everything before you download your own data.
+
+**1. Start FalkorDB.** Run it in Docker, or see [FalkorDB Cloud](#falkordb-cloud):
+
+```bash
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+```
+
+**2. Load the sample, and add the server to Claude Code:**
+
+```bash
+uvx personal-brain load --sample
+claude mcp add personal-brain -- uvx personal-brain mcp
+```
+
+Try:
+
+- "Who in my network works at Kestrel Graph?"
+- "Who could introduce me to someone at a well-funded startup?"
+- "I met Oskar Mensah at the Graph & RAG Meetup. He's building agent memory." (There are two Oskar Mensahs, so it asks which one.)
+- "Forget that note."
+
+**Other MCP clients:** use command `uvx`, arguments `personal-brain mcp` (stdio).
+
+### FalkorDB Cloud
+
+A free [FalkorDB Cloud](https://app.falkordb.cloud/) instance works without Docker. Pass its URL to the server, and add `--cloud` to `load` and `export`:
+
+```bash
+export FALKORDB_URL='falkors://user:password@host:port'
+uvx personal-brain load --sample --cloud
+claude mcp add personal-brain -e FALKORDB_URL="$FALKORDB_URL" -- uvx personal-brain mcp
+```
+
+Or put `FALKORDB_URL=...` in `~/.personal-brain/.env`.
+
+## Use it as your agent's memory (MCP)
+
+`uvx personal-brain mcp` gives your agent four tools on one graph:
+
+| Tool | What it does |
+|---|---|
+| `remember` | Saves who you met, where they work and where you met. Matches the name to people already in the graph. When it is not sure which person you mean, it saves nothing and asks. A new company ends the old job and keeps it in the history. |
+| `find` | Finds people, companies and events by name, in any script, typos and missing accents included. |
+| `ask` | Runs a read-only Cypher query (FalkorDB refuses writes), with a 5 second limit and at most 50 rows. The tool description carries the schema. |
+| `forget` | Forgets one note and everything it added, one relationship, or one person. A forgotten person stays out of future rebuilds. |
+
+Every write hangs off a `Note` node, so you can trace each fact to the note that made it. `PB_GRAPH` picks the graph (default `network`). If FalkorDB is not running, the server still starts, and each tool says how to start it. Windows is not tested.
+
+## How it works
+
+```
+LinkedIn data export ──┐
+                       ├─> load_graph.py ──> FalkorDB ──┬─> mcp_server.py ──> your agent
+data/enriched/ ────────┘   (graph "network")            ├─> export_graph.py ──> layout_graph.py ──> viewer
+(optional)                                              ├─> export_stories.py, export_shortlists.py ──> viewer
+                                                        └─> server.py (live "Remember" API) ──> viewer
+```
+
+1. **Your LinkedIn export** gives connections (with the date you connected), your messages (only counts are used, never text), your posts, jobs and schools.
+2. **Optional files in `data/enriched/`** add each connection's full job history, schools and skills, company funding, and upcoming events. They use the JSON format of `sample_data/enriched/`. This repo has no tool to collect them; everything works without them.
+3. **load_graph.py** builds the graph and infers:
+   - `KNOWS` between two connections who worked at the same company or studied at the same school for 3+ months at the same time (at big schools, same start year only), who work at the same company now (when there is no job history), or who are in the same group chat.
+   - `Event` nodes: days when you added 5+ connections are probably events. Name them in `my_brain.json`.
+   - `Topic` interests (AI agents, agent memory, knowledge graphs, founders, investors, podcasts…) from headlines and skills.
+   - With enriched files only:
+     - Years of experience per technology from job titles and descriptions.
+     - `well_funded` startups: private, active, at most 5,000 people, and a Series round or 8+ investors.
+     - `City` from each profile's location, at metro level ("Berlin Metropolitan Area" and "Berlin" are one city; Palo Alto and San Jose are "SF Bay Area").
+     - Who hosts each upcoming event: a host who is your connection (LinkedIn match), or a company where you know people (host is the company, a host works there, or the title names it, like "Notion x Clover").
+4. **export_graph.py + layout_graph.py** export the graph to JSON and compute a 2D layout (igraph DrL). In 3D, each node type sits on its own layer.
+5. **export_stories.py** runs the "Ask the graph" Cypher queries on FalkorDB and saves the answers and timings for the viewer.
+6. **export_shortlists.py** ranks co-hosts, podcast guests and places to speak with a simple score you can read and change.
+
+### Graph schema
+
+| Nodes | Edges |
+|---|---|
+| `Me`, `Person`, `Company`, `School`, `Skill`, `Topic`, `Event`, `Investor`, `City`, `Note` | `(Me)-[:CONNECTED]->(Person)`, `(Person)-[:WORKED_AT {title, start, end, current}]->(Company)`, `(Person)-[:STUDIED_AT]->(School)`, `(Person)-[:HAS_SKILL]->(Skill)`, `(Person)-[:HAS_EXPERIENCE {years}]->(Skill)`, `(Person)-[:INTO]->(Topic)`, `(Person)-[:KNOWS {via, place}]-(Person)`, `(Me)-[:ATTENDED]->(Event)`, `(Person)-[:MET_AT]->(Event)`, `(Company)-[:FUNDED_BY {lead, round}]->(Investor)`, `(Person)-[:LIVES_IN]->(City)`, `(Event {upcoming})-[:HOSTED_BY {via}]->(Person or Company)`, `(Event)-[:ABOUT]->(Topic)`, `(Event)-[:HELD_IN]->(City)`, `(Me)-[:MET]->(Person)` and `(Me)-[:WROTE]->(Note)-[:ABOUT]->(Person)` (from Remember) |
+
+## Build your own
+
+**1. Get your LinkedIn data.** LinkedIn > Settings > Data privacy > Get a copy of your data.
+Two choices:
+
+- **Connections only**: usually ready in about 10 minutes. You get people, their current company and title, and the day you connected. That is enough for the graph, events and the agent tools.
+- **Download larger data archive**: ready in about a day. It adds your messages (only counts are used), posts, jobs and schools.
+
+Unzip it into `~/.personal-brain` (the folder name contains `LinkedInDataExport`). `personal-brain --help` shows your data folder. To use another folder, set `PB_HOME`.
+
+**Or start empty.** Skip the import. The MCP server creates you in an empty graph, and the graph grows as you tell your agent who you met.
+
+Optional: copy [`my_brain.example.json`](my_brain.example.json) to `~/.personal-brain/my_brain.json` to name your events and list competitors.
+
+**2. Build the graph and the viewer data.** Add `--cloud` to both when you use FalkorDB Cloud:
+
+```bash
+uvx personal-brain load
+uvx personal-brain export
+```
+
+**3. Open it.**
+
+```bash
+uvx personal-brain view
+```
+
+Open http://127.0.0.1:8765 (shortlists: http://127.0.0.1:8765/shortlists.html). Keys: `2` / `3` switch views, `T` time-lapse, `B` big bang, `D` demo, `Esc` reset.
+
+To explore in the FalkorDB Browser instead, see `docs/demo_queries.cypher`.
+
+## Work on the code
+
+You need Python 3.10 or newer, [uv](https://docs.astral.sh/uv/getting-started/installation/) and Docker. In a clone, your data folder is the clone itself, and Claude Code reads `.mcp.json` from any folder inside it.
+
+```bash
+git clone https://github.com/zhang-liz/personal-brain && cd personal-brain
+python3 -m venv .venv && .venv/bin/pip install -e .
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+```
+
+Then, in another terminal, run the tests. They use throwaway graphs:
+
+```bash
+.venv/bin/python tests/test_memory.py       # the memory tools (add --cloud to use FALKORDB_URL)
+.venv/bin/python tests/test_mcp_server.py   # the server, started the way an agent starts it
+.venv/bin/python tests/test_package.py      # the built package, used from another folder
+```
+
+## Your data stays yours
+
+- Your data stays in `~/.personal-brain`, outside the package. Only you can open that folder. In a clone, the export, `data/`, `.env` and `my_brain.json` are in `.gitignore`. Never commit them.
+- Message text is never read into the graph, only how many messages you exchanged with each person.
+- `data/viewer/graph.json` and the shortlists in your data folder hold real names. Share screenshots, not those files.
+- The local server listens on `127.0.0.1` only and serves only `data/viewer/`.
+
+## Files
+
+| Path | What it does |
+|---|---|
+| `src/personal_brain/cli.py` | The `personal-brain` command |
+| `src/personal_brain/paths.py` | Where your data folder is |
+| `src/personal_brain/load_graph.py` | Builds the FalkorDB graph and all inferred links |
+| `src/personal_brain/export_graph.py` | Exports every node and edge to `data/viewer/graph.json` |
+| `src/personal_brain/layout_graph.py` | Precomputes the layout |
+| `src/personal_brain/export_stories.py` | The "Ask the graph" questions and their Cypher |
+| `src/personal_brain/export_shortlists.py` | Ranked shortlists: co-hosts & sponsors, podcast guests, places to speak |
+| `src/personal_brain/viewer/shortlists.html` | The shortlists page (filter, download CSV) |
+| `src/personal_brain/server.py` | Serves the viewer and the live Remember / Forget API |
+| `src/personal_brain/memory.py` | The memory itself: remember, find, ask, forget (used by the MCP server and the viewer) |
+| `src/personal_brain/mcp_server.py` | The MCP server for Claude Code and other agents |
+| `.mcp.json` | Tells Claude Code how to start the MCP server in a clone |
+| `tests/` | End-to-end checks of the memory tools, the MCP server and the built package, on throwaway graphs |
+| `src/personal_brain/sample_data/` | The made-up sample network |
+| `scripts/make_sample_data.py` | Writes `sample_data/` |
+| `src/personal_brain/viewer/index.html` | The WebGL viewer (three.js r170, MIT, vendored) |
+| `docs/demo_queries.cypher` | Queries to paste into the FalkorDB Browser |
+
+This is a demo-quality build made at a hackathon, not a product.
+
+## License
+
+MIT, see [LICENSE](LICENSE). three.js in `src/personal_brain/viewer/vendor/` is MIT too (its own LICENSE file).

personal_brain-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "personal-brain"
+dynamic = ["version"]
+description = "Your LinkedIn network as agent memory in FalkorDB: MCP tools to remember, find, ask and forget, plus a 3D viewer."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+keywords = ["mcp", "falkordb", "knowledge-graph", "agent-memory", "linkedin"]
+dependencies = [
+    "falkordb==1.2.0",
+    "igraph==0.11.8",
+    "mcp>=2.3,<3",
+    "redis",
+]
+
+[project.urls]
+Homepage = "https://github.com/zhang-liz/personal-brain"
+Demo = "https://zhang-liz.github.io/personal-brain/"
+
+[project.scripts]
+personal-brain = "personal_brain.cli:main"
+
+[tool.hatch.version]
+path = "src/personal_brain/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/personal_brain"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "README.md", "LICENSE", "pyproject.toml"]

personal_brain-0.1.0/src/personal_brain/__init__.py

@@ -0,0 +1,3 @@
+"""Personal Brain: your LinkedIn network as agent memory in FalkorDB."""
+
+__version__ = "0.1.0"

personal_brain-0.1.0/src/personal_brain/cli.py

@@ -0,0 +1,52 @@
+"""The personal-brain command."""
+
+import importlib
+import sys
+
+from personal_brain import __version__
+from personal_brain.paths import HOME
+
+USAGE = f"""personal-brain {__version__}: your LinkedIn network as agent memory in FalkorDB.
+
+Commands:
+  mcp                      run the MCP server for your agent (stdio)
+  load [--sample] [--cloud] [--force]
+                           build the graph from your LinkedIn export, or from the made-up sample
+  export [--cloud]         write the viewer's data from the graph
+  view                     open the viewer's server on http://127.0.0.1:8765
+
+Your data folder: {HOME}
+"""
+
+
+def run(module, *args):
+    """Each module reads its options from sys.argv, some of them on import."""
+    sys.argv = [f"personal-brain {module}", *args]
+    importlib.import_module(f"personal_brain.{module}").main()
+
+
+def main():
+    command, args = (sys.argv[1], sys.argv[2:]) if len(sys.argv) > 1 else ("", [])
+    if command == "--version":
+        print(f"personal-brain {__version__}")
+    elif command in ("mcp", "load", "export", "view"):
+        HOME.mkdir(parents=True, exist_ok=True, mode=0o700)
+        if command == "mcp":
+            run("mcp_server", *args)
+        elif command == "load":
+            run("load_graph", *args)
+        elif command == "view":
+            run("server", *args)
+        else:
+            run("export_graph", *args)
+            run("layout_graph", "--dims=2")
+            run("export_stories", *args)
+            run("export_shortlists", *args)
+    elif command in ("", "-h", "--help", "help"):
+        print(USAGE)
+    else:
+        sys.exit(f"Unknown command: {command}\n\n{USAGE}")
+
+
+if __name__ == "__main__":
+    main()

personal_brain-0.1.0/src/personal_brain/export_graph.py

@@ -0,0 +1,95 @@
+"""THROWAWAY SPIKE: export the whole FalkorDB graph to JSON for the WebGL viewer.
+
+Reads every node and edge, in pages (FalkorDB Cloud caps results at 10k rows),
+and writes data/viewer/graph.json (gitignored: it has real names).
+
+    personal-brain export           # local Docker FalkorDB
+    personal-brain export --cloud   # FALKORDB_URL from the environment or .env
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+from falkordb import FalkorDB
+
+from personal_brain.paths import HOME, cloud_url
+OUT = Path(os.environ.get("PB_VIEWER_DIR", HOME / "data" / "viewer")) / "graph.json"
+PAGE = 500  # node ids per page
+CAP = 10000  # FalkorDB Cloud result-set cap
+
+
+def connect():
+    if "--cloud" in sys.argv:
+        return FalkorDB.from_url(cloud_url()), "FalkorDB Cloud"
+    return FalkorDB(host="localhost", port=6379), "local FalkorDB"
+
+
+def main():
+    db, where = connect()
+    g = db.select_graph(os.environ.get("PB_GRAPH", "network"))
+    t0 = time.time()
+    max_id = g.query("MATCH (n) RETURN max(id(n))").result_set[0][0]
+
+    def edge_page(lo, hi):
+        rows = g.query("MATCH (a)-[r]->(b) WHERE id(a) >= $lo AND id(a) < $hi"
+                       " RETURN id(a), id(b), type(r) ORDER BY id(r) LIMIT $cap",
+                       {"lo": lo, "hi": hi, "cap": CAP}).result_set
+        if len(rows) < CAP:
+            return rows
+        if hi - lo == 1:
+            # One node with more edges than a result can hold (you, with 10k+ connections).
+            skip = 0
+            while len(rows) % CAP == 0 and len(rows) == skip + CAP:
+                skip += CAP
+                rows += g.query("MATCH (a)-[r]->(b) WHERE id(a) = $lo RETURN id(a), id(b), type(r)"
+                                " ORDER BY id(r) SKIP $skip LIMIT $cap", {"lo": lo, "skip": skip, "cap": CAP}).result_set
+            return rows
+        mid = (lo + hi) // 2
+        return edge_page(lo, mid) + edge_page(mid, hi)
+
+    nodes, edges = {}, []
+    for lo in range(0, max_id + 1, PAGE):
+        params = {"lo": lo, "hi": lo + PAGE}
+        for nid, label, name, sub, when in g.query(
+                "MATCH (n) WHERE id(n) >= $lo AND id(n) < $hi"
+                " RETURN id(n), labels(n)[0], n.name, coalesce(n.headline, n.title, n.funding, n.summary, ''),"
+                " coalesce(n.connected_on, n.date, '')",
+                params).result_set:
+            nodes[nid] = [label, name or "", sub or "", when or ""]
+        edges += [tuple(row) for row in edge_page(lo, lo + PAGE)]
+
+    total = g.query("MATCH ()-[r]->() RETURN count(r)").result_set[0][0]
+    if total != len(edges):
+        sys.exit(f"exported {len(edges)} edges but graph has {total}")
+
+    # Re-index nodes 0..n-1 for the viewer's typed arrays.
+    ids = sorted(nodes)
+    index = {nid: i for i, nid in enumerate(ids)}
+    labels = sorted({n[0] for n in nodes.values()})
+    types = sorted({e[2] for e in edges})
+    degree = [0] * len(ids)
+    for a, b, _ in edges:
+        degree[index[a]] += 1
+        degree[index[b]] += 1
+
+    data = {
+        "source": where,
+        "labels": labels,
+        "types": types,
+        # node: [labelIndex, name, subtitle, degree, when (connected_on / event date)]
+        "nodes": [[labels.index(nodes[n][0]), nodes[n][1], nodes[n][2][:120], degree[index[n]],
+                   nodes[n][3]] for n in ids],
+        # edge: [sourceIndex, targetIndex, typeIndex]
+        "edges": [[index[a], index[b], types.index(t)] for a, b, t in edges],
+    }
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(data, ensure_ascii=False, separators=(",", ":")))
+    print(f"exported from {where}: {len(ids)} nodes, {len(edges)} edges "
+          f"in {time.time() - t0:.1f}s -> {OUT} ({OUT.stat().st_size / 1e6:.1f} MB)")
+
+
+if __name__ == "__main__":
+    main()