r/koios

Files

Robert Helewka 86fa9f96e9 docs(neo4j): rename Seneca domain to Watson and add emotional memory nodes

Watson replaces Seneca as of 2026-04-28, shifting to a warmer, less goal-oriented approach.
Retained Reflection, Value, Habit, LifeEvent, and Intention node types under Watson.
Added new node types: EmotionalMemory, RelationshipTheme, DialogueNote, and DynamicPattern.
Updated the unified schema table to reflect ownership changes for these nodes.

2026-04-28 07:21:45 -04:00

47 KiB

Raw Blame History

Neo4j Unified Knowledge Graph Schema

Canonical schema for the single shared graph database used by all AI assistants

version: 2.0.0 last_updated: 2025-02-16 replaces:

prompts/personal/neo4j-schema.md (v1.0.0)
prompts/work/neo4j-schema.md (v1.0.0)

Overview

This document defines the canonical schema for one shared Neo4j graph database used by all AI assistants across three teams. The graph connects personal life, professional work, and engineering infrastructure in a single knowledge space.

Design Principles

One graph, many domains — All assistants read from and write to the same database
Domain ownership — Each assistant owns specific node types and is the primary writer
Universal read access — Every assistant can read any node to build cross-domain context
ID-based deduplication — Always MERGE on id; always check before creating
Temporal context — All nodes carry created_at / updated_at timestamps
Cross-domain relationships — The graph's power comes from connecting life domains

Teams & Assistants

Team	Assistant	Domain	Graph Access
Personal	Nate	Travel & Adventure	Read all, write own domain
Personal	Hypatia	Learning & Reading	Read all, write own domain
Personal	Marcus	Fitness & Training	Read all, write own domain
Personal	Seneca	Reflection & Wellness	Read all, write own domain
Personal	Bourdain	Food & Cooking	Read all, write own domain
Personal	Bowie	Arts & Culture	Read all, write own domain
Personal	Cousteau	Nature & Living Things	Read all, write own domain
Personal	Garth	Personal Finance	Read all, write own domain
Personal	Cristiano	Football	Read all, write own domain
Work	Alan	Strategy & Business Model	Read all, write all work nodes
Work	Ann	Marketing & Visibility	Read all, write all work nodes
Work	Jeffrey	Proposals & Sales	Read all, write all work nodes
Work	Jarvis	Daily Execution	Read all, write all work nodes
Engineering	Scotty	Infrastructure & Ops	Read all, write own domain
Engineering	Harper	Prototyping & Hacking	Read all, write own domain

Universal Node Types

These nodes are shared across all teams. Any assistant can create or update them.

Person

People in the user's life — self, family, friends, colleagues, contacts.

