AI Solution for LMS: Grading, Tests, Analytics

Even with selective verification, time savings reach 70%.

How AI Reduces Instructor Workload

Automatic assignment grading is the main driver of savings. LLMs (Claude 3.5, LLaMA 3) grade essays against a rubric, and code is evaluated via tests in Docker plus quality analysis. Typical result: 85% accuracy in full automation, the rest with manual verification. AI checks essays 450 times faster than a human.

from anthropic import Anthropic
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class AssignmentGrader:
    """AI grading for open-ended assignments"""
    def __init__(self, rubric: dict):
        self.rubric = rubric
        self.llm = Anthropic()

    def grade_essay(self, submission: str, model_answer: str) -> dict:
        """Grade essay against rubric using LLM"""
        criteria_text = '\n'.join([
            f"- {criterion}: {max_points} points. {description}"
            for criterion, (max_points, description) in self.rubric.items()
        ])
        response = self.llm.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=500,
            messages=[{
                "role": "user",
                "content": f"""Grade this student essay according to the rubric.
RUBRIC: {criteria_text}
MODEL ANSWER (for reference): {model_answer[:500]}
STUDENT SUBMISSION: {submission[:800]}
Return JSON: {{
    "scores": {{"criterion_name": score, ...}},
    "total": total_score,
    "max_total": max_possible,
    "feedback": "specific feedback in Russian",
    "strengths": ["..."],
    "improvements": ["..."]
}}"""
            }]
        )
        import json
        try:
            return json.loads(response.content[0].text)
        except Exception:
            return {'total': 0, 'feedback': 'Automatic grading error', 'error': True}

    def grade_code_assignment(self, code: str, test_cases: list[dict]) -> dict:
        """Grade code: run tests + quality analysis"""
        # Run test cases (in isolated environment)
        test_results = []
        passed = 0
        for tc in test_cases:
            try:
                # In production: Docker sandbox, timeout
                result = self._run_safely(code, tc['input'])
                correct = str(result).strip() == str(tc['expected']).strip()
                test_results.append({'input': tc['input'], 'passed': correct})
                if correct:
                    passed += 1
            except Exception as e:
                test_results.append({'input': tc['input'], 'passed': False, 'error': str(e)})
        functional_score = passed / len(test_cases) * 100
        # Code quality analysis via LLM
        quality_response = self.llm.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=200,
            messages=[{
                "role": "user",
                "content": f"""Evaluate code quality (1-10) and give brief feedback in Russian.
Consider: readability, efficiency, edge cases, style.
Code: 
"""
            }]
        )

{code[:600]}

 Return JSON: {{"quality_score": 7, "feedback": "..."}}""" }] )
import json
try:
    quality = json.loads(quality_response.content[0].text)
except Exception:
    quality = {'quality_score': 5, 'feedback': ''}
return {
    'functional_score': functional_score,
    'quality_score': quality.get('quality_score', 5),
    'total_score': functional_score * 0.7 + quality.get('quality_score', 5) * 3,
    'tests_passed': f"{passed}/{len(test_cases)}",
    'feedback': quality.get('feedback', ''),
    'test_details': test_results
}

def _run_safely(self, code: str, input_data) -> str:
    """Placeholder — in production: subprocess + Docker + timeout"""
    return "placeholder"

class QuizGenerator:
    """Generate tests from learning materials"""
    def __init__(self):
        self.llm = Anthropic()

    def generate_quiz(self, content: str, n_questions: int = 5, difficulty: str = 'medium', question_types: list = None) -> list[dict]:
        """Generate quiz from learning material"""
        if question_types is None:
            question_types = ['multiple_choice', 'true_false', 'fill_blank']
        response = self.llm.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=[{
                "role": "user",
                "content": f"""Generate {n_questions} quiz questions in Russian.
