Build a Personal Knowledge Graph

Met with Sarah yesterday to discuss the API migration. She recommended 
we look at GraphQL instead of REST for the new service. Alex disagreed 
but said he'd review the benchmarks.

Extract entities (people, projects, tools, concepts) and relationships
from this note. Return as JSON triples.

{
  "entities": [
    {"name": "Sarah", "type": "Person"},
    {"name": "Alex", "type": "Person"},
    {"name": "API Migration", "type": "Project"},
    {"name": "GraphQL", "type": "Tool"},
    {"name": "REST", "type": "Tool"}
  ],
  "relationships": [
    {"from": "Sarah", "relation": "RECOMMENDS", "to": "GraphQL", "context": "for API migration"},
    {"from": "Alex", "relation": "DISAGREES_WITH", "to": "GraphQL"},
    {"from": "Alex", "relation": "WILL_REVIEW", "to": "benchmarks"},
    {"from": "Sarah", "relation": "DISCUSSED", "to": "API Migration"},
    {"from": "Alex", "relation": "DISCUSSED", "to": "API Migration"}
  ]
}

# Docker install
docker run -d \
  --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/your-password \
  neo4j:latest

CREATE (sarah:Person {name: "Sarah", role: "Engineer"})
CREATE (alex:Person {name: "Alex", role: "Tech Lead"})
CREATE (api:Project {name: "API Migration", status: "active"})
CREATE (graphql:Tool {name: "GraphQL"})
CREATE (rest:Tool {name: "REST"})

MATCH (s:Person {name: "Sarah"}), (g:Tool {name: "GraphQL"})
CREATE (s)-[:RECOMMENDS {date: date("2026-01-27"), context: "for API migration"}]->(g)

MATCH (s:Person {name: "Sarah"}), (a:Project {name: "API Migration"})
CREATE (s)-[:WORKS_ON]->(a)

// Who recommends GraphQL?
MATCH (p:Person)-[:RECOMMENDS]->(t:Tool {name: "GraphQL"})
RETURN p.name

// What does Sarah work on?
MATCH (p:Person {name: "Sarah"})-[:WORKS_ON]->(proj:Project)
RETURN proj.name

// Two-hop: tools used by people Sarah works with
MATCH (s:Person {name: "Sarah"})-[:WORKS_WITH]->(colleague:Person)-[:USES]->(tool:Tool)
RETURN DISTINCT tool.name

import networkx as nx
import json

class PersonalKG:
    def __init__(self):
        self.graph = nx.MultiDiGraph()

    def add_entity(self, name: str, entity_type: str, **props):
        self.graph.add_node(name, type=entity_type, **props)

    def add_relationship(self, from_entity: str, relation: str, to_entity: str, **props):
        self.graph.add_edge(from_entity, to_entity, relation=relation, **props)

    def query_outgoing(self, entity: str, relation: str = None):
        """Find what an entity connects to."""
        edges = self.graph.out_edges(entity, data=True)
        if relation:
            edges = [(u, v, d) for u, v, d in edges if d.get('relation') == relation]
        return edges

    def query_incoming(self, entity: str, relation: str = None):
        """Find what connects to an entity."""
        edges = self.graph.in_edges(entity, data=True)
        if relation:
            edges = [(u, v, d) for u, v, d in edges if d.get('relation') == relation]
        return edges

    def path_between(self, start: str, end: str):
        """Find connection path between two entities."""
        try:
            return nx.shortest_path(self.graph, start, end)
        except nx.NetworkXNoPath:
            return None

    def save(self, path: str):
        data = nx.node_link_data(self.graph)
        with open(path, 'w') as f:
            json.dump(data, f)

    def load(self, path: str):
        with open(path) as f:
            data = json.load(f)
        self.graph = nx.node_link_graph(data)

# Usage
kg = PersonalKG()
kg.add_entity("Sarah", "Person", role="Engineer")
kg.add_entity("GraphQL", "Tool")
kg.add_relationship("Sarah", "RECOMMENDS", "GraphQL", date="2026-01-27")

# Query
print(kg.query_outgoing("Sarah", "RECOMMENDS"))
# [('Sarah', 'GraphQL', {'relation': 'RECOMMENDS', 'date': '2026-01-27'})]

from anthropic import Anthropic

def extract_entities_and_relations(note_text: str) -> dict:
    client = Anthropic()

    prompt = f"""Extract entities and relationships from this note.

Entities: people, projects, tools, concepts, decisions
Relationships: WORKS_ON, RECOMMENDS, MENTIONED, INTRODUCED, DECIDED, DISCUSSED

Return JSON:
{{
  "entities": [{{"name": "...", "type": "..."}}],
  "relationships": [{{"from": "...", "relation": "...", "to": "...", "context": "..."}}]
}}

Note:
{note_text}"""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1000,
        messages=[{"role": "user", "content": prompt}]
    )

    # Parse JSON from response
    import json
    return json.loads(response.content[0].text)

def ingest_note(kg: PersonalKG, note_path: str):
    with open(note_path) as f:
        text = f.read()

    extracted = extract_entities_and_relations(text)

    for entity in extracted["entities"]:
        kg.add_entity(entity["name"], entity["type"])

    for rel in extracted["relationships"]:
        kg.add_relationship(
            rel["from"],
            rel["relation"],
            rel["to"],
            context=rel.get("context", ""),
            source=note_path
        )

# Process all notes
from pathlib import Path
kg = PersonalKG()
for note in Path("~/notes").expanduser().glob("**/*.md"):
    ingest_note(kg, note)
kg.save("knowledge_graph.json")

def get_context_for_topic(kg: PersonalKG, topic: str) -> str:
    """Gather related context from the knowledge graph."""
    context_parts = []

    # Direct connections
    outgoing = kg.query_outgoing(topic)
    incoming = kg.query_incoming(topic)

    for _, target, data in outgoing:
        context_parts.append(f"{topic} {data['relation']} {target}")

    for source, _, data in incoming:
        context_parts.append(f"{source} {data['relation']} {topic}")

    return "\n".join(context_parts)

# Use in Claude conversation
topic = "API Migration"
context = get_context_for_topic(kg, topic)

prompt = f"""Context from my knowledge graph:
{context}

Question: What's the status of {topic} and who's involved?"""

Person: name, role, context
Project: name, status, started
Tool: name, category
Concept: name, source

WORKS_ON: Person → Project
USES: Project → Tool  
KNOWS: Person → Person
INTRODUCED: Person → Concept (when: date)