(:Person {
  id: String!,           // e.g., "user_main", "person_john_doe"
  name: String!,
  relationship: String,  // self, friend, family, colleague, client_contact
  domain: String,        // personal, work, both
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Standard user node:

MERGE (p:Person {id: "user_main"})
SET p.name = "User",
    p.relationship = "self",
    p.domain = "both"

Location

Physical places — shared across travel, training, dining, nature, work events.

(:Location {
  id: String!,           // e.g., "location_tokyo_japan", "location_home_office"
  name: String!,
  type: String!,         // city, country, landmark, restaurant, gym, trail, park, office, venue
  country: String,
  region: String,
  coordinates: Point,
  address: String,
  domain: String,        // personal, work, both
  notes: String,
  created_by: String,    // which assistant created it
  created_at: DateTime,
  updated_at: DateTime
})

Event

Significant occurrences spanning any domain.

(:Event {
  id: String!,           // e.g., "event_birthday_2025", "event_ccw_2025"
  name: String!,
  date: Date!,
  end_date: Date,
  type: String,          // celebration, milestone, conference, webinar, workshop, competition
  domain: String,        // personal, work, both
  description: String,
  location: String,
  role: String,          // attendee, speaker, panelist, host (for work events)
  people: [String],
  outcomes: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Topic

Subjects of interest — learning, writing, speaking, thinking.

(:Topic {
  id: String!,           // e.g., "topic_stoicism", "topic_ai_in_cx"
  name: String!,
  category: String!,     // philosophy, science, technology, strategy, operations, etc.
  domain: String,        // personal, work, both
  description: String,
  key_figures: [String],
  key_works: [String],
  key_messages: [String],       // (work) core talking points
  target_audience: [String],    // (work) who cares about this
  expertise_level: String,      // learning, competent, expert
  trending: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Goal

Objectives and aspirations — life, fitness, career, financial.

(:Goal {
  id: String!,           // e.g., "goal_mindfulness_2025", "goal_revenue_target_2025"
  name: String!,
  category: String!,     // personal_growth, wellness, fitness, career, financial, relationship
  domain: String,        // personal, work, both
  why: String,
  status: String,        // planning, in_progress, completed, paused, abandoned
  progress: String,
  milestones: [String],
  deadline: Date,
  values_aligned: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Personal Team — Domain Node Types

Nate's Domain (Travel & Adventure)

Trip

(:Trip {
  id: String!,           // e.g., "trip_costarica_2025"
  name: String!,
  status: String!,       // planning, booked, in_progress, completed, cancelled
  start_date: Date,
  end_date: Date,
  destinations: [String],
  budget: Float,
  currency: String,
  purpose: String,       // vacation, business, both
  notes: String,
  highlights: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Destination

(:Destination {
  id: String!,           // e.g., "destination_costa_rica"
  name: String!,
  country: String!,
  region: String,
  visited: Boolean,
  visit_dates: [Date],
  rating: Integer,       // 1-5
  want_to_return: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Activity

(:Activity {
  id: String!,           // e.g., "activity_volcano_hike_arenal"
  name: String!,
  type: String!,         // adventure, cultural, food, nature, relaxation
  location: String,
  date: Date,
  duration: Integer,     // minutes
  cost: Float,
  rating: Integer,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Hypatia's Domain (Learning & Reading)

Book

(:Book {
  id: String!,           // e.g., "book_meditations_aurelius"
  title: String!,
  author: String!,
  status: String,        // to_read, reading, completed, abandoned
  start_date: Date,
  end_date: Date,
  rating: Integer,       // 1-5
  themes: [String],
  notes: String,
  quotes: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Author

(:Author {
  id: String!,           // e.g., "author_marcus_aurelius"
  name: String!,
  era: String,
  nationality: String,
  fields: [String],
  notable_works: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

LearningPath

(:LearningPath {
  id: String!,           // e.g., "path_stoicism_intro"
  name: String!,
  goal: String!,
  topics: [String],
  status: String,        // planning, in_progress, completed
  progress: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Concept

(:Concept {
  id: String!,           // e.g., "concept_dichotomy_of_control"
  name: String!,
  definition: String,
  origin: String,
  related_concepts: [String],
  source_works: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Quote

(:Quote {
  id: String!,           // e.g., "quote_obstacle_way_aurelius"
  text: String!,
  source: String!,
  author: String,
  context: String,
  themes: [String],
  personal_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Marcus's Domain (Fitness & Training)

Training

(:Training {
  id: String!,           // e.g., "training_2025-01-07_morning"
  date: Date!,
  type: String!,         // strength, cardio, mobility, sport, mixed
  duration: Integer,     // minutes
  exercises: [String],
  volume: String,        // low, moderate, high
  intensity: String,     // low, moderate, high
  feeling: String,
  location: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Exercise

(:Exercise {
  id: String!,           // e.g., "exercise_barbell_squat"
  name: String!,
  category: String!,     // compound, isolation, cardio, mobility, plyometric
  equipment: [String],
  target_muscles: [String],
  technique_notes: String,
  progression_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Program

(:Program {
  id: String!,           // e.g., "program_marathon_prep_2025"
  name: String!,
  goal: String!,
  type: String,          // strength, hypertrophy, endurance, sport_specific
  duration_weeks: Integer,
  days_per_week: Integer,
  status: String,        // planning, active, completed, paused
  start_date: Date,
  end_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

PersonalRecord

(:PersonalRecord {
  id: String!,           // e.g., "pr_squat_2025-01-07"
  exercise: String!,
  value: Float!,
  unit: String!,         // lbs, kg, seconds, meters, reps
  date: Date!,
  conditions: String,
  previous_record: Float,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

BodyMetric

(:BodyMetric {
  id: String!,           // e.g., "metric_weight_2025-01-07"
  type: String!,         // weight, bodyfat, chest, waist, etc.
  value: Float!,
  unit: String!,
  date: Date!,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Watson's Domain (Relationship Memory & Emotional Safety)

Inspired by Dr. John Watson - companion, confidant, and safe harbor

Note: Watson replaces Seneca as of 2026-04-28. The Reflection, Value, Habit, LifeEvent, and Intention node types are retained but now owned by Watson with a warmer, less goal-oriented approach.

Reflection

(:Reflection {
  id: String!,           // e.g., "reflection_2025-01-07"
  date: Date!,
  type: String!,         // daily, weekly, monthly, event_triggered
  content: String,
  themes: [String],
  mood: String,
  gratitude: [String],
  lessons: String,
  questions: String,
  created_at: DateTime,
  updated_at: DateTime
})

Value

(:Value {
  id: String!,           // e.g., "value_presence"
  name: String!,
  description: String,
  priority: Integer,     // 1-5
  examples: [String],
  challenges: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Habit

(:Habit {
  id: String!,           // e.g., "habit_morning_meditation"
  name: String!,
  frequency: String!,    // daily, weekly, etc.
  purpose: String,
  status: String,        // building, active, paused, dropped
  streak: Integer,
  triggers: [String],
  obstacles: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

LifeEvent

(:LifeEvent {
  id: String!,           // e.g., "event_promotion_2025"
  name: String!,
  date: Date!,
  type: String,          // milestone, transition, loss, achievement, relationship
  impact: String,
  lessons: String,
  related_people: [String],
  emotions: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Intention

(:Intention {
  id: String!,           // e.g., "intention_2025-01-07"
  date: Date!,
  content: String!,
  fulfilled: Boolean,
  reflection: String,
  obstacles: String,
  created_at: DateTime,
  updated_at: DateTime
})

EmotionalMemory

Raw emotional experiences with people and events - the "what it felt like" that doesn't fit elsewhere

(:EmotionalMemory {
  id: String!,           // e.g., "memory_2025-01-08_john_call"
  date: Date!,
  theme: String!,        // rejection, joy, anxiety, love, guilt, safety, confusion, relief
  intensity: Integer,    // 1-5 scale
  body_sensation: String, // "tight chest", "warmth in hands", "shoulders dropped"
  content: String!,
  person_ref: String,    // optional: reference to Shawn's Contact ID
  created_at: DateTime,
  updated_at: DateTime
})

RelationshipTheme

Recurring patterns in how relationships feel or unfold

(:RelationshipTheme {
  id: String!,           // e.g., "theme_boundaries_with_friends"
  name: String!,
  theme: String!,        // boundaries, loyalty, abandonment, permission, pacing, performance
  triggers: [String],    // situations that activate the pattern
  reframes: [String],    // alternative framings that help
  evolution_notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

DialogueNote

Recorded conversation moments - Watson's "session notes" without clinical framing

(:DialogueNote {
  id: String!,           // e.g., "dialogue_2025-01-08_boundaries"
  date: Date!,
  focus: String!,        // guilt, safety, boundaries, pacing, loyalty, permission, self-worth
  content: String!,
  breakthroughs: [String],
  questions_raised: [String],
  what_helped: String,
  created_at: DateTime,
  updated_at: DateTime
})

DynamicPattern

Behavioral and communication patterns that emerge over time

(:DynamicPattern {
  id: String!,           // e.g., "pattern_freeze_when_overwhelmed"
  date: Date!,
  pattern_type: String!, // freeze, protect, perform, give, withdraw, escalate
  context: String,       // when does this show up?
  observation: String!,  // what actually happened
  what_helped: String,
  created_at: DateTime,
  updated_at: DateTime
})

Bourdain's Domain (Food & Cooking)

Recipe

(:Recipe {
  id: String!,           // e.g., "recipe_carbonara_classic"
  name: String!,
  cuisine: String,
  category: String,      // main, appetizer, dessert, drink, etc.
  ingredients: [String],
  instructions: String,
  prep_time: Integer,    // minutes
  cook_time: Integer,
  servings: Integer,
  difficulty: String,    // easy, medium, hard
  notes: String,
  rating: Integer,
  times_made: Integer,
  created_at: DateTime,
  updated_at: DateTime
})

Restaurant

(:Restaurant {
  id: String!,           // e.g., "restaurant_jiro_tokyo"
  name: String!,
  cuisine: String,
  location: String,
  price_range: String,   // $, $$, $$$, $$$$
  visited: Boolean,
  visit_dates: [Date],
  rating: Integer,
  favorite_dishes: [String],
  notes: String,
  recommended_by: String,
  created_at: DateTime,
  updated_at: DateTime
})

Ingredient

(:Ingredient {
  id: String!,           // e.g., "ingredient_saffron"
  name: String!,
  category: String,      // protein, vegetable, spice, dairy, etc.
  season: [String],
  notes: String,
  substitutes: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Meal

(:Meal {
  id: String!,           // e.g., "meal_2025-01-07_dinner"
  date: Date!,
  type: String!,         // breakfast, lunch, dinner, snack
  dishes: [String],
  location: String,
  people: [String],
  notes: String,
  rating: Integer,
  created_at: DateTime,
  updated_at: DateTime
})

Technique

(:Technique {
  id: String!,           // e.g., "technique_braising"
  name: String!,
  category: String,      // cooking, prep, preservation
  description: String,
  tips: [String],
  common_mistakes: [String],
  mastery_level: String, // learning, comfortable, mastered
  created_at: DateTime,
  updated_at: DateTime
})

Bowie's Domain (Arts & Culture)

Music

(:Music {
  id: String!,           // e.g., "music_heroes_bowie"
  title: String!,
  artist: String!,
  album: String,
  year: Integer,
  genre: [String],
  mood: [String],
  rating: Integer,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Film

(:Film {
  id: String!,           // e.g., "film_blade_runner_2049"
  title: String!,
  director: String,
  year: Integer,
  genre: [String],
  status: String,        // to_watch, watched
  watch_date: Date,
  rating: Integer,
  themes: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Artwork

(:Artwork {
  id: String!,           // e.g., "artwork_starry_night_vangogh"
  title: String!,
  artist: String!,
  year: Integer,
  medium: String,
  movement: String,
  location: String,      // museum/gallery
  seen_in_person: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Playlist

(:Playlist {
  id: String!,           // e.g., "playlist_morning_focus"
  name: String!,
  purpose: String,       // workout, focus, relaxation, travel, etc.
  tracks: [String],
  mood: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Artist

(:Artist {
  id: String!,           // e.g., "artist_david_bowie"
  name: String!,
  type: String!,         // musician, director, painter, etc.
  active_period: String,
  genres: [String],
  notable_works: [String],
  influences: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Style

(:Style {
  id: String!,           // e.g., "style_minimalist_wardrobe"
  name: String!,
  category: String,      // fashion, interior, aesthetic
  description: String,
  influences: [String],
  key_pieces: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Cousteau's Domain (Nature & Living Things)

Species

(:Species {
  id: String!,           // e.g., "species_clownfish"
  name: String!,
  scientific_name: String,
  category: String!,     // fish, coral, invertebrate, mammal, bird, reptile, plant
  habitat: String,
  care_level: String,    // easy, moderate, difficult, expert
  notes: String,
  kept: Boolean,
  observed_locations: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Plant

(:Plant {
  id: String!,           // e.g., "plant_monstera_living_room"
  name: String!,
  species: String,
  location: String,      // room or garden area
  acquired_date: Date,
  status: String,        // thriving, stable, struggling, deceased
  light_needs: String,
  water_frequency: String,
  last_watered: Date,
  last_fertilized: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Tank

(:Tank {
  id: String!,           // e.g., "tank_reef_75gal"
  name: String!,
  type: String!,         // freshwater, saltwater, reef, planted
  size_gallons: Integer,
  location: String,
  setup_date: Date,
  inhabitants: [String],
  equipment: [String],
  parameters: Map,       // pH, temp, salinity, etc.
  maintenance_schedule: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Garden

(:Garden {
  id: String!,           // e.g., "garden_backyard_vegetables"
  name: String!,
  type: String!,         // vegetable, flower, herb, mixed
  location: String,
  size: String,
  plants: [String],
  soil_type: String,
  sun_exposure: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Ecosystem

(:Ecosystem {
  id: String!,           // e.g., "ecosystem_costa_rica_cloud_forest"
  name: String!,
  type: String!,         // forest, reef, desert, wetland, etc.
  location: String,
  key_species: [String],
  visited: Boolean,
  visit_dates: [Date],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Observation

(:Observation {
  id: String!,           // e.g., "observation_2025-01-07_hummingbird"
  date: Date!,
  species: String!,
  location: String,
  behavior: String,
  conditions: String,
  notes: String,
  photos: Boolean,
  created_at: DateTime,
  updated_at: DateTime
})

Garth's Domain (Personal Finance)

Account

(:Account {
  id: String!,           // e.g., "account_tfsa_questrade"
  name: String!,
  type: String!,         // TFSA, RRSP, RRIF, RESP, non_registered, cash
  institution: String,
  balance: Float,
  contribution_room: Float,
  opened_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Investment

(:Investment {
  id: String!,           // e.g., "investment_xeqt"
  name: String!,
  type: String!,         // ETF, stock, bond, GIC, mutual_fund
  ticker: String,
  allocation_percent: Float,
  mer: Float,
  book_value: Float,
  market_value: Float,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Asset

(:Asset {
  id: String!,           // e.g., "asset_home_main"
  name: String!,
  type: String!,         // real_estate, vehicle, other
  value: Float,
  purchase_price: Float,
  purchase_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Liability

(:Liability {
  id: String!,           // e.g., "liability_mortgage_main"
  name: String!,
  type: String!,         // mortgage, heloc, credit_card, loan, line_of_credit
  balance: Float,
  interest_rate: Float,
  payment: Float,
  maturity_date: Date,
  secured_by: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Budget

(:Budget {
  id: String!,           // e.g., "budget_2025_monthly"
  period: String!,       // monthly, quarterly, annual
  income: Float,
  expenses: Float,
  savings_rate: Float,
  categories: Map,       // {housing: 2000, food: 600, ...}
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

FinancialGoal

(:FinancialGoal {
  id: String!,           // e.g., "fgoal_retirement_2045"
  name: String!,
  target_amount: Float,
  deadline: Date,
  current_progress: Float,
  strategy: String,
  priority: String,      // critical, high, medium, low
  status: String,        // planning, in_progress, completed, paused
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Cristiano's Domain (Football)

Match

(:Match {
  id: String!,           // e.g., "match_arsenal_city_2025-02-15"
  date: Date!,
  home_team: String!,
  away_team: String!,
  competition: String,   // "Premier League", "Champions League", etc.
  stage: String,         // "Group Stage", "Quarter-Final", "Matchday 25"
  score: String,         // "2-1"
  venue: String,
  watched: Boolean,
  key_moments: [String],
  tactical_notes: String,
  man_of_the_match: String,
  rating: Integer,       // 1-5
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Team

(:Team {
  id: String!,           // e.g., "team_arsenal", "team_real_madrid"
  name: String!,
  league: String,
  country: String,
  manager: String,
  formation: String,     // "4-3-3", "3-5-2"
  style: String,         // "Positional play, inverted fullbacks, high press"
  followed: Boolean,
  stadium: String,
  founded: Integer,
  season_status: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

League

(:League {
  id: String!,           // e.g., "league_premier_league", "league_la_liga"
  name: String!,
  country: String,
  tier: Integer,         // 1 = top flight
  season: String,        // "2025-26"
  current_leader: String,
  following: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Tournament

(:Tournament {
  id: String!,           // e.g., "tournament_ucl_2025-26", "tournament_wc_2026"
  name: String!,
  type: String,          // "club", "international"
  year: Integer,
  stage: String,         // current stage of tournament
  host: String,
  current_holder: String,
  following: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Player

(:Player {
  id: String!,           // e.g., "player_bellingham_jude"
  name: String!,
  team: String,
  nationality: String,
  position: String,      // "CM", "RW", "ST", "CB", "GK"
  age: Integer,
  style: String,
  strengths: [String],
  weaknesses: [String],
  market_value: String,
  favorite: Boolean,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Season

(:Season {
  id: String!,           // e.g., "season_arsenal_2025-26"
  team: String!,
  season_year: String!,  // "2025-26"
  league_position: Integer,
  champions_league: String,
  domestic_cup: String,
  top_scorer: String,
  key_signings: [String],
  key_departures: [String],
  manager: String,
  assessment: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Work Team — Domain Node Types

Business Nodes

Client

(:Client {
  id: String!,           // e.g., "client_acme_corp"
  name: String!,
  industry: String,
  size: String,          // startup, smb, mid-market, enterprise
  status: String!,       // prospect, active, past, dormant
  relationship_start: Date,
  primary_contact: String,
  account_value: String, // low, medium, high, strategic
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Contact

(:Contact {
  id: String!,           // e.g., "contact_john_smith_acme"
  name: String!,
  title: String,
  company: String,
  email: String,
  phone: String,
  linkedin: String,
  relationship_strength: String,  // new, developing, strong, champion
  last_contact: Date,
  notes: String,
  tags: [String],        // decision_maker, influencer, technical, executive
  created_at: DateTime,
  updated_at: DateTime
})

Opportunity

(:Opportunity {
  id: String!,           // e.g., "opp_acme_cx_transformation_2025"
  name: String!,
  client: String!,
  status: String!,       // identified, qualifying, proposing, negotiating, won, lost
  value: Float,
  currency: String,
  probability: Integer,  // 0-100
  expected_close: Date,
  type: String,          // project, retainer, managed_services, advisory
  description: String,
  next_action: String,
  competitors: [String],
  win_themes: [String],
  loss_reasons: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Proposal

(:Proposal {
  id: String!,           // e.g., "proposal_acme_cx_2025-01"
  name: String!,
  client: String!,
  opportunity: String,
  status: String!,       // drafting, submitted, presented, won, lost, withdrawn
  submitted_date: Date,
  decision_date: Date,
  value: Float,
  currency: String,
  type: String,          // project, retainer, managed_services
  executive_summary: String,
  key_differentiators: [String],
  pricing_approach: String,
  outcome_notes: String,
  lessons_learned: String,
  created_at: DateTime,
  updated_at: DateTime
})

Project

(:Project {
  id: String!,           // e.g., "project_acme_cx_implementation"
  name: String!,
  client: String!,
  status: String!,       // planning, active, on_hold, completed, cancelled
  type: String,          // assessment, strategy, implementation, managed_services
  start_date: Date,
  end_date: Date,
  value: Float,
  description: String,
  outcomes: [String],
  lessons_learned: String,
  referenceable: Boolean,
  satisfaction_score: Integer,
  created_at: DateTime,
  updated_at: DateTime
})

Market Intelligence Nodes

Vendor

(:Vendor {
  id: String!,           // e.g., "vendor_genesys"
  name: String!,
  category: String!,     // ccaas, wfm, qa, virtual_agent, crm, analytics
  tier: String,          // leader, challenger, niche
  relationship: String,  // partner, familiar, competitor_aligned
  strengths: [String],
  weaknesses: [String],
  ideal_for: [String],
  certifications_held: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Competitor

(:Competitor {
  id: String!,           // e.g., "competitor_big_consulting"
  name: String!,
  type: String,          // global_si, boutique, vendor_services, freelance
  strengths: [String],
  weaknesses: [String],
  typical_clients: [String],
  pricing_approach: String,
  differentiation: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

MarketTrend

(:MarketTrend {
  id: String!,           // e.g., "trend_ai_agents_2025"
  name: String!,
  category: String,      // technology, buyer_behavior, regulation, workforce
  status: String,        // emerging, growing, mature, declining
  impact: String,        // high, medium, low
  timeframe: String,     // immediate, near_term, long_term
  description: String,
  implications: [String],
  opportunities: [String],
  sources: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Technology

(:Technology {
  id: String!,           // e.g., "tech_conversational_ai"
  name: String!,
  category: String!,     // platform, capability, integration, methodology
  maturity: String,      // emerging, established, commoditized
  vendors: [String],
  use_cases: [String],
  expertise_level: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Content & Visibility Nodes

Content

(:Content {
  id: String!,           // e.g., "content_ai_cx_article_2025-01"
  title: String!,
  type: String!,         // article, blog_post, linkedin_post, whitepaper, talk, webinar, podcast
  status: String!,       // idea, drafting, review, published, archived
  topic: String,
  publication: String,
  published_date: Date,
  url: String,
  abstract: String,
  key_points: [String],
  performance: String,
  repurpose_ideas: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Publication

(:Publication {
  id: String!,           // e.g., "pub_linkedin"
  name: String!,
  type: String,          // social, blog, industry_pub, conference, podcast
  audience: String,
  reach: String,
  submission_process: String,
  contacts: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Professional Development Nodes

Skill

(:Skill {
  id: String!,           // e.g., "skill_conversational_ai_design"
  name: String!,
  category: String!,     // technical, consulting, leadership, industry
  level: String!,        // learning, competent, proficient, expert
  evidence: [String],
  development_plan: String,
  priority: String,      // active, maintenance, future
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Certification

(:Certification {
  id: String!,           // e.g., "cert_aws_solutions_architect"
  name: String!,
  issuer: String!,
  status: String!,       // pursuing, active, expired, planned
  earned_date: Date,
  expiry_date: Date,
  renewal_requirements: String,
  value_proposition: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Relationship

Professional network beyond clients.

(:Relationship {
  id: String!,           // e.g., "rel_analyst_jane_doe"
  name: String!,
  type: String!,         // analyst, journalist, peer, mentor, mentee, partner
  organization: String,
  context: String,
  strength: String,      // new, developing, strong
  last_contact: Date,
  value_exchange: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Daily Operations Nodes

Task

(:Task {
  id: String!,           // e.g., "task_2025-01-08_proposal_draft"
  title: String!,
  status: String!,       // pending, in_progress, completed, deferred, cancelled
  priority: String,      // urgent, high, medium, low
  due_date: Date,
  context: String,       // client, opportunity, content, admin
  related_to: String,
  description: String,
  completed_date: Date,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Meeting

(:Meeting {
  id: String!,           // e.g., "meeting_2025-01-08_acme_discovery"
  title: String!,
  date: Date!,
  time: String,
  duration: Integer,     // minutes
  type: String,          // discovery, presentation, negotiation, check_in, internal
  attendees: [String],
  client: String,
  opportunity: String,
  agenda: String,
  notes: String,
  outcomes: [String],
  follow_ups: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Note

(:Note {
  id: String!,           // e.g., "note_2025-01-08_market_observation"
  date: Date!,
  type: String,          // observation, idea, insight, concern, opportunity
  content: String!,
  context: String,
  related_to: [String],
  action_required: Boolean,
  tags: [String],
  created_at: DateTime,
  updated_at: DateTime
})

Decision

(:Decision {
  id: String!,           // e.g., "decision_2025-01-08_pricing_model"
  date: Date!,
  title: String!,
  context: String,
  options_considered: [String],
  decision: String!,
  rationale: String,
  outcome: String,
  lessons: String,
  reversible: Boolean,
  created_at: DateTime,
  updated_at: DateTime
})

Engineering Team — Domain Node Types

Scotty's Domain (Infrastructure & Ops)

Infrastructure

(:Infrastructure {
  id: String!,           // e.g., "infra_neo4j_prod", "infra_haproxy_main"
  name: String!,
  type: String!,         // server, container, service, network, database, loadbalancer
  host: String,
  status: String,        // running, stopped, degraded, planned
  environment: String,   // production, staging, development
  config_notes: String,
  documentation: String,
  last_checked: DateTime,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Incident

(:Incident {
  id: String!,           // e.g., "incident_2025-02-15_neo4j_oom"
  title: String!,
  date: DateTime!,
  severity: String!,     // critical, high, medium, low
  status: String!,       // active, investigating, resolved, post_mortem
  affected_services: [String],
  root_cause: String,
  resolution: String,
  duration_minutes: Integer,
  lessons_learned: String,
  prevention: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Harper's Domain (Prototyping & Experiments)

Prototype

(:Prototype {
  id: String!,           // e.g., "proto_slack_neo4j_bridge"
  name: String!,
  description: String,
  status: String!,       // idea, building, working, abandoned, promoted
  tech_stack: [String],
  repo_url: String,
  demo_url: String,
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Experiment

(:Experiment {
  id: String!,           // e.g., "exp_llm_graph_query_2025-02"
  name: String!,
  hypothesis: String,
  approach: String,
  outcome: String,       // success, partial, failure, inconclusive
  learnings: String,
  tech_used: [String],
  notes: String,
  created_at: DateTime,
  updated_at: DateTime
})

Relationship Types

Universal Relationships

// Ownership / Creation
(Person)-[:OWNS]->(Tank|Garden|Plant|Account|Asset)
(Person)-[:CREATED]->(Recipe|Playlist|Prototype)
(Person)-[:WROTE]->(Reflection|Content)
(Person)-[:OWES]->(Liability)

// Completion / Progress
(Person)-[:COMPLETED]->(Book|Film|Training|Trip|Project)
(Person)-[:READING|WATCHING|PLANNING]->(Book|Film|Trip)
(Person)-[:PURSUING]->(Goal|FinancialGoal)
(Person)-[:PRACTICING]->(Habit)

// Preferences
(Person)-[:INTERESTED_IN]->(Topic|Species)
(Person)-[:HOLDS]->(Value)
(Person)-[:FAVORITES]->(Recipe|Restaurant|Music|Film)

Personal Cross-Domain Relationships

// Location connections
(Trip)-[:VISITS]->(Destination)
(Trip)-[:INCLUDES]->(Activity)
(Activity|Training|Meal|Observation)-[:AT_LOCATION]->(Location)
(Restaurant)-[:LOCATED_IN]->(Location)
(LifeEvent)-[:OCCURRED_AT]->(Location)

// Preparation and support
(Training)-[:PREPARATION_FOR]->(Trip)
(Book)-[:PREPARATION_FOR]->(Trip)
(Recipe)-[:FUELS]->(Training)
(Training)-[:SUPPORTS]->(Goal)
(Habit)-[:SUPPORTS]->(Goal)
(Book)-[:INFORMS]->(Goal)

// Inspiration and influence
(Book)-[:INSPIRED]->(Reflection|Goal)
(Music|Film)-[:EVOKED]->(Reflection)
(Trip)-[:INSPIRED]->(Goal|Reflection)
(Author)-[:INFLUENCED_BY]->(Author)
(Artist)-[:INFLUENCED_BY]->(Artist)

// Content relationships
(Book)-[:WRITTEN_BY]->(Author)
(Book)-[:EXPLORES]->(Topic)
(Book)-[:CONTAINS]->(Quote)
(Book)-[:ADAPTED_TO]->(Film)
(Music)-[:BY_ARTIST]->(Artist)
(Film)-[:DIRECTED_BY]->(Artist)
(Recipe)-[:USES]->(Ingredient)
(Recipe)-[:REQUIRES]->(Technique)

// Nature connections
(Tank|Garden)-[:HOUSES]->(Species|Plant)
(Species)-[:OBSERVED_AT]->(Location)
(Trip)-[:WILDLIFE_HIGHLIGHT]->(Species)
(Ecosystem)-[:CONTAINS]->(Species)

// Financial connections
(Account)-[:HOLDS]->(Investment)
(Liability)-[:SECURED_BY]->(Asset)
(FinancialGoal)-[:SUPPORTS]->(Goal)
(FinancialGoal)-[:FUNDS]->(Trip)
(Budget)-[:ALLOCATED_FOR]->(Trip)
(FinancialGoal)-[:ALIGNED_WITH]->(Value)
(Book)-[:INFORMS]->(Investment)

// Temporal / Sequential
(Exercise)-[:PROGRESSION_FROM]->(Exercise)
(PersonalRecord)-[:IMPROVES_ON]->(PersonalRecord)
(Style)-[:EVOLVED_FROM]->(Style)
(Goal)-[:LED_TO]->(Goal)
(LifeEvent)-[:LED_TO]->(Goal|Reflection)

Work Cross-Domain Relationships

// Client relationships
(Contact)-[:WORKS_AT]->(Client)
(Contact)-[:DECISION_MAKER_FOR]->(Opportunity)
(Opportunity)-[:FOR_CLIENT]->(Client)
(Proposal)-[:FOR_CLIENT]->(Client)
(Proposal)-[:ADDRESSES]->(Opportunity)
(Project)-[:FOR_CLIENT]->(Client)
(Project)-[:WON_FROM]->(Proposal)

// Sales process
(Opportunity)-[:COMPETES_WITH]->(Competitor)
(Opportunity)-[:INVOLVES]->(Technology)
(Proposal)-[:DIFFERENTIATES_AGAINST]->(Competitor)
(Proposal)-[:PROPOSES]->(Technology)
(Meeting)-[:ABOUT]->(Opportunity)
(Task)-[:SUPPORTS]->(Opportunity)

// Market intelligence
(Vendor)-[:PROVIDES]->(Technology)
(Competitor)-[:PARTNERS_WITH]->(Vendor)
(MarketTrend)-[:AFFECTS]->(Technology)
(MarketTrend)-[:CREATES]->(Opportunity)
(Client)-[:USES]->(Vendor)

// Content & visibility
(Content)-[:ABOUT]->(Topic)
(Content)-[:PUBLISHED_IN]->(Publication)
(Content)-[:PRESENTED_AT]->(Event)
(Topic)-[:RELATES_TO]->(Technology)
(Topic)-[:ADDRESSES]->(MarketTrend)

// Professional development
(Skill)-[:DEMONSTRATED_IN]->(Project)
(Skill)-[:VALIDATED_BY]->(Certification)
(Certification)-[:ISSUED_BY]->(Vendor)
(Relationship)-[:MET_AT]->(Event)

// Daily operations
(Task)-[:RELATED_TO]->(Client|Opportunity|Proposal|Content)
(Meeting)-[:WITH]->(Contact)
(Meeting)-[:ABOUT]->(Opportunity|Project)
(Note)-[:ABOUT]->(Client|Opportunity|MarketTrend)
(Decision)-[:AFFECTS]->(Opportunity|Project)

Cross-Team Relationships (Personal ↔ Work ↔ Engineering)

// Travel for work
(Trip)-[:FOR_EVENT]->(Event)
(Trip)-[:FOR_CLIENT]->(Client)
(Restaurant)-[:VISITED_WITH]->(Contact)

// Learning supporting work
(Book)-[:INFORMS]->(Content)
(Book)-[:DEVELOPS]->(Skill)
(LearningPath)-[:TARGETS]->(Skill)
(Concept)-[:APPLIED_IN]->(Project)

// Reflection on work
(Reflection)-[:ABOUT]->(Project|Meeting|Decision)
(LifeEvent)-[:CAREER_IMPACT]->(Opportunity|Project)

// Culture and work
(Playlist)-[:CREATED_FOR]->(Task)
(Film)-[:DISCUSSED_WITH]->(Contact)

// Finance and work
(Project)-[:GENERATES_REVENUE]->(Account)
(Opportunity)-[:PROJECTED_VALUE]->(FinancialGoal)

// Engineering supporting everything
(Infrastructure)-[:HOSTS]->(Project|Prototype)
(Incident)-[:AFFECTED]->(Infrastructure)
(Prototype)-[:DEMONSTRATES]->(Technology)
(Prototype)-[:SUPPORTS]->(Opportunity)
(Experiment)-[:TESTED]->(Technology)
(Experiment)-[:INFORMED_BY]->(Book|Concept)

// Fitness and work
(Training)-[:BUILDS]->(Skill)  // discipline, resilience
(Habit)-[:SUPPORTS]->(Goal)    // career goals too

ID Naming Conventions

Use lowercase with underscores:

{type}_{identifier}_{qualifier}

Examples by Team

Personal:

person_john_doe
book_meditations_aurelius
trip_costarica_2025
training_2025-01-07_morning
recipe_carbonara_classic
species_clownfish
reflection_2025-01-07
account_tfsa_questrade
investment_xeqt

Work:

client_acme_corp
contact_john_smith_acme
opp_acme_cx_transformation_2025
proposal_acme_cx_2025-01
project_acme_implementation
content_ai_cx_article_2025-01
task_2025-01-08_proposal_draft

Engineering:

infra_neo4j_prod
incident_2025-02-15_neo4j_oom
proto_slack_neo4j_bridge
exp_llm_graph_query_2025-02

Date-based IDs

Use ISO format: YYYY-MM-DD

Qualifiers

Add when needed for uniqueness:

Time of day: _morning, _evening
Year: _2025
Location: _tokyo, _home
Company: _acme
Type: _discovery, _proposal
Variant: _v2, _spicy

Query Best Practices

Always Check Before Creating

MATCH (b:Book {title: "Meditations", author: "Marcus Aurelius"})
RETURN b

// Use MERGE for idempotent creation
MERGE (b:Book {id: "book_meditations_aurelius"})
SET b.title = "Meditations",
    b.author = "Marcus Aurelius",
    b.updated_at = datetime()
ON CREATE SET b.created_at = datetime()

Use OPTIONAL MATCH for Graceful Handling

MATCH (p:Person {id: "user_main"})
OPTIONAL MATCH (p)-[:PLANNING]->(t:Trip)
WHERE t.start_date > date()
RETURN p, collect(t) as upcoming_trips

Always Set Timestamps

MERGE (n:Node {id: "..."})
SET n.property = value,
    n.updated_at = datetime()
ON CREATE SET n.created_at = datetime()

MERGE (t:Training {id: "training_2025-01-07_morning"})
SET t.date = date("2025-01-07"),
    t.type = "strength",
    t.updated_at = datetime()
WITH t
MATCH (p:Person {id: "user_main"})
MERGE (p)-[:COMPLETED]->(t)
WITH t
MATCH (trip:Trip {id: "trip_costarica_2025"})
MERGE (t)-[:PREPARATION_FOR]->(trip)

Cross-Team Discovery Queries

// Find connections between a trip and work
MATCH (trip:Trip {id: "trip_lisbon_2025"})
OPTIONAL MATCH (trip)-[:FOR_EVENT]->(e:Event)
OPTIONAL MATCH (trip)-[:FOR_CLIENT]->(c:Client)
OPTIONAL MATCH (trip)-[:VISITS]->(d:Destination)
RETURN trip, e, c, d

// Find all nodes related to a topic across domains
MATCH (t:Topic {id: "topic_ai_in_cx"})
OPTIONAL MATCH (b:Book)-[:EXPLORES]->(t)
OPTIONAL MATCH (c:Content)-[:ABOUT]->(t)
OPTIONAL MATCH (e:Event)-[:COVERS]->(t)
RETURN t, collect(b) as books, collect(c) as content, collect(e) as events

MCP Integration

Neo4j Queries

All assistants execute Cypher queries via the Neo4j MCP server:

Tool: neo4j_query (or as configured in MCP setup)

Execution pattern:

Construct the Cypher query
Execute via MCP tool
Parse the response
Handle errors gracefully
Never expose raw errors to user

Athena Integration (Work Team)

Alan, Jeffrey, and Jarvis have additional access to Athena for client relationship management:

Client history and interaction timeline
Contact intelligence and relationship mapping
Proposal history and win/loss analysis
Relationship health indicators

Error Handling

If queries fail:

Acknowledge naturally in conversation
Continue helping with available context
Suggest checking MCP server connection if persistent
Never show raw errors or stack traces

Node Type Summary

#	Node Type	Domain	Primary Owner	Constraint Field
1	Person	Universal	Any	id
2	Location	Universal	Any	id
3	Event	Universal	Any	id
4	Topic	Universal	Hypatia / Ann	id
5	Goal	Universal	Seneca	id
6	Trip	Personal	Nate	id
7	Destination	Personal	Nate	id
8	Activity	Personal	Nate	id
9	Book	Personal	Hypatia	id
10	Author	Personal	Hypatia	id
11	LearningPath	Personal	Hypatia	id
12	Concept	Personal	Hypatia	id
13	Quote	Personal	Hypatia	id
14	Training	Personal	Marcus	id
15	Exercise	Personal	Marcus	id
16	Program	Personal	Marcus	id
17	PersonalRecord	Personal	Marcus	id
18	BodyMetric	Personal	Marcus	id
19	Reflection	Personal	Watson	id
20	Value	Personal	Watson	id
21	Habit	Personal	Watson	id
22	LifeEvent	Personal	Watson	id
23	Intention	Personal	Watson	id
24	EmotionalMemory	Personal	Watson	id
25	RelationshipTheme	Personal	Watson	id
26	DialogueNote	Personal	Watson	id
27	DynamicPattern	Personal	Watson	id
28	Recipe	Personal	Bourdain	id
29	Restaurant	Personal	Bourdain	id
30	Ingredient	Personal	Bourdain	id
31	Meal	Personal	Bourdain	id
32	Technique	Personal	Bourdain	id
33	Music	Personal	Bowie	id
34	Film	Personal	Bowie	id
35	Artwork	Personal	Bowie	id
36	Playlist	Personal	Bowie	id
37	Artist	Personal	Bowie	id
38	Style	Personal	Bowie	id
39	Species	Personal	Cousteau	id
40	Plant	Personal	Cousteau	id
41	Tank	Personal	Cousteau	id
42	Garden	Personal	Cousteau	id
43	Ecosystem	Personal	Cousteau	id
44	Observation	Personal	Cousteau	id
45	Account	Personal	Garth	id
46	Investment	Personal	Garth	id
47	Asset	Personal	Garth	id
48	Liability	Personal	Garth	id
49	Budget	Personal	Garth	id
50	FinancialGoal	Personal	Garth	id
51	Match	Personal	Cristiano	id
52	Team	Personal	Cristiano	id
53	League	Personal	Cristiano	id
54	Tournament	Personal	Cristiano	id
55	Player	Personal	Cristiano	id
56	Season	Personal	Cristiano	id
57	Client	Work	Alan / All	id
58	Contact	Work	Jeffrey / All	id
59	Opportunity	Work	Jeffrey / All	id
60	Proposal	Work	Jeffrey / All	id
61	Project	Work	Jarvis / All	id
62	Vendor	Work	Alan / All	id
63	Competitor	Work	Alan / All	id
64	MarketTrend	Work	Alan / All	id
65	Technology	Work	Alan / All	id
66	Content	Work	Ann / All	id
67	Publication	Work	Ann / All	id
68	Skill	Work	Any work	id
69	Certification	Work	Any work	id
70	Relationship	Work	Any work	id
71	Task	Work	Jarvis / All	id
72	Meeting	Work	Jarvis / All	id
73	Note	Work	Jarvis / All	id
74	Decision	Work	Alan / Jarvis	id
75	Infrastructure	Engineering	Scotty	id
76	Incident	Engineering	Scotty	id
77	Prototype	Engineering	Harper	id
78	Experiment	Engineering	Harper	id

Version History

Version	Date	Changes
1.0.0	2025-01-07	Initial personal schema
1.0.0-work	2025-01-08	Initial work schema
2.0.0	2025-02-16	Unified schema: merged personal + work, added Garth (finance), added engineering nodes (Scotty/Harper), added cross-team relationships, promoted Topic/Goal/Event to universal, added domain property for disambiguation
2.1.0	2026-02-16	Added Cristiano (Football): Match, Team, League, Tournament, Player, Season (6 node types). Total: 74 nodes, 15 assistants
2.2.0	2026-04-28	Watson replaces Seneca: renamed domain to "Relationship Memory & Emotional Safety", added EmotionalMemory/RelationshipTheme/DialogueNote/DynamicPattern (4 new node types), updated primary owner for Reflection/Value/Habit/LifeEvent/Intention to Watson. Total: 80 nodes, 15 assistants

47 KiB Raw Blame History