# SM2 Spaced Repetition MCP > SM2 Spaced Repetition uses the proven SM-2 algorithm to manage your flashcard review schedule. It calculates optimal intervals and updates difficulty factors based on how well you know a card. You can process entire batches of reviews in one go, making memory retention efficient for deep study. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** spaced-repetition, sm2, anki, algorithm, memory, study ## Description Managing what material you need to see next is tough. Most studying requires constant manual tracking: 'Was that 3 days? No, maybe 4? Should I count it as easy or good?' This MCP handles the math behind effective spaced repetition. It takes your raw performance data—like a score from 0 to 5—and runs it through the scientifically backed SM-2 algorithm. The system instantly determines the optimal next review interval and adjusts the card's difficulty factor. When you connect this MCP via Vinkius, your agent processes multiple updates in a single call. You just feed the scores, and the MCP handles all the complex scheduling logic, giving you predictable, efficient memory retention without having to manually adjust dates or factors for every single card. ## Prompt Examples **Prompt:** ``` Update my cards with these scores: ID 1: 5, ID 2: 2 ``` **Response:** ``` Card 1 is now scheduled for a longer interval, and Card 2 has been reset to a 1-day interval. ``` **Prompt:** ``` What are the default settings for a new card? ``` **Response:** ``` New cards start with an initial Easiness Factor of 2.5 and an initial interval of 1 day. ``` **Prompt:** ``` Check if these scores are valid: [6, 3, -1] ``` **Response:** ``` The scores 6 and -1 are invalid. All scores must be integers between 0 and 5. ``` ## Capabilities ### Calculate Optimal Intervals It determines the mathematically correct next review date based on user performance. ### Update Difficulty Factors The MCP adjusts a card's inherent difficulty factor (E-factor) after every successful or failed review. ### Process Review Batches You can update dozens of cards and their due dates with one single command. ### Manage Card Statuses It updates a card's status (e.g., 'due,' 'mastered') based on the input scores. ## Use Cases ### Cramming for a certification exam A paralegal needs to review 200 key legal definitions before an exam. Instead of logging into the database and manually updating dates, they feed all 200 IDs and their recall scores to `evaluate_review_batch`. The system instantly updates the due dates for everything, prioritizing what's weakest. ### Teaching a new language A tutor needs to check on three students who are learning Spanish vocabulary. They run their scores through `evaluate_review_batch` so that each student gets targeted practice—some get cards due tomorrow, others get them in two weeks. ### Managing medical knowledge A resident doctor finishes a rotation and has hundreds of drug facts to review. Running `evaluate_review_batch` allows the agent to process all performance data at once, ensuring no critical fact falls off the radar. ## Benefits - You get precise scheduling. Instead of manually estimating 'maybe next week,' the `evaluate_review_batch` tool calculates the exact optimal date using proven algorithms. - It handles volume efficiently. If you have a stack of 50 cards, you process them all in one go through batch evaluation, instead of clicking on 50 individual records. - The difficulty factor is always correct. Every score (from 0 to 5) automatically adjusts the card's underlying difficulty metric, keeping your study model accurate over time. - Predictable memory retention. You trust that the schedule isn't just a guess; it’s based on mathematical principles proven effective in cognitive science. - Time savings are massive. It removes the need to track dates across multiple spreadsheets and manual calendar entries. ## How It Works The bottom line is you get a completely accurate, mathematically driven review schedule without doing any manual math. 1. You instruct your agent to run the review cycle, providing a list of card IDs and their corresponding performance scores. 2. The MCP processes this data through the SM-2 algorithm, calculating new difficulty factors and optimal future intervals for each card in the batch. 3. Your agent receives confirmation with all updated due dates, ensuring your study schedule is accurate. ## Frequently Asked Questions **How does the SM-2 algorithm work?** It uses review quality scores (0-5) to adjust the interval between reviews and the Easiness Factor, helping to schedule reviews at the peak of your forgetting curve. Tools available: `your_tool_name`. **Can I process multiple cards at once?** Yes, the `evaluate_review_batch` tool allows you to send a batch of card updates in a single request for maximum efficiency. **What are the supported card statuses?** The system manages cards through three stages: New, Learning, and Mature. **If I give `evaluate_review_batch` scores that are out of range, what happens?** The MCP validates your input immediately. If any score or ID fails the required range (e.g., outside 0-5), the tool tells you exactly which values are invalid before processing anything else. **What is the recommended size for a batch when using `evaluate_review_batch`?** While there isn't a hard limit, keep batches under 50 cards. Processing large volumes in smaller chunks prevents timeouts and ensures reliable scheduling updates. **What specific data types must I pass to the MCP when running a review batch?** You need card IDs and integer scores. The tool expects these values to be clean integers; non-integer inputs will cause the process to fail validation. **Can I set custom default parameters for new cards before calling `evaluate_review_batch`?** Yes, you can override the standard initial settings. You specify your desired Easiness Factor or starting interval directly in the function call arguments. **If I need to calculate review intervals for a massive dataset, are there performance limitations?** The MCP is designed for high throughput. For extremely large datasets, break them into manageable batches of 25-50 cards per call to maintain optimal processing speed.