Personal Brain

Turn your LinkedIn network into a graph you can ask questions, stored in FalkorDB, and fly through it in 3D.

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

sample_data/ is a made-up network (241 invented people, startups and events) in the same file formats as a real LinkedIn export, so you can try everything before you download your own data.

python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
cp .env.example .env            # paste your FalkorDB Cloud URL into FALKORDB_URL
.venv/bin/python spike/load_graph.py --sample --cloud

A free FalkorDB Cloud instance is the fastest start. To run FalkorDB locally instead, start it with Docker and leave out --cloud:

docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest

Then open Claude Code in this folder. It finds .mcp.json and asks to start the personal-brain server. 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."

Related MCP server: Mnemosyne

Use it as your agent's memory (MCP)

spike/mcp_server.py gives your agent four tools on one graph:

Every write hangs off a Note node, so you can trace each fact to the note that made it. Claude Code reads .mcp.json. For another client, run .venv/bin/python spike/mcp_server.py (stdio) from this folder. PB_GRAPH picks the graph (default network).

Check it end to end on a throwaway graph: .venv/bin/python tests/test_memory.py --cloud.

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

Build your own

You need Python 3.10+ and FalkorDB (a free FalkorDB Cloud instance, or Docker).

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 this folder (the folder name contains LinkedInDataExport).

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.

2. Install.

python3 -m venv .venv
.venv/bin/pip install -r requirements.txt
cp .env.example .env                  # add your FALKORDB_URL
cp my_brain.example.json my_brain.json  # optional: name your events, list competitors

For local FalkorDB instead of Cloud:

docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest

Then leave out --cloud in the commands below.

3. Build the graph and the viewer data.

.venv/bin/python spike/load_graph.py --cloud
.venv/bin/python spike/export_graph.py --cloud
.venv/bin/python spike/layout_graph.py --dims=2
.venv/bin/python spike/export_stories.py --cloud
.venv/bin/python spike/export_shortlists.py --cloud

4. Open it.

./spike/serve_viewer.sh

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 spike/demo_queries.cypher.

Your data stays yours

• The LinkedIn export, everything in 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 hold real names. Share screenshots, not those files.

• The local server listens on 127.0.0.1 only and serves only data/viewer/.

Files

This is a demo-quality build made at a hackathon, not a product.

License

MIT, see LICENSE. three.js in spike/viewer/vendor/ is MIT too (its own LICENSE file).