personal-brain 0.1.0__py3-none-any.whl

personal_brain/__init__.py

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

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/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()

personal_brain/export_shortlists.py

@@ -0,0 +1,297 @@
+"""Ranked shortlists from the FalkorDB graph: co-hosts & sponsors, podcast guests, places to speak.
+
+Each list is a few Cypher queries plus a transparent score, so every row says
+why it ranks where it does. Writes data/viewer/shortlists.json (for
+shortlists.html) and one CSV per list in data/viewer/shortlists/.
+
+    personal-brain export --cloud
+"""
+
+import csv
+import json
+import os
+import re
+import sys
+from collections import defaultdict
+from datetime import date
+from pathlib import Path
+
+from falkordb import FalkorDB
+
+from personal_brain.load_graph import norm
+
+from personal_brain.paths import HOME, cloud_url
+OUT = Path(os.environ.get("PB_VIEWER_DIR", HOME / "data" / "viewer"))
+SETTINGS = HOME / "my_brain.json"
+TOP = 60
+
+SENIOR_RE = re.compile(r"\b(founder|co-?founder|ceo|cto|chief|head of|vp|vice president|director|principal"
+                       r"|staff|distinguished|partner|professor|research scientist|lead)\b", re.I)
+ORG_RE = re.compile(r"\b(summit|conference|conf|meetup|meetups|club|community|hackathon|hackathons|ted"
+                    r"|developer groups?|gdg|circle|society|festival|collective|guild|events|forum"
+                    r"|week|hacks)\b", re.I)
+NOT_ORG_RE = re.compile(r"\b(software|university|college|student|students|career|design|school)\b", re.I)
+ORGANIZER_RE = re.compile(r"\b(organi[sz]er|co-?organi[sz]er|curator|chapter lead|host|community lead"
+                          r"|head of community|community manager|events? (lead|manager|director))\b", re.I)
+TALK_RE = re.compile(r"\b(talks?|panel|meetup|lightning|demo|tech talk|summit|conference|conf|workshop"
+                     r"|forum|unconference|showcase|fireside|seminar|lecture|keynote|speakers?)\b", re.I)
+SOCIAL_RE = re.compile(r"\b(dinner|happy hour|party|drinks|brunch|mixer|golf|run club|yoga|pop-up"
+                       r"|retreat|picnic|karaoke)\b", re.I)
+EVENT_TOPIC_POINTS = {"Agent Memory": 3, "Knowledge Graphs": 3, "RAG & Search": 2, "AI Agents": 1.5,
+                      "Developer Relations": 1, "LLMs & GenAI": 0.5}
+# Big tech hosts many events but rarely co-hosts with a startup: listed, but ranked lower.
+BIG_TECH = {"google", "meta", "facebook", "microsoft", "apple", "nvidia", "amazon", "amazon web services aws",
+            "ibm", "salesforce", "oracle", "github", "intel", "linkedin"}
+GUEST_TOPIC_POINTS = {"Agent Memory": 3, "Knowledge Graphs": 2, "AI Agents": 1, "RAG & Search": 1,
+                      "LLMs & GenAI": 0.5}
+
+
+def connect():
+    if "--cloud" in sys.argv:
+        return FalkorDB.from_url(cloud_url()), "FalkorDB Cloud"
+    return FalkorDB(host="localhost", port=6379), "local FalkorDB"
+
+
+def competitors():
+    """Companies you would not co-host with (my_brain.json "competitors"), normalized."""
+    s = json.loads(SETTINGS.read_text()) if SETTINGS.exists() else {}
+    return {norm(c) for c in s.get("competitors", [])}
+
+
+def main():
+    db, where = connect()
+    g = db.select_graph(os.environ.get("PB_GRAPH", "network"))
+    q = lambda cypher, **params: g.query(cypher, params).result_set
+    today = date.today()
+    since = f"{today.year - 1}-01-01"
+    rivals = competitors()
+
+    # ---------- facts about people ----------
+    people = {}
+    for pid, name, headline, title, company, url, messages, lead in q(
+            "MATCH (:Me)-[:CONNECTED]->(p:Person) RETURN p.id, p.name, p.headline, p.title, p.company,"
+            " p.url, p.messages, p.event_contact"):
+        people[pid] = {"id": pid, "name": name, "headline": headline or "", "title": title or "",
+                       "company": company or "", "url": url or "", "messages": messages or 0,
+                       "lead": bool(lead), "topics": set(), "city": "", "employers": [], "hosts": []}
+    for pid, topic in q("MATCH (p:Person)-[:INTO]->(t:Topic) RETURN p.id, t.name"):
+        if pid in people:
+            people[pid]["topics"].add(topic)
+    for pid, city in q("MATCH (p:Person)-[:LIVES_IN]->(c:City) RETURN p.id, c.name"):
+        if pid in people:
+            people[pid]["city"] = city
+    for pid, cid, cname, wf, title in q(
+            "MATCH (p:Person)-[w:WORKED_AT {current:true}]->(c:Company)"
+            " RETURN p.id, c.id, c.name, c.well_funded, w.title"):
+        if pid in people:
+            people[pid]["employers"].append({"id": cid, "name": cname, "well_funded": bool(wf),
+                                             "title": title or ""})
+    graph_years = dict(q("MATCH (p:Person)-[x:HAS_EXPERIENCE]->(:Skill {id:'graph databases'})"
+                         " RETURN p.id, x.years"))
+    met_recently = defaultdict(int)
+    for pid, in q("MATCH (p:Person)-[:MET_AT]->(e:Event) WHERE e.date >= $since RETURN p.id", since=since):
+        met_recently[pid] += 1
+    mine = {cid for cid, in q("MATCH (:Me)-[:WORKED_AT]->(c:Company) RETURN c.id")}
+
+    # ---------- upcoming events and how they link to you ----------
+    events = {}
+    for eid, name, day, time, url, guests, hosts, venue, blurb in q(
+            "MATCH (e:Event {upcoming:true}) RETURN e.id, e.name, e.date, e.time, e.url, e.guests,"
+            " e.hosts, e.venue, e.blurb"):
+        events[eid] = {"id": eid, "name": name, "date": day, "time": time, "url": url, "guests": guests or 0,
+                       "hosts": hosts or "", "venue": venue or "", "blurb": blurb or "", "topics": [],
+                       "host_people": [], "host_companies": []}
+    for eid, topic in q("MATCH (e:Event {upcoming:true})-[:ABOUT]->(t:Topic) RETURN e.id, t.name"):
+        events[eid]["topics"].append(topic)
+    for eid, pid in q("MATCH (e:Event {upcoming:true})-[:HOSTED_BY]->(p:Person) RETURN e.id, p.id"):
+        events[eid]["host_people"].append(pid)
+        if pid in people:
+            people[pid]["hosts"].append(eid)
+    hosted_by_company = defaultdict(list)
+    for eid, cid, cname, via in q("MATCH (e:Event {upcoming:true})-[h:HOSTED_BY]->(c:Company)"
+                                  " RETURN e.id, c.id, c.name, h.via"):
+        events[eid]["host_companies"].append({"id": cid, "name": cname, "via": via})
+        hosted_by_company[cid].append(eid)
+
+    staff = defaultdict(list)   # company id -> your connections working there now
+    for p in people.values():
+        for emp in p["employers"]:
+            staff[emp["id"]].append(p)
+
+    def best_contact(company_id):
+        """The event/community lead you message most there, else anyone you message most."""
+        ps = sorted(staff[company_id], key=lambda p: (not p["lead"], -p["messages"]))
+        return ps[0] if ps else None
+
+    def short_date(day):
+        return date.fromisoformat(day).strftime("%b %d")
+
+    # ---------- 1. co-hosts & sponsors ----------
+    companies = {}
+    for cid, name, wf, funding, employees, industries in q(
+            "MATCH (c:Company) RETURN c.id, c.name, c.well_funded, c.funding, c.employees, c.industries"):
+        if cid in staff and cid not in mine and cid not in rivals:
+            companies[cid] = (name, bool(wf), funding or "", employees or "", industries or "")
+    cohosts = []
+    for cid, (name, wf, funding, employees, industries) in companies.items():
+        ps = staff[cid]
+        leads = [p for p in ps if p["lead"]]
+        hosted = sorted(set(hosted_by_company[cid]), key=lambda e: events[e]["date"])
+        met = sum(1 for p in ps if met_recently[p["id"]])
+        ai = sum(1 for p in ps if p["topics"] & {"AI Agents", "Agent Memory", "Knowledge Graphs", "RAG & Search"})
+        big = cid in BIG_TECH
+        score = (3 * min(len(hosted), 3) + 3 * wf + 2 * min(len(leads), 2) + 0.5 * min(len(ps), 5)
+                 + min(met, 3) + (1 if ai >= 2 else 0) - 4 * big)
+        if not (hosted or wf or leads or met):
+            continue
+        why = ["big tech"] if big else []
+        if hosted:
+            why.append(f"hosts {len(hosted)} upcoming event{'s' * (len(hosted) > 1)}")
+        if wf:
+            why.append(f"well-funded ({funding})" if funding else "well-funded")
+        if leads:
+            why.append(f"{len(leads)} event/community lead{'s' * (len(leads) > 1)} you know")
+        why.append(f"{len(ps)} connection{'s' * (len(ps) > 1)} there")
+        if met:
+            why.append(f"met {met} of them at events since {today.year - 1}")
+        contact = best_contact(cid)
+        cohosts.append({
+            "score": round(score, 1), "company": name, "why": " · ".join(why),
+            "contact": contact["name"], "contact_title": contact["headline"][:90],
+            "contact_url": contact["url"], "contact_messages": contact["messages"],
+            "events": "; ".join(f"{short_date(events[e]['date'])} {events[e]['name']}" for e in hosted[:3]),
+            "funding": funding, "people": employees})
+    cohosts.sort(key=lambda r: -r["score"])
+
+    # ---------- 2. podcast guests ----------
+    guests = []
+    for p in people.values():
+        topic_pts = sum(GUEST_TOPIC_POINTS.get(t, 0) for t in p["topics"])
+        if not p["topics"] & {"Agent Memory", "Knowledge Graphs", "AI Agents", "RAG & Search"}:
+            continue
+        if any(e["id"] in mine for e in p["employers"]):   # your own coworkers
+            continue
+        role = f"{p['title']} {p['headline']}"
+        senior = bool(SENIOR_RE.search(role))
+        funded = next((e["name"] for e in p["employers"] if e["well_funded"]), "")
+        yrs = graph_years.get(p["id"], 0)
+        score = (topic_pts + 2 * senior + ("Podcast & Media" in p["topics"]) + (p["city"] == "SF Bay Area")
+                 + bool(p["hosts"]) + (p["messages"] > 0) + bool(funded) + (yrs >= 1))
+        why = [", ".join(t for t in GUEST_TOPIC_POINTS if t in p["topics"])]
+        if senior:
+            why.append("senior")
+        if yrs >= 1:
+            why.append(f"{yrs:g} yrs graph databases")
+        if "Podcast & Media" in p["topics"]:
+            why.append("already does podcasts/media")
+        if p["hosts"]:
+            why.append(f"hosts {events[p['hosts'][0]]['name'][:40]}")
+        if funded:
+            why.append(f"at {funded} (well-funded)")
+        if p["city"] == "SF Bay Area":
+            why.append("in SF")
+        guests.append({"score": round(score, 1), "name": p["name"], "headline": p["headline"][:110],
+                       "company": p["employers"][0]["name"] if p["employers"] else p["company"],
+                       "city": p["city"], "why": " · ".join(why),
+                       "warmth": f"{p['messages']} messages" if p["messages"] else "connected, no messages yet",
+                       "url": p["url"]})
+    guests.sort(key=lambda r: -r["score"])
+
+    # ---------- 3a. upcoming events to speak at ----------
+    speak = []
+    for e in events.values():
+        topic_pts = sum(EVENT_TOPIC_POINTS.get(t, 0) for t in e["topics"])
+        host_people = [people[pid] for pid in e["host_people"] if pid in people]
+        host_cos = [c for c in e["host_companies"] if c["id"] in staff and c["id"] not in mine]
+        rival = any(c["id"] in rivals for c in e["host_companies"])
+        days = (date.fromisoformat(e["date"]) - today).days
+        talk, social = bool(TALK_RE.search(e["name"])), bool(SOCIAL_RE.search(e["name"]))
+        score = (topic_pts + 3 * bool(host_people) + 2 * bool(host_cos)
+                 + any(best_contact(c["id"])["lead"] for c in host_cos)
+                 + talk - social + (e["guests"] >= 150) - (days < 10) - 4 * rival)
+        if not (topic_pts or host_people or host_cos) or rival or days < 3:   # under 3 days: too late
+            continue
+        if host_people:
+            ask = f"ask {host_people[0]['name']} (host, your connection)"
+        elif host_cos:
+            c = max(host_cos, key=lambda c: best_contact(c["id"])["lead"])
+            ask = f"ask {best_contact(c['id'])['name']} at {c['name']} ({c['via']})"
+        else:
+            ask = "cold: message the host on Luma"
+        why = [", ".join(t for t in EVENT_TOPIC_POINTS if t in e["topics"]) or "AI"]
+        if talk:
+            why.append("has talks/demos")
+        if social:
+            why.append("social, few talk slots")
+        if e["guests"] >= 150:
+            why.append(f"{e['guests']} going")
+        if days < 10:
+            why.append("soon: ask now or skip")
+        speak.append({"score": round(score, 1), "date": e["date"], "event": e["name"], "why": " · ".join(why),
+                      "ask": ask, "hosts": e["hosts"][:120], "guests": e["guests"], "url": e["url"]})
+    speak.sort(key=lambda r: (-r["score"], r["date"]))
+
+    # ---------- 3b. organizers you know (recurring stages) ----------
+    organizers = []
+    for p in people.values():
+        orgs = [e for e in p["employers"] if ORG_RE.search(e["name"]) and not NOT_ORG_RE.search(e["name"])]
+        role = " ".join([p["title"], p["headline"]] + [e["title"] for e in p["employers"]])
+        organizing = bool(ORGANIZER_RE.search(role))
+        if not (orgs or (organizing and p["lead"])):
+            continue
+        ai = bool(p["topics"] & {"AI Agents", "Agent Memory", "Knowledge Graphs", "RAG & Search", "LLMs & GenAI"})
+        score = (2 * bool(orgs) + 2 * organizing + 2 * bool(p["hosts"]) + ai
+                 + (p["city"] == "SF Bay Area") + (p["messages"] > 0))
+        why = []
+        if orgs:
+            why.append(f"runs/works at {orgs[0]['name']}")
+        if organizing:
+            why.append("organizer role")
+        if p["hosts"]:
+            why.append(f"hosts {events[p['hosts'][0]]['name'][:40]} ({short_date(events[p['hosts'][0]]['date'])})")
+        if ai:
+            why.append("into AI")
+        if p["city"] == "SF Bay Area":
+            why.append("in SF")
+        if p["messages"]:
+            why.append(f"{p['messages']} messages")
+        organizers.append({"score": score, "name": p["name"], "headline": p["headline"][:110],
+                           "org": (orgs[0]["name"] if orgs else p["employers"][0]["name"] if p["employers"]
+                                   else p["company"]),
+                           "city": p["city"], "why": " · ".join(why), "url": p["url"]})
+    organizers.sort(key=lambda r: -r["score"])
+
+    lists = {
+        "cohosts": {"title": "Co-hosts & sponsors", "rows": cohosts[:TOP], "total": len(cohosts),
+                    "note": "Companies where you know people, ranked by: hosts upcoming AI events (3 each, max 3) "
+                            "+ well-funded (3) + event/community leads you know (2 each, max 2) + connections "
+                            "(0.5 each, max 5) + people met at events (1 each, max 3) + AI team (1)."},
+        "guests": {"title": "Podcast guests", "rows": guests[:TOP], "total": len(guests),
+                   "note": "Connections into agents, memory, graphs or RAG, ranked by topic (Agent Memory 3, "
+                           "Knowledge Graphs 2, AI Agents 1, RAG 1) + senior (2) + 1 each for: graph DB years, "
+                           "does podcasts, hosts events, at a well-funded startup, in SF, you have messaged."},
+        "speak": {"title": "Upcoming events to speak at", "rows": speak[:TOP], "total": len(speak),
+                  "note": "Upcoming SF Luma events, ranked by topic (Agent Memory 3, Knowledge Graphs 3, RAG 2, "
+                          "AI Agents 1.5) + host is your connection (3) + you know people at the host company (2, "
+                          "+1 if an event lead) + talks (1) − social only (1) + 150+ going (1) − under 10 days (1)."},
+        "organizers": {"title": "Organizers you know", "rows": organizers[:TOP], "total": len(organizers),
+                       "note": "People at conferences, meetups and communities, or with organizer roles. Recurring "
+                               "stages: ask them for a slot at the next one."},
+    }
+    payload = {"generated": today.isoformat(), "source": where, "lists": lists}
+    (OUT / "shortlists.json").write_text(json.dumps(payload, ensure_ascii=False, indent=1))
+    (OUT / "shortlists").mkdir(exist_ok=True)
+    for key, lst in lists.items():
+        rows = lst["rows"]
+        if rows:
+            with open(OUT / "shortlists" / f"{key}.csv", "w", newline="", encoding="utf-8") as f:
+                w = csv.DictWriter(f, fieldnames=["rank"] + list(rows[0]))
+                w.writeheader()
+                w.writerows({"rank": i + 1, **r} for i, r in enumerate(rows))
+        print(f"{key:10s} {lst['total']:4d} candidates, top: "
+              + " | ".join(r.get("name") or r.get("company") or r.get("event") for r in rows[:5]))
+    print(f"wrote {OUT / 'shortlists.json'}")
+
+
+if __name__ == "__main__":
+    main()

