AI в образовании: персонализация, AI-тьюторы, оценка

Объясни [тему] так, как объяснил бы 14-летнему подростку без специальной подготовки.
Используй аналогию из повседневной жизни. Избегай жаргона. Длина: 3-4 абзаца.

На основе текста ниже создай 10 вопросов для проверки понимания.
Распредели: 4 вопроса на факты, 3 на понимание, 3 на применение.
Дай ответы отдельным списком.
[вставь текст параграфа]

У меня в классе разные уровни подготовки. Возьми это задание и создай
три версии: лёгкую (с подсказками), среднюю (оригинальная), сложную (с усложнением).
[вставь задание]

Проверь это эссе ученика 9 класса. Критерии: структура (введение/тело/заключение),
аргументация, примеры, грамматика. Для каждого критерия дай оценку 1-5 и
конкретный совет, что улучшить. Тон — поддерживающий, не осуждающий.
[текст эссе]

┌─────────────────────────────────────────────────────┐
│                    AI-тьютор                         │
│                                                     │
│  ┌──────────┐   ┌──────────┐   ┌─────────────────┐ │
│  │ Студент  │──▶│ Контекст │──▶│   LLM (Claude/  │ │
│  │(вопрос) │   │  сборка  │   │   GPT-4o)       │ │
│  └──────────┘   └──────────┘   └─────────────────┘ │
│                      │                    │         │
│               ┌──────┴──────┐      ┌─────▼─────┐   │
│               │  История    │      │  Ответ +   │   │
│               │  диалога    │      │  оценка    │   │
│               │  (память)   │      │  понимания │   │
│               └─────────────┘      └───────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────────┐   │
│  │           База знаний (RAG)                  │   │
│  │  Учебники | Задачи | Объяснения | Примеры    │   │
│  └──────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘

TUTOR_SYSTEM_PROMPT = """Ты AI-тьютор по математике для учеников 5-9 класса.

ПРИНЦИПЫ:
1. Никогда не давай прямой ответ на задачу — помогай ученику найти его самому
2. Задавай наводящие вопросы: «Что ты уже знаешь об этой теме?», «Какой первый шаг?»
3. Если ученик застрял — дай подсказку, а не решение
4. Хвали за правильные рассуждения, даже если ответ неверный
5. Объясняй ошибки конкретно: что именно неверно и почему
6. Адаптируй язык под уровень: используй простые слова, аналогии, примеры из жизни

ФОРМАТ ОТВЕТОВ:
- Короткие сообщения (2-4 предложения)
- Заканчивай вопросом, чтобы продолжить диалог
- Используй эмодзи умеренно для поддержки
- Никогда не выдавай финальный ответ, пока ученик сам не дойдёт до него

Текущая тема ученика: {topic}
Уровень: {grade_level}
История сессии: {session_history}
"""

import anthropic

client = anthropic.Anthropic()


def tutor_response(
    student_message: str,
    topic: str,
    grade_level: str,
    conversation_history: list[dict],
) -> str:
    """Generate Socratic tutor response."""
    system = TUTOR_SYSTEM_PROMPT.format(
        topic=topic,
        grade_level=grade_level,
        session_history=_summarize_history(conversation_history),
    )

    messages = conversation_history + [
        {"role": "user", "content": student_message}
    ]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=512,
        system=system,
        messages=messages,
    )

    return response.content[0].text


def _summarize_history(history: list[dict]) -> str:
    """Keep last 5 turns for context without blowing token budget."""
    if not history:
        return "Начало сессии"
    recent = history[-10:]  # last 5 turns (user + assistant)
    return "\n".join(
        f"{m['role'].upper()}: {m['content'][:200]}" for m in recent
    )

from dataclasses import dataclass
from enum import Enum


class Difficulty(Enum):
    EASY = 1
    MEDIUM = 2
    HARD = 3
    EXPERT = 4


@dataclass
class StudentProfile:
    topic: str
    correct_streak: int = 0
    wrong_streak: int = 0
    total_attempts: int = 0
    total_correct: int = 0

    @property
    def accuracy(self) -> float:
        if self.total_attempts == 0:
            return 0.5
        return self.total_correct / self.total_attempts

    def current_difficulty(self) -> Difficulty:
        """Adaptive difficulty based on performance."""
        if self.correct_streak >= 3:
            return Difficulty.HARD
        elif self.wrong_streak >= 2:
            return Difficulty.EASY
        elif self.accuracy > 0.8:
            return Difficulty.MEDIUM
        elif self.accuracy < 0.4:
            return Difficulty.EASY
        return Difficulty.MEDIUM

    def update(self, correct: bool) -> None:
        self.total_attempts += 1
        if correct:
            self.total_correct += 1
            self.correct_streak += 1
            self.wrong_streak = 0
        else:
            self.wrong_streak += 1
            self.correct_streak = 0