Content: {content[:1500]}
Requirements:
- Difficulty: {difficulty}
- Mix of types: {', '.join(question_types)}
- Test understanding, not memorization
- Include distractors for multiple choice
Return JSON array:
[{{
    "type": "multiple_choice",
    "question": "...",
    "options": ["A) ...", "B) ...", "C) ...", "D) ..."],
    "correct_answer": "A",
    "explanation": "Why this answer is correct"
}}]"""
            }]
        )
        import json
        try:
            return json.loads(response.content[0].text)
        except Exception:
            return []

class EarlyWarningSystem:
    """Early identification of at-risk students"""
    def compute_risk_scores(self, engagement_data: pd.DataFrame) -> pd.DataFrame:
        """
        Risk indicators for dropout/course abandonment:
        - Drop in activity over the last 2 weeks
        - Low grades + slow response time
        - Missed deadlines
        """
        risk_df = engagement_data.copy()
        # Activity trend
        risk_df['activity_trend'] = (
            risk_df['logins_last_week'] - risk_df['logins_week_before']
        ) / (risk_df['logins_week_before'] + 1)
        # Normalized risk factors
        risk_factors = pd.DataFrame({
            'low_grades': (risk_df['avg_score_last_3'] < 0.6).astype(float),
            'declining_activity': (risk_df['activity_trend'] < -0.3).astype(float),
            'missed_deadlines': (risk_df['missed_deadlines_count'] > 1).astype(float),
            'no_login_7d': (risk_df['days_since_last_login'] > 7).astype(float),
            'low_forum_activity': (risk_df['forum_posts_total'] == 0).astype(float),
        })
        # Weighted risk score
        weights = {
            'low_grades': 0.25,
            'declining_activity': 0.25,
            'missed_deadlines': 0.30,
            'no_login_7d': 0.15,
            'low_forum_activity': 0.05
        }
        risk_df['risk_score'] = sum(
            risk_factors[factor] * weight for factor, weight in weights.items()
        )
        risk_df['risk_level'] = pd.cut(
            risk_df['risk_score'],
            bins=[0, 0.3, 0.6, 1.0],
            labels=['low', 'medium', 'high']
        )
        return risk_df.sort_values('risk_score', ascending=False)

    def generate_intervention(self, student: dict) -> dict:
        """Recommended intervention by risk level"""
        risk_level = student.get('risk_level', 'low')
        interventions = {
            'low': {
                'action': 'automated_reminder',
                'message': 'Automatic reminder about active assignments',
                'urgency': 'low'
            },
            'medium': {
                'action': 'personalized_email',
                'message': 'Personalized support email generated by LLM',
                'urgency': 'medium',
                'assigned_to': 'system'
            },
            'high': {
                'action': 'mentor_outreach',
                'message': 'Personal contact from mentor/counselor',
                'urgency': 'high',
                'assigned_to': 'human_mentor'
            }
        }
        return interventions.get(risk_level, interventions['low'])

Why the Early Warning System Works

The algorithm analyzes 5 factors: declining logins, low grades, missed deadlines, forum absence. A weighted risk score automatically assigns intervention — from a reminder to a mentor call. Our projects show that implementing such a system reduces dropout rate by 15-25%, directly impacting the institution's budget.

Types of Assignments for Automation

What's Included in the Work

• LMS audit: analyze current architecture, API, constraints.
• ML layer design: select model (Claude, LLaMA, Mistral), vector DB (pgvector, ChromaDB), integration scheme.
• Development: assignment grading, test generation, early warning (as in code above), analytics dashboards.
• Testing: A/B comparison with manual grading, p99 latency measurement, accuracy on your data.
• Deployment: on your server or cloud (SageMaker, Vertex AI), set up CI/CD for model updates.
• Documentation and training: instructions for instructors, API documentation for developers.
• Support: warranty service, model fine-tuning when new courses appear.

Process of Work

1. Analytics: we examine your LMS, collect historical data (grades, logins).
2. Design: choose architecture (RAG, fine-tuning, rule-based), agree on metrics.
3. Implementation: write code, integrate with LMS, deploy infrastructure.
4. Testing: load testing (100+ concurrent requests), quality verification.
5. Deployment: phased rollout — first on 10% of students, then full rollout.

Timeline and How to Start

Project estimation takes 3 to 8 weeks depending on LMS complexity and module set. Cost is calculated individually for your scenario. We offer a turnkey solution — Retrieval-Augmented Generation (RAG) (Wikipedia) is a key pattern used in our architecture. With 5 years in EdTech and over 30 successful projects, we guarantee results. Contact us for a project assessment: we will analyze your LMS and propose the optimal solution.

Order a pilot project on one course — assess the effect before full implementation. Get a consultation from our engineer: we will assess your project.