What, Why, How

What is myKE?

myKE (Knowledge Explorer) is an AI-powered interactive learning environment that generates and visualizes knowledge as an explorable concept map. A learner enters a domain, subdomain, and concept — or describes a problem in free text — and the system produces a structured graph where nodes are concepts, skills, and prerequisites, and edges are typed relationships (requires, enables, related, special-case).

The map is not a static diagram. Every node is a doorway: clicking it opens a details panel with context-specific actions — definitions, examples, assessments, step-by-step tutorials, relationship explanations, and a Socratic chat. Learners can expand any node to generate a deeper sub-map, switch layout algorithms to reframe the graph spatially, or enter Lecture Mode to receive slide-based instruction derived from the map.

Node vocabulary

Core capabilities

• Q2LQuestion to Learn — Socratic exercise where AI generates a scenario and evaluates whether the learner's question is "deep" before guiding discussion. Inverts the AI-answers-human pattern.
• AnalyticsLearning Analytics — Eight server-side learner models aggregate into a personal profile visible via "How Am I Doing?"
• TeacherTeacher Dashboard — Curriculum builder with AI-assisted concept expansion, class management via enrollment codes, and student progress tracking.
• RolesMulti-role system — Learner → Teacher → Admin → System Admin, with role-based UI and data access.
• i18n14-language support — All UI strings and AI-generated content rendered in the learner's chosen language; translations update without redeployment.
• xAPIxAPI / LRS integration — All significant learning events delivered as standardized xAPI statements to a configured Learning Record Store.
• WondermentWonderment — Three specialist AI agents (Empiricist, Connector, Provocateur) surface paradoxes, hidden connections, and counterintuitive depth through a 5-step inquiry arc, directly measuring Bloom's Evaluate and Create levels.
• WTBWhen Things Break Down — AI-generated failure scenarios across engineering, biology, and social systems where learners investigate clues and diagnose root causes, measuring Apply/Analyze Bloom's levels through causal reasoning.

Why myKE exists

The problem

Modern learners have unprecedented access to information but face a compounding trap: AI assistants answer questions instantly, which trains answer-seeking behavior and atrophies question-asking capacity. Passive consumption creates the illusion of understanding without the cognitive effort that produces it. Students can retrieve facts but cannot connect them, apply them, or recognise when they don't understand something.

Traditional educational software compounds this by treating AI as an answer machine: type question → receive explanation. This reduces effort, weakens memory consolidation, and undermines metacognition — the learner's awareness of their own understanding.

Philosophical stance

myKE is grounded in constructivism: knowledge is not transmitted, it is built through active engagement with material and prior schema. The concept map as a central artifact makes the structure of a domain visible so learners see how ideas connect rather than what they are in isolation.

myKE uses AI as scaffold, not substitute:

Why concept maps

Knowledge represented as a graph surfaces what flat documents cannot:

• Dependency order — what must be understood before what.
• Conceptual proximity — which ideas cluster, which are isolated.
• Gap detection — missing connections become visible.
• Navigation by interest — learners follow threads that matter to them, not a fixed linear path.

Theory behind myKE

myKE is not a technology project with pedagogy bolted on. Every design decision — why the map is centered on one concept, why Q2L asks learners to formulate questions rather than answer them, why the analytics track question depth rather than time-on-task — traces back to established learning science.

Bloom's Taxonomy in action

Every myKE feature maps to one or more cognitive levels:

The Q2L question-depth rubric

The most theoretically grounded feature is Q2L's evaluation of question depth. Surface questions ask for facts that can be looked up. Deep questions expose the learner's mental model and cannot be resolved by simple retrieval.

Deep questions share characteristics: they explore mechanisms (why, how) over facts (what, when), investigate relationships, consider edge cases, and require integrating multiple ideas. They cannot be answered by lookup — and formulating them requires partial understanding, which is precisely why Q2L prioritises the question over the answer.

AI as scaffold (ZPD in practice)

Vygotsky's Zone of Proximal Development describes the gap between what a learner can do alone and what they can do with expert guidance. myKE positions AI in the role of that expert — but carefully. The AI:

• Generates the map structure (reduces cognitive load on navigation)
• Offers scaffolded question suggestions in Q2L (but the learner formulates the final question)
• Evaluates and gives feedback (without giving away the answer)
• Guides Socratic discussion (asks follow-up questions rather than explaining)

The scaffolding is designed to fade: as a learner deepens understanding, AI interactions shift from explanatory to interrogatory. The learner moves from the outer ZPD toward independent mastery.

What makes myKE different

EdTech is a crowded space. LLM-powered tools have multiplied since 2023. What separates myKE from AI tutors, flashcard generators, and knowledge-base chatbots is not a single feature but a coherent inversion of the dominant interaction model.

The interaction model is inverted

Most AI education tools follow: learner asks → AI answers. myKE inverts this at its most important feature:

myKE vs. other tool categories

When Things Break Down

Wonderment

Edge AI — Relation Explorer

The five things only myKE does

• Question evaluation as the primary AI role. AI does not primarily answer — it evaluates the quality of the learner's questions and guides toward deeper inquiry.
• Knowledge structure as a persistent, explorable artifact. The concept map is not a visual aid — it is the learning environment itself, navigable, expandable, and personally customisable.
• Stealth assessment through interaction patterns. Learning quality is inferred from how learners explore (sequence, depth, question type, AI collaboration style) rather than from what they score on a test.
• Diagnostic reasoning through failure scenarios. WTB puts learners inside failure scenarios where they must reason about root causes — measuring Apply and Analyze Bloom's levels that cannot be faked by recall.
• Multi-agent epistemic wonder. Wonderment deploys three specialist agents simultaneously to surface paradoxes, cross-domain connections, and counterintuitive depth — turning awe into a deliberate pedagogical tool.

How it works

System architecture

React 18 SPA (Vite)          Express API (Node.js)          AI Providers
  client/src/               server/src/                    OpenAI / Anthropic
  ├── App.jsx               ├── index.js                   / Azure OpenAI
  ├── contexts/             ├── routes/
  ├── components/           ├── services/
  ├── pages/                │   ├── mapGenerator.js
  ├── hooks/                │   ├── ai/
  └── services/             │   ├── learnerModels.js
                            │   └── learnerProfile.js
                            └── middleware/auth.js

npm workspaces monorepo. The server serves the built client from /client/dist and exposes a REST API under /api. All source is JSX/JS — no TypeScript.

Map generation pipeline

Canvas rendering & layouts

ConceptMap.jsx renders an SVG canvas with zoom/pan, node dragging, selection, hover states, and useBehaviorTracking on every interaction. Map state is managed by the useConceptMap hook.

Four layout algorithms switchable at runtime via layoutEngine.js:

Q2L flow

AI generates scenario
  → Learner selects 1–3 context concepts
  → Learner composes a question (scaffolded by AI-suggested examples)
  → evaluateQ2LQuestion() applies 3-test rubric:
        shallow → feedback + invitation to try again
        deep    → guided Socratic discussion (chat() with q2lContext)

Learning analytics pipeline

Client-side — BehaviorTracker batches 158 behaviour types and flushes to POST /api/analytics/events every 5 s or 50 events. Enable with edt=true cookie or ?edt=true URL param.

Server-side — learnerModels.js maintains eight models; learnerProfile.js orchestrates them into a composite profile.

Auth and roles

OAuth flows through an external proxy. The server issues a JWT stored in the Authorization header and myke_auth cookie. AuthContext recovers tokens from the cookie on mount if the localStorage token has expired.

Role hierarchy: System Admin (email = ADMIN_EMAIL env var) → Admin → Teacher → Learner. React Router wraps routes in ProtectedRoute and RoleBasedRoute.

Storage layers

i18n

I18nContext wraps i18next with a hash-based key system. Language files load from GCS via /api/i18n/:lang so translations update without redeployment. Language instructions are injected into every AI call so generated content is also returned in the learner's language. The admin-only I18nAuditOverlay scans the DOM for non-translated strings and submits them for translation.

xAPI / LRS

xapi.js maintains a global xapiContext accumulating session metadata. Learning events are emitted as xAPI statements with custom verbs (explored, expanded, asked, completed, attempted) and posted to POST /api/xapi/statement.

Caching

All AI generation endpoints cache results in GCS by input hash:

Pass skipCache: true in the request body to force regeneration.