NexusLearn

Personalized AI-powered learning paths platform with adaptive quizzes, a Socratic tutor, and progress tracking — built for how you actually learn.

Comment

Inspiration

The idea for NexusLearn was born out of a deeply personal frustration.

Every time I wanted to learn something new — machine learning, a new language, music theory — I'd spend the first few hours just figuring out how to learn it. Which YouTube series? Which book? What order do the concepts go in? By the time I had a plan, the motivation was half gone.

Existing platforms either locked you into their curriculum (Coursera, Udemy) or gave you a blank canvas with no structure (YouTube, Wikipedia). There was no tool that said: "Tell me what you want to learn, and I'll build the course around you — right now, instantly, for free."

Then there was the tutoring problem. I could watch a lecture and think I understood something. Then I'd try to explain it and realize I had gaps. Real understanding only came from being questioned — from a teacher who asked "But why does that work?" instead of just giving me the answer. That kind of Socratic dialogue was only available to people who could afford a tutor.

When I discovered MeDo and its deep integration with Baidu's ERNIE AI, I saw the opportunity to build something that solved both problems at once. MeDo's multi-turn conversation capability meant I could build a tutor that genuinely remembered context, adapted its questions, and guided a student through reasoning rather than just delivering content.

NexusLearn is the tool I wish existed every time I tried to teach myself something new.

What it does

NexusLearn is an AI-powered adaptive learning platform that turns any topic or document into a fully structured, personalized learning experience in under 30 seconds.

Core features:

🗺️ AI Learning Path Generator

Type any topic — "Quantum Computing", "Jazz Theory", "Corporate Finance" — and ERNIE generates a complete, structured curriculum: milestones, subtopics, resources, time estimates, and difficulty levels. No two paths are the same because they're built around your level and available study hours.

🦉 Socratic AI Tutor

The centerpiece of NexusLearn. Instead of answering questions directly, the AI tutor asks you questions — guiding you to discover answers through your own reasoning. It maintains a 10-message conversation context window, tracks where you get stuck, and adjusts the difficulty of its questions accordingly. It teaches the way the best teachers teach.

🧠 Adaptive Quiz Engine with Spaced Repetition

Quizzes that get harder when you're doing well, and easier when you're struggling — powered by the SM-2 spaced repetition algorithm (the same science behind Anki). The AI generates fresh questions for each session so you're never just memorizing the test.

📄 Document-to-Course (Doc2Course)

Upload any PDF, paste a URL, or drop in raw text — NexusLearn analyzes the content with ERNIE and generates a complete learning package: structured curriculum, flashcards, and a quiz. A 40-page research paper becomes a learnable course in 30 seconds.

📊 Progress Dashboard

A GitHub-style activity heatmap, streak tracking, XP gamification with level titles (Apprentice → Scholar → Expert → Master), and an AI Coach panel that generates personalized insights — flagging your fastest-improving topic, identifying what you've been avoiding, and suggesting your optimal study time.

👥 Study Groups

Share any learning path, compete on a leaderboard, and receive daily AI-generated group challenges. The group feature turns solo learning into a collaborative, accountable experience.

How we built it

NexusLearn was built entirely using MeDo — Baidu's full-stack AI development platform — through a series of carefully structured, iterative conversations.

The build process:

We started with a single master prompt that described the entire application architecture: database schema, API endpoints, UI layout, design system, and ERNIE integration points. MeDo's full-stack generation capability produced the complete scaffolding — authentication, routing, and core pages — from this single prompt.

From there, we used MeDo's multi-turn chat to iteratively deepen each feature:

  • ERNIE integration: Three distinct ERNIE-powered API endpoints were wired through MeDo's plugin system:

    • POST /api/ai/generate-path — curriculum generation with structured JSON output
    • POST /api/ai/generate-quiz — adaptive quiz question generation calibrated by difficulty
    • POST /api/ai/tutor-chat — Socratic tutoring with conversation history and confidence scoring

  • SM-2 algorithm: The spaced repetition logic was implemented by describing the algorithm in plain language to MeDo and having it generate the scheduling logic — next_interval = previous_interval × ease_factor, with ease_factor updating based on quiz performance.

  • Document processing: The Doc2Course pipeline was built by prompting MeDo to handle multi-format file ingestion (PDF, DOCX, TXT), text extraction, token management (3,000-word limit before ERNIE call), and structured output parsing.

  • Design system: We referenced four design inspirations — a SaaS dashboard layout, an editorial landing page with organic blob shapes, an illustrated course card library, and a large pill CTA section — describing each in detail to MeDo and having it unify them into one cohesive visual language.

Tech stack (generated by MeDo):

  • Frontend: React with Tailwind CSS, smooth page transitions, skeleton loading states
  • Backend: Node.js REST API with session authentication
  • Database: PostgreSQL (users, learning_paths, quiz_sessions, study_sessions)
  • AI: Baidu ERNIE-4.0 via MeDo plugin integration
  • Deployment: One-click via MeDo's deploy pipeline

Challenges we ran into

1. Prompting ERNIE for reliable JSON The biggest technical challenge was getting ERNIE to return consistently structured JSON — especially for complex outputs like a full curriculum with nested milestones, subtopics, and resources. We solved this by engineering explicit JSON schema instructions directly into the ERNIE prompt template, and adding a parsing fallback that gracefully handles malformed responses rather than crashing the UI.

2. Maintaining conversation context in the Socratic tutor Building a tutor that remembers what was said three messages ago required careful context window management. We settled on passing the last 8 messages as conversation_history on every API call — enough context for coherent dialogue without hitting token limits. Getting the Socratic system prompt right took multiple iterations: the tutor had to ask guiding questions without being frustratingly evasive.

3. Making spaced repetition feel natural The SM-2 algorithm is mathematically sound but can feel robotic if surfaced badly. The challenge was translating ease_factor and next_review_date into UI elements that felt motivating rather than clinical. The solution was the "Due for review" badge system — visual, urgent, but not anxiety-inducing.

4. Document token limits Long PDFs would easily exceed ERNIE's context window. We implemented a sliding window approach — extracting the first 3,000 words, generating the curriculum, then processing subsequent chunks to enrich subtopics — all orchestrated through MeDo's iterative conversation flow.

5. MeDo's iterative build model Building a complex multi-feature application through conversation required discipline. The temptation to ask MeDo to "fix everything at once" led to inconsistencies early on. We learned to isolate each broken component and address it in a dedicated follow-up turn, treating MeDo like a highly capable engineer who works best with focused, specific briefs.

Accomplishments that we're proud of

  • The Socratic tutor genuinely works. Watching it guide a user to the correct answer through questions alone — never stating the answer directly — is the single most impressive thing NexusLearn does. It feels like a real tutoring session, not a chatbot.

  • Doc2Course pipeline. Dropping a 30-page research paper PDF and getting back a structured course with milestones, flashcards, and a quiz in under 30 seconds still feels magical to us every time we test it.

  • Full production-quality app built through conversation. Every line of code in NexusLearn was generated through MeDo. There is no manually written backend code. The fact that a complex, multi-feature application with real AI integrations, a relational database, and a polished UI can emerge from carefully structured natural language prompts is something we're genuinely proud to have demonstrated.

  • The design system. We synthesized four different reference design styles into one cohesive visual language — the illustrated course cards, the editorial landing page, the SaaS dashboard layout, and the pill CTA section all feel like they belong to the same product.

  • Zero to deployed in 11 days.

What we learned

MeDo is most powerful when you treat it like a senior engineer, not a search engine. The quality of output scales directly with the quality of the prompt. Vague prompts get generic apps. Detailed, architected prompts — with explicit database schemas, ERNIE prompt templates, UI layout descriptions, and design system specifications — get production-quality applications.

Multi-turn conversation is the real innovation. It's not just about what MeDo generates in a single pass. The power comes from being able to say "the quiz result screen needs a review mistakes section" and having MeDo understand the full context of the existing application and add that feature cleanly. Treating each conversation as a stateful build session — not a series of isolated requests — was the key mental shift.

ERNIE's structured output capabilities are underestimated. With the right prompt engineering, ERNIE reliably produces complex, nested JSON — curricula, quiz questions, personalized insights — that can drive real application logic. It's not just a text generator; it's a reasoning engine that can be the backbone of an entire product.

Learning science is a product feature. Spaced repetition, the Socratic method, confidence scoring — these are not academic concepts. They are the differentiators between a quiz app and a learning platform. Every technical decision we made was grounded in what actually helps humans retain information.

What's next for NexusLearn

NexusLearn is not a hackathon project. It's a real product addressing a real gap in the edtech market, and we intend to continue building it.

Immediate roadmap (next 60 days):

  • 🎙️ Voice tutoring — speak with the Socratic AI tutor using voice input and audio responses
  • 🌐 Multi-language support — generate learning paths in any language, with ERNIE's multilingual capabilities as the backbone
  • 📱 Native mobile app — iOS and Android apps for on-the-go learning, with offline quiz mode
  • 🤝 Teacher dashboard — educators can assign NexusLearn paths to students and track class-wide progress

Medium-term vision:

  • Integrations with university LMS platforms (Canvas, Blackboard)
  • API access for organizations to build internal training programs on NexusLearn infrastructure
  • A marketplace where expert learners can publish and monetize their curated learning paths

The big picture: The gap between knowing about something and genuinely understanding it is where education fails most people. NexusLearn's Socratic tutor exists specifically to close that gap — to make the kind of deep, questioning, personalized dialogue that used to require an expensive human tutor available to anyone, anywhere, on any topic.

We believe that's worth building properly. And with MeDo and ERNIE at the foundation, we have the tools to do it.

Built With

Share this project:

Updates