Day2 Supplement Mcp

Automate and integrate Day 2 supplemental MCP workflows to reinforce and extend onboarding processes

Category: productivity Source: ai-native-camp/camp-1

Day2 Supplement Mcp is a community skill for building MCP servers that provide supplementary learning resources, covering content delivery tools, progress tracking resources, exercise generation, and structured curriculum access through the Model Context Protocol.

What Is This?

Overview

Day2 Supplement Mcp provides patterns for creating MCP servers that deliver educational supplement content to AI-powered learning assistants. It covers tool definitions for retrieving lesson materials by topic, resource endpoints for curriculum metadata and progress data, exercise generation tools that produce practice problems with solutions, and progress tracking that records completed activities. The skill enables developers to build structured learning backends that AI clients can access through standardized MCP interfaces.

Who Should Use This

This skill serves developers building AI-powered tutoring applications that need structured content delivery, teams creating learning platforms where AI assistants guide students through curricula, and educators designing supplementary material systems that integrate with conversational AI.

Why Use It?

Problems It Solves

AI tutoring assistants lack access to structured curriculum data, relying solely on general knowledge for teaching. Learning progress is lost between sessions when AI clients have no persistent storage integration. Exercise generation without a content backend produces generic problems that do not align with specific lesson objectives. Supplementary materials across multiple formats need a unified access layer.

Core Highlights

Content delivery tools serve lesson materials filtered by topic and difficulty level. Resource endpoints expose curriculum structure and learner progress as MCP resources. Exercise generators produce topic-aligned problems with answer keys and explanations. Progress tracking records completed lessons and results for adaptive learning.

How to Use It?

Basic Usage

from dataclasses import dataclass, field

@dataclass
class LessonContent:
    topic: str
    title: str
    body: str
    difficulty: str = "beginner"
    exercises: list[dict] = field(default_factory=list)

class ContentStore:
    def __init__(self):
        self.lessons: dict[str, list[LessonContent]] = {}

    def add_lesson(self, lesson: LessonContent):
        if lesson.topic not in self.lessons:
            self.lessons[lesson.topic] = []
        self.lessons[lesson.topic].append(lesson)

    def get_by_topic(self, topic: str,
                     difficulty: str = ""
                     ) -> list[LessonContent]:
        items = self.lessons.get(topic, [])
        if difficulty:
            items = [l for l in items
                     if l.difficulty == difficulty]
        return items

    def list_topics(self) -> list[str]:
        return sorted(self.lessons.keys())

class ProgressTracker:
    def __init__(self):
        self.records: dict[str, list[dict]] = {}

    def record_completion(self, user_id: str,
                          topic: str, score: float):
        if user_id not in self.records:
            self.records[user_id] = []
        self.records[user_id].append(
            {"topic": topic, "score": score})

    def get_progress(self, user_id: str) -> list[dict]:
        return self.records.get(user_id, [])

Real-World Examples

from dataclasses import dataclass, field
import random

@dataclass
class Exercise:
    question: str
    options: list[str] = field(default_factory=list)
    answer: str = ""
    explanation: str = ""

class ExerciseGenerator:
    def __init__(self, store: ContentStore):
        self.store = store

    def generate(self, topic: str,
                 count: int = 3) -> list[Exercise]:
        lessons = self.store.get_by_topic(topic)
        exercises = []
        for lesson in lessons:
            for ex_data in lesson.exercises:
                exercises.append(Exercise(
                    question=ex_data.get("q", ""),
                    options=ex_data.get("opts", []),
                    answer=ex_data.get("ans", ""),
                    explanation=ex_data.get("expl", "")))
        if len(exercises) > count:
            exercises = random.sample(exercises, count)
        return exercises

class SupplementServer:
    def __init__(self):
        self.store = ContentStore()
        self.tracker = ProgressTracker()
        self.generator = ExerciseGenerator(self.store)

    def handle_tool_call(self, name: str,
                         params: dict) -> dict:
        if name == "get_lesson":
            lessons = self.store.get_by_topic(
                params["topic"],
                params.get("difficulty", ""))
            return {"lessons": [
                {"title": l.title, "body": l.body}
                for l in lessons]}
        if name == "generate_exercises":
            exs = self.generator.generate(
                params["topic"],
                params.get("count", 3))
            return {"exercises": [
                {"q": e.question, "opts": e.options}
                for e in exs]}
        return {"error": "Unknown tool"}

Advanced Tips

Index lesson content by both topic and difficulty to enable filtered retrieval that adapts to learner level. Implement spaced repetition in the progress tracker for topics needing review. Use MCP resource endpoints to expose curriculum data that AI clients read before tool selection.

When to Use It?

Use Cases

Build a supplementary math practice server that generates exercises aligned with specific curriculum topics. Create a language learning MCP backend that delivers vocabulary lessons and tracks learner progress across sessions. Deploy a coding tutorial server that provides structured lessons and practice problems through MCP tool interfaces.

Important Notes

Requirements

Structured curriculum content organized by topic and difficulty level. A storage backend for persisting learner progress data. MCP SDK for implementing tool and resource endpoint definitions.

Usage Recommendations

Do: organize content with clear topic and difficulty metadata for accurate retrieval by AI clients. Track learner progress to enable personalized exercise selection and review scheduling. Provide answer explanations alongside solutions to support learning.

Don't: serve all lessons in a single response without filtering by topic or difficulty, which overwhelms the AI context. Store progress data without user identification, preventing individual history retrieval. Generate exercises that do not map to available lesson content.

Limitations

Exercise quality depends on the structured data in the content store. Progress tracking requires persistent storage infrastructure. MCP tool schemas must be updated when new content types or formats are added.