koios/docs/neo4j-unified-schema.md

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

1. One graph, many domains — All assistants read from and write to the same database
2. Domain ownership — Each assistant owns specific node types and is the primary writer
3. Universal read access — Every assistant can read any node to build cross-domain context
4. ID-based deduplication — Always MERGE on id; always check before creating
5. Temporal context — All nodes carry created_at / updated_at timestamps
6. 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
})

Seneca's Domain (Reflection & Wellness)

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
})

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

Batch Related Operations

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:

1. Construct the Cypher query
2. Execute via MCP tool
3. Parse the response
4. Handle errors gracefully
5. 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:

1. Acknowledge naturally in conversation
2. Continue helping with available context
3. Suggest checking MCP server connection if persistent
4. 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	Seneca	id
20	Value	Personal	Seneca	id
21	Habit	Personal	Seneca	id
22	LifeEvent	Personal	Seneca	id
23	Intention	Personal	Seneca	id
24	Recipe	Personal	Bourdain	id
25	Restaurant	Personal	Bourdain	id
26	Ingredient	Personal	Bourdain	id
27	Meal	Personal	Bourdain	id
28	Technique	Personal	Bourdain	id
29	Music	Personal	Bowie	id
30	Film	Personal	Bowie	id
31	Artwork	Personal	Bowie	id
32	Playlist	Personal	Bowie	id
33	Artist	Personal	Bowie	id
34	Style	Personal	Bowie	id
35	Species	Personal	Cousteau	id
36	Plant	Personal	Cousteau	id
37	Tank	Personal	Cousteau	id
38	Garden	Personal	Cousteau	id
39	Ecosystem	Personal	Cousteau	id
40	Observation	Personal	Cousteau	id
41	Account	Personal	Garth	id
42	Investment	Personal	Garth	id
43	Asset	Personal	Garth	id
44	Liability	Personal	Garth	id
45	Budget	Personal	Garth	id
46	FinancialGoal	Personal	Garth	id
47	Match	Personal	Cristiano	id
48	Team	Personal	Cristiano	id
49	League	Personal	Cristiano	id
50	Tournament	Personal	Cristiano	id
51	Player	Personal	Cristiano	id
52	Season	Personal	Cristiano	id
53	Client	Work	Alan / All	id
54	Contact	Work	Jeffrey / All	id
55	Opportunity	Work	Jeffrey / All	id
56	Proposal	Work	Jeffrey / All	id
57	Project	Work	Jarvis / All	id
58	Vendor	Work	Alan / All	id
59	Competitor	Work	Alan / All	id
60	MarketTrend	Work	Alan / All	id
61	Technology	Work	Alan / All	id
62	Content	Work	Ann / All	id
63	Publication	Work	Ann / All	id
64	Skill	Work	Any work	id
65	Certification	Work	Any work	id
66	Relationship	Work	Any work	id
67	Task	Work	Jarvis / All	id
68	Meeting	Work	Jarvis / All	id
69	Note	Work	Jarvis / All	id
70	Decision	Work	Alan / Jarvis	id
71	Infrastructure	Engineering	Scotty	id
72	Incident	Engineering	Scotty	id
73	Prototype	Engineering	Harper	id
74	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