personal_brain/export_stories.py

@@ -0,0 +1,155 @@
+"""THROWAWAY SPIKE: run the demo "story" queries on FalkorDB and save results for the viewer.
+
+Each story is a Cypher query. We store the query text, FalkorDB's run time, and
+the node ids it touched, so the viewer can light them up.
+
+    personal-brain export --cloud
+"""
+
+import json
+import os
+import sys
+from datetime import date
+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")) / "stories.json"
+
+STORIES = [
+    {
+        "id": "founders",
+        "title": "Which founders did I meet at events this year?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": f"""MATCH (me:Me)-[:ATTENDED]->(e:Event)<-[:MET_AT]-(p:Person)
+      -[:INTO]->(:Topic {{name:'Founder'}})
+WHERE e.date >= '{date.today().year}-01-01'
+RETURN id(me), id(e), id(p)""",
+        "pairs": [(0, 1), (1, 2)],
+    },
+    {
+        "id": "bigtech",
+        "title": "Who in my network works at big tech?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(p:Person)
+      -[:WORKED_AT {current:true}]->(c:Company)
+WHERE c.name IN ['Google', 'Meta', 'Microsoft', 'Apple', 'NVIDIA',
+  'Amazon', 'Amazon Web Services (AWS)', 'IBM', 'Salesforce', 'Oracle']
+RETURN id(me), id(p), id(c)""",
+        "pairs": [(0, 1), (1, 2)],
+    },
+    {
+        "id": "funded-intro",
+        "title": "Who can warm-intro me to people at well-funded startups?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(friend:Person)-[:KNOWS]-(p:Person)
+      -[:WORKED_AT {current:true}]->(c:Company {well_funded:true})
+OPTIONAL MATCH (c)-[:FUNDED_BY]->(i:Investor)
+RETURN id(me), id(friend), id(p), id(c), collect(id(i)) AS investors""",
+        "pairs": [(0, 1), (1, 2), (2, 3), (3, 4)],
+    },
+    {
+        "id": "cohosts",
+        "title": "Which startups host AI events, and who do I know there?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(p:Person)-[:WORKED_AT {current:true}]->(c:Company)
+      <-[:HOSTED_BY]-(e:Event {upcoming:true})
+WHERE NOT c.name IN ['Google', 'Meta', 'Microsoft', 'Apple', 'NVIDIA', 'Amazon',
+  'Amazon Web Services (AWS)', 'IBM', 'Salesforce', 'Oracle', 'GitHub']
+RETURN id(me), id(p), id(c), id(e)""",
+        "pairs": [(0, 1), (1, 2), (2, 3)],
+    },
+    {
+        "id": "podcast",
+        "title": "Who should I invite to my podcast on agents and memory?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(p:Person)-[:INTO]->(t:Topic)
+WHERE t.name IN ['Agent Memory', 'Knowledge Graphs', 'AI Agents', 'RAG & Search']
+  AND ANY(w IN ['founder', 'cto', 'ceo', 'chief', 'head of', 'vp', 'director',
+                'principal', 'staff', 'research'] WHERE toLower(p.headline) CONTAINS w)
+RETURN id(me), id(p), id(t)""",
+        "pairs": [(0, 1), (1, 2)],
+    },
+    {
+        "id": "speak",
+        "title": "Which upcoming agent events can I speak at through people I know?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        # Two ways in: you know the host, or you know someone at the host company.
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(p:Person)<-[:HOSTED_BY]-(e:Event {upcoming:true})
+      -[:ABOUT]->(t:Topic)
+WHERE t.name IN ['AI Agents', 'Agent Memory', 'Knowledge Graphs', 'RAG & Search']
+RETURN id(me) AS me, id(p) AS friend, id(p) AS host, id(e) AS event, id(t) AS topic
+UNION
+MATCH (me:Me)-[:CONNECTED]->(p:Person)-[:WORKED_AT {current:true}]->(c:Company)
+      <-[:HOSTED_BY]-(e:Event {upcoming:true})-[:ABOUT]->(t:Topic)
+WHERE t.name IN ['AI Agents', 'Agent Memory', 'Knowledge Graphs', 'RAG & Search']
+RETURN id(me) AS me, id(p) AS friend, id(c) AS host, id(e) AS event, id(t) AS topic""",
+        "pairs": [(0, 1), (1, 2), (2, 3), (3, 4)],
+    },
+    {
+        "id": "investors",
+        "title": "Who can warm-intro me to the investors behind OpenAI?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        # The investor firm is a Company (its people work there) and an Investor (it funds companies), same id.
+        "cypher": """MATCH (t:Company {name:'OpenAI'})-[:FUNDED_BY]->(i:Investor)
+MATCH (firm:Company {id: i.id})<-[:WORKED_AT {current:true}]-(vc:Person)-[:INTO]->(:Topic {name:'Investing'})
+MATCH (me:Me)-[:CONNECTED]->(friend:Person)-[:KNOWS]-(vc)
+WHERE friend.messages > 0
+RETURN id(me), id(friend), id(vc), id(firm), id(i), id(t)""",
+        "pairs": [(0, 1), (1, 2), (2, 3), (4, 5)],
+    },
+    {
+        "id": "executives",
+        "title": "Which founders and CEOs can I reach through people I talk to?",
+        "focus": "MATCH (m:Me) RETURN id(m)",
+        "cypher": """MATCH (me:Me)-[:CONNECTED]->(friend:Person)-[:KNOWS]-(p:Person)
+WHERE friend.messages > 0 AND p.messages = 0
+  AND ANY(w IN ['founder', 'ceo', 'chief', 'cto', 'coo', 'cfo'] WHERE toLower(p.title) CONTAINS w)
+RETURN id(me), id(friend), id(p)""",
+        "pairs": [(0, 1), (1, 2)],
+    },
+]
+
+
+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"))
+    count, max_id = g.query("MATCH (n) RETURN count(n), max(id(n))").result_set[0]
+    if count != max_id + 1:
+        sys.exit("node ids are not contiguous; viewer indices would not match FalkorDB ids")
+
+    out = []
+    for story in STORIES:
+        result = g.query(story["cypher"])
+        # A column can be a list (collect); flatten it for the lit-node set.
+        flat = lambda v: v if isinstance(v, list) else [v]
+        ids = sorted({x for row in result.result_set for v in row for x in flat(v) if x is not None})
+        # Edges to light: only the path steps, not every edge between lit nodes.
+        # Keep direction (me -> friend -> expert) so the viewer can send light pulses along it.
+        seen, pairs = set(), []
+        for row in result.result_set:
+            for a, b in story["pairs"]:
+                for x in flat(row[a]):
+                    for y in flat(row[b]):
+                        if x is not None and y is not None and x != y and (x, y) not in seen:
+                            seen.add((x, y))
+                            pairs.append([x, y])
+        focus = g.query(story["focus"]).result_set[0][0]
+        out.append({**{k: story[k] for k in ("id", "title", "cypher")},
+                    "focus": focus, "nodes": ids, "pairs": pairs, "rows": len(result.result_set),
+                    "ms": round(result.run_time_ms, 2), "source": where})
+        print(f"{story['id']:9s} rows={len(result.result_set):4d} nodes={len(ids):4d} pairs={len(pairs):4d} "
+              f"{result.run_time_ms:.2f} ms")
+    OUT.write_text(json.dumps(out, ensure_ascii=False, indent=1))
+    print(f"wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

personal_brain/layout_graph.py

@@ -0,0 +1,60 @@
+"""THROWAWAY SPIKE: precompute 2D and 3D layouts for the WebGL viewer.
+
+Reads data/viewer/graph.json (from export_graph.py), runs igraph's DrL layout
+in 2D and 3D, and writes the positions back into the same file.
+
+    personal-brain export   # runs this after export_graph
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import igraph as ig
+
+from personal_brain.paths import HOME
+GRAPH_JSON = Path(os.environ.get("PB_VIEWER_DIR", HOME / "data" / "viewer")) / "graph.json"
+RADIUS = 1000.0
+# "Me" links to everyone, which would crush the map into one ball: leave those
+# links out of the layout and put Me at the center afterwards. Skill links are
+# many and weak, so they pull less than jobs, schools and "knows" links.
+SKIP = {"CONNECTED", "ATTENDED"}
+WEIGHTS = {"HAS_SKILL": 0.2, "LIVES_IN": 0.15, "HELD_IN": 0.15}
+
+
+def normalize(coords, dims):
+    n = len(coords)
+    center = [sum(c[d] for c in coords) / n for d in range(dims)]
+    shifted = [[c[d] - center[d] for d in range(dims)] for c in coords]
+    radii = sorted(sum(v * v for v in c) ** 0.5 for c in shifted)
+    scale = RADIUS / (radii[int(n * 0.98)] or 1.0)
+    return [round(v * scale, 1) for c in shifted for v in c]
+
+
+def main():
+    data = json.loads(GRAPH_JSON.read_text())
+    types = data["types"]
+    n = len(data["nodes"])
+    kept = [(a, b, t) for a, b, t in data["edges"] if a != b and types[t] not in SKIP]
+    g = ig.Graph(n=n, edges=[(a, b) for a, b, _ in kept])
+    weights = [WEIGHTS.get(types[t], 1.0) for _, _, t in kept]
+    me = next(i for i, node in enumerate(data["nodes"]) if data["labels"][node[0]] == "Me")
+    dims_list = [int(a.split("=")[1]) for a in sys.argv if a.startswith("--dims=")] or [2, 3]
+    for dims in dims_list:
+        t0 = time.time()
+        coords = g.layout_drl(weights=weights, dim=dims).coords
+        coords[me] = [0.0] * dims  # normalize() re-centers on the mean, so set it after
+        flat = normalize(coords, dims)
+        flat[me * dims:(me + 1) * dims] = [0.0] * dims
+        data[f"pos{dims}"] = flat
+        radii = sorted(sum(v * v for v in flat[i * dims:(i + 1) * dims]) ** 0.5 for i in range(n))
+        print(f"{dims}D layout: {time.time() - t0:.1f}s, radius p10/p50/p90 = "
+              f"{radii[n // 10]:.0f}/{radii[n // 2]:.0f}/{radii[n * 9 // 10]:.0f}")
+    GRAPH_JSON.write_text(json.dumps(data, ensure_ascii=False, separators=(",", ":")))
+    print(f"wrote {GRAPH_JSON} ({GRAPH_JSON.stat().st_size / 1e6:.1f} MB)")
+
+
+if __name__ == "__main__":
+    main()