def generate_question(
    topic: str,
    difficulty: Difficulty,
    previous_questions: list[str],
    model: str = "claude-haiku-4-20250514",
) -> dict:
    """Generate adaptive question based on difficulty."""
    difficulty_prompts = {
        Difficulty.EASY: "простой вопрос с подсказкой, одно действие",
        Difficulty.MEDIUM: "стандартный вопрос из учебника, 2-3 действия",
        Difficulty.HARD: "сложный вопрос, требует нескольких шагов",
        Difficulty.EXPERT: "олимпиадный уровень, нестандартный подход",
    }

    client = anthropic.Anthropic()
    response = client.messages.create(
        model=model,
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": f"""Создай вопрос по теме «{topic}».
Уровень: {difficulty_prompts[difficulty]}.
Избегай повторов: {previous_questions[-5:] if previous_questions else 'нет'}.

Ответь JSON:
{{
  "question": "текст вопроса",
  "answer": "правильный ответ",
  "hint": "подсказка если застрял",
  "explanation": "объяснение решения"
}}""",
        }],
    )

    import json
    text = response.content[0].text
    start = text.index("{")
    end = text.rindex("}") + 1
    return json.loads(text[start:end])

ESSAY_RUBRIC = """Оцени эссе ученика по критериям (каждый 1-5 баллов):

1. СТРУКТУРА: чёткое введение, основная часть, заключение
2. АРГУМЕНТАЦИЯ: утверждения подкреплены доказательствами
3. ПРИМЕРЫ: конкретные примеры, не абстрактные слова
4. ЯЗЫК: грамматика, разнообразие лексики, стиль
5. СООТВЕТСТВИЕ ТЕМЕ: ответ на поставленный вопрос

Эссе:
{essay}

Ответь строго JSON:
{{
  "scores": {{
    "structure": N,
    "argumentation": N,
    "examples": N,
    "language": N,
    "relevance": N
  }},
  "total": N,
  "strengths": ["что хорошо (2-3 пункта)"],
  "improvements": ["что улучшить (2-3 пункта)"],
  "feedback": "общий поддерживающий комментарий (2-3 предложения)"
}}"""


def evaluate_essay(
    essay_text: str,
    grade_level: int = 9,
    model: str = "claude-sonnet-4-20250514",
) -> dict:
    """Automated essay evaluation with detailed rubric."""
    client = anthropic.Anthropic()

    response = client.messages.create(
        model=model,
        max_tokens=1024,
        system=f"Ты опытный учитель русского языка и литературы. Оцениваешь работу ученика {grade_level} класса. Тон — поддерживающий, конструктивный.",
        messages=[{
            "role": "user",
            "content": ESSAY_RUBRIC.format(essay=essay_text),
        }],
    )

    import json
    text = response.content[0].text
    start = text.index("{")
    end = text.rindex("}") + 1
    result = json.loads(text[start:end])

    # Normalize total to percentage
    max_score = 25  # 5 criteria × 5 points
    result["percentage"] = round(result["total"] / max_score * 100)
    result["grade"] = _score_to_grade(result["percentage"])

    return result


def _score_to_grade(percentage: int) -> str:
    if percentage >= 90:
        return "5"
    elif percentage >= 75:
        return "4"
    elif percentage >= 60:
        return "3"
    return "2"

import numpy as np
from anthropic import Anthropic

client = Anthropic()


def get_embedding(text: str) -> list[float]:
    """Get text embedding via OpenAI (Anthropic не имеет своих эмбеддингов)."""
    from openai import OpenAI
    oai = OpenAI()
    response = oai.embeddings.create(
        model="text-embedding-3-small",
        input=text,
    )
    return response.data[0].embedding


def cosine_similarity(a: list[float], b: list[float]) -> float:
    a, b = np.array(a), np.array(b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))


def recommend_content(
    student_profile: StudentProfile,
    content_library: list[dict],  # [{"id": ..., "title": ..., "text": ..., "embedding": [...]}]
    n: int = 5,
) -> list[dict]:
    """Recommend learning content based on student's weak areas."""
    # Build query from weak topics
    query = f"Объяснение темы: {student_profile.topic}. "
    if student_profile.accuracy < 0.6:
        query += "Базовые концепции для начинающих, простые примеры."
    else:
        query += "Продвинутые задачи, нестандартные применения."

    query_embedding = get_embedding(query)

    # Score all content
    scored = []
    for item in content_library:
        sim = cosine_similarity(query_embedding, item["embedding"])
        scored.append((sim, item))

    # Return top-N
    scored.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scored[:n]]

TUTOR_EVAL_PROMPT = """Оцени ответ AI-тьютора по критериям (1-5):

1. СОКРАТОВСКИЙ МЕТОД: помогает найти ответ, не даёт его напрямую
2. ПЕДАГОГИЧНОСТЬ: объяснение понятно, без жаргона
3. АДАПТИВНОСТЬ: учитывает уровень и контекст студента
4. ВОВЛЕЧЁННОСТЬ: заканчивает вопросом, поддерживает диалог
5. ТОЧНОСТЬ: информация верна, нет ошибок

Вопрос студента: {student_question}
Ответ тьютора: {tutor_response}

JSON: {{"scores": {{"socratic": N, "pedagogical": N, "adaptive": N,
        "engaging": N, "accurate": N}}, "total": N, "issues": [...]}}"""


def evaluate_tutor_response(
    student_question: str,
    tutor_response_text: str,
    judge_model: str = "claude-opus-4-20250514",
) -> dict:
    """LLM-as-judge for tutor quality."""
    client = Anthropic()
    response = client.messages.create(
        model=judge_model,
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": TUTOR_EVAL_PROMPT.format(
                student_question=student_question,
                tutor_response=tutor_response_text,
            ),
        }],
    )

    import json
    text = response.content[0].text
    start = text.index("{")
    end = text.rindex("}") + 1
    return json.loads(text[start:end])