Upload 5 files

agent.py

@@ -0,0 +1,246 @@
+"""
+AI Examiner Agent — Groq with tool calling + fallback parser for leaked function calls.
+"""
+
+import json
+import re
+import uuid
+from datetime import datetime
+from openai import OpenAI
+
+from exam_functions import (
+    start_exam, get_next_topic, end_exam, set_topic_queue, Message,
+)
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "start_exam",
+            "description": "Call once the student provided name and email. Returns list of exam topics.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "email": {"type": "string"},
+                    "name":  {"type": "string"},
+                },
+                "required": ["email", "name"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_next_topic",
+            "description": "Call to get the next exam topic. Returns empty string when no topics remain.",
+            "parameters": {"type": "object", "properties": {}, "required": []},
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "end_exam",
+            "description": "Call after giving final feedback. Saves score (0-10) permanently.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "email": {"type": "string"},
+                    "score": {"type": "number"},
+                },
+                "required": ["email", "score"],
+            },
+        },
+    },
+]
+
+SYSTEM_PROMPT = """You are an AI university examiner conducting an NLP course oral exam.
+
+RULES:
+1. Greet the student and ask for their full name and email.
+2. Once you have both, call start_exam(email, name).
+   - On error: ask to double-check details.
+   - On success: immediately call get_next_topic() to get the first topic.
+
+3. For EACH topic, conduct a dialogue:
+   - Ask an open-ended question about the topic.
+   - Move to the NEXT QUESTION (not next topic) when:
+     a) The student gives a sufficiently complete answer — ask a follow-up to go deeper.
+     b) The student says "I don't know" or similar — acknowledge and ask a different/simpler question on the SAME topic.
+     c) It becomes clear the student's level won't change with more questions — then move to the next TOPIC.
+   - Move to the NEXT TOPIC (call get_next_topic()) when:
+     a) The student's knowledge on this topic is clearly established.
+     b) The student has said "I don't know" to 2+ questions in a row on this topic.
+     c) You have asked 3+ questions and have a clear picture of the student's level.
+
+4. CRITICAL: Do NOT show the score or end the exam until get_next_topic() returns "". Cover ALL topics.
+
+5. After all topics:
+   - Show the student their score (0-10) and feedback (strengths + what to improve).
+   - Call end_exam(email, score) with the EXACT numeric score you stated.
+   - Scoring guide:
+     * 9-10: Deep, accurate, detailed answers on all topics.
+     * 7-8: Good understanding, minor gaps.
+     * 5-6: Partial understanding, significant gaps.
+     * 3-4: Mostly "I don't know", very shallow answers.
+     * 0-2: No meaningful answers at all.
+
+6. Be encouraging but STRICT and objective. "I don't know" lowers the score significantly.
+7. Match the student's language (Ukrainian or English).
+8. Never add meta-comments in parentheses. Speak naturally."""
+
+
+def _parse_leaked_calls(text: str) -> list[tuple[str, str]]:
+    """Parse <function=NAME...{json}...> in any format Llama might use."""
+    found = []
+    pattern = re.compile(r"<function=(\w+)[,\s(]*(\{.*?\})\s*\)?\s*(?:</function>)?", re.DOTALL)
+    for m in pattern.finditer(text):
+        name = m.group(1)
+        args_raw = m.group(2).strip()
+        try:
+            json.loads(args_raw)
+            args_str = args_raw
+        except (json.JSONDecodeError, ValueError):
+            args_str = "{}"
+        found.append((name, args_str))
+    return found
+
+
+class ExaminerAgent:
+    def __init__(self, api_key: str):
+        self.client = OpenAI(
+            api_key=api_key,
+            base_url="https://api.groq.com/openai/v1",
+        )
+        self.messages: list[dict] = []
+        self.history: list[Message] = []
+        self.student_email = ""
+        self.exam_finished = False
+
+    def _log(self, role: str, content: str):
+        self.history.append({
+            "role": role, "content": content,
+            "datetime": datetime.now().isoformat(timespec="seconds"),
+        })
+
+    def _dispatch(self, name: str, arguments_str: str) -> str:
+        try:
+            inputs = json.loads(arguments_str) if arguments_str and arguments_str.strip() not in ("null", "None", "") else {}
+        except json.JSONDecodeError:
+            inputs = {}
+
+        self._log("tool_call", f"{name}({arguments_str})")
+
+        if name == "start_exam":
+            try:
+                topics = start_exam(inputs["email"], inputs["name"])
+                set_topic_queue(topics)
+                self.student_email = inputs["email"]
+                return json.dumps({"topics": topics})
+            except ValueError as e:
+                return json.dumps({"error": str(e)})
+
+        elif name == "get_next_topic":
+            return json.dumps({"topic": get_next_topic()})
+
+        elif name == "end_exam":
+            score = inputs.get("score", None)
+            # Fallback: extract score from chat history if missing or zero
+            if not score:
+                for entry in reversed(self.history[-10:]):
+                    found = re.findall(r"([0-9]+(?:\.[0-9]+)?)\s*(?:out of|/)\s*10", entry.get("content", ""))
+                    if found:
+                        score = float(found[-1])
+                        break
+            if not score:
+                score = 0.0
+            if self.student_email:
+                end_exam(self.student_email, float(score), self.history)
+                self.exam_finished = True
+            return json.dumps({"status": "saved"})
+
+        return json.dumps({"error": "unknown tool"})
+
+    def _inject_leaked(self, leaked: list[tuple[str, str]]):
+        """Execute leaked tool calls and inject results into message history."""
+        for name, args_str in leaked:
+            result = self._dispatch(name, args_str)
+            fake_id = f"call_{uuid.uuid4().hex[:8]}"
+            self.messages.append({
+                "role": "assistant",
+                "content": "",
+                "tool_calls": [{"id": fake_id, "type": "function",
+                                "function": {"name": name, "arguments": args_str}}],
+            })
+            self.messages.append({"role": "tool", "tool_call_id": fake_id, "content": result})
+
+    def _run_turn(self) -> str:
+        while True:
+            try:
+                response = self.client.chat.completions.create(
+                    model="llama-3.3-70b-versatile",
+                    max_tokens=1024,
+                    tools=TOOLS,
+                    tool_choice="auto",
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        *self.messages,
+                    ],
+                )
+            except Exception as e:
+                leaked = _parse_leaked_calls(str(e))
+                if leaked:
+                    if self.messages and self.messages[-1]["role"] == "assistant":
+                        bad = self.messages.pop()
+                        clean = re.sub(r"<function=.*", "", bad.get("content", ""), flags=re.DOTALL).strip()
+                        if clean:
+                            self.messages.append({"role": "assistant", "content": clean})
+                    self._inject_leaked(leaked)
+                    continue
+                raise
+
+            msg = response.choices[0].message
+            finish_reason = response.choices[0].finish_reason
+
+            assistant_msg: dict = {"role": "assistant", "content": msg.content or ""}
+            if msg.tool_calls:
+                assistant_msg["tool_calls"] = [
+                    {"id": tc.id, "type": "function",
+                     "function": {"name": tc.function.name, "arguments": tc.function.arguments}}
+                    for tc in msg.tool_calls
+                ]
+            self.messages.append(assistant_msg)
+
+            if finish_reason != "tool_calls" or not msg.tool_calls:
+                text = msg.content or ""
+                leaked = _parse_leaked_calls(text)
+                if leaked:
+                    clean = re.sub(r"<function=.*", "", text, flags=re.DOTALL).strip()
+                    self.messages.pop()
+                    if clean:
+                        self.messages.append({"role": "assistant", "content": clean})
+                    self._inject_leaked(leaked)
+                    continue
+                self._log("system", text)
+                return text
+
+            for tc in msg.tool_calls:
+                result = self._dispatch(tc.function.name, tc.function.arguments)
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": result,
+                })
+
+    def start(self) -> str:
+        self.messages = []
+        self.history = []
+        self.student_email = ""
+        self.exam_finished = False
+        set_topic_queue([])
+        self.messages = [{"role": "user", "content": "Hello, I am ready for my exam."}]
+        return self._run_turn()
+
+    def chat(self, user_message: str) -> str:
+        self._log("user", user_message)
+        self.messages.append({"role": "user", "content": user_message})
+        return self._run_turn()

app.py

@@ -0,0 +1,191 @@
+"""
+Gradio web interface for AI Examiner Agent.
+Run:  python app.py
+"""
+
+import gradio as gr
+from agent import ExaminerAgent
+
+_agent: ExaminerAgent | None = None
+
+
+def init_exam(api_key: str):
+    """Called when the user clicks 'Start Exam'. Resets chat completely."""
+    global _agent
+
+    if not api_key.strip():
+        return [{
+            "role": "assistant",
+            "content": "⚠️ Please enter your Groq API key first."
+        }], gr.update(interactive=False)
+
+    try:
+        _agent = ExaminerAgent(api_key.strip())
+        opening = _agent.start()
+        return [{"role": "assistant", "content": opening}], gr.update(interactive=True)
+    except Exception as e:
+        _agent = None
+        return [{"role": "assistant", "content": f"❌ Error initialising agent: {e}"}], gr.update(interactive=False)
+
+
+def user_message(message: str, history: list):
+    """Called when the student sends a message."""
+    global _agent
+
+    if not message.strip():
+        return history, ""
+
+    if _agent is None:
+        return history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": "⚠️ Please click **Start Exam** first."},
+        ], ""
+
+    # Block messages after exam is finished
+    if _agent.exam_finished:
+        return history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": "✅ The exam is already finished. Click **▶ Start Exam** to start a new session."},
+        ], ""
+
+    history = history + [{"role": "user", "content": message}]
+
+    try:
+        reply = _agent.chat(message)
+    except Exception as e:
+        reply = f"❌ Agent error: {e}"
+
+    history = history + [{"role": "assistant", "content": reply}]
+    return history, ""
+
+
+# ─── UI ──────────────────────────────────────────────────────────────────────
+
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=Syne:wght@400;600;800&display=swap');
+
+body, .gradio-container {
+    background: #0d0f14 !important;
+    font-family: 'Syne', sans-serif !important;
+}
+
+.title-block {
+    text-align: center;
+    padding: 2rem 1rem 1rem;
+}
+.title-block h1 {
+    font-family: 'Syne', sans-serif;
+    font-weight: 800;
+    font-size: 2.6rem;
+    letter-spacing: -1px;
+    background: linear-gradient(135deg, #e2ff5d 0%, #00ffc2 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin: 0;
+}
+.title-block p {
+    color: #8b95a8;
+    font-family: 'Space Mono', monospace;
+    font-size: 0.82rem;
+    margin-top: 0.4rem;
+}
+
+.gr-button-primary {
+    background: linear-gradient(135deg, #e2ff5d, #00ffc2) !important;
+    color: #0d0f14 !important;
+    font-family: 'Space Mono', monospace !important;
+    font-weight: 700 !important;
+    border: none !important;
+    border-radius: 6px !important;
+}
+.gr-button-primary:hover { filter: brightness(1.1) !important; }
+
+label { color: #8b95a8 !important; font-family: 'Space Mono', monospace !important; font-size: 0.78rem !important; }
+input, textarea { background: #141820 !important; border: 1px solid #2a3040 !important; color: #e8ecf4 !important; border-radius: 6px !important; }
+
+.info-box {
+    background: #141820;
+    border: 1px solid #2a3040;
+    border-radius: 8px;
+    padding: 1rem 1.2rem;
+    font-family: 'Space Mono', monospace;
+    font-size: 0.75rem;
+    color: #5a6478;
+    line-height: 1.7;
+}
+.info-box strong { color: #e2ff5d; }
+"""
+
+with gr.Blocks(title="AI Examiner Agent") as demo:
+
+    gr.HTML("""
+    <div class="title-block">
+        <h1>⬡ AI Examiner Agent</h1>
+        <p>NLP course · oral exam simulation · powered by AI</p>
+    </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=260):
+            gr.HTML("""
+            <div class="info-box">
+                <strong>How it works</strong><br>
+                1. Paste your Groq API key<br>
+                2. Click <em>Start Exam</em><br>
+                3. Tell the bot your name &amp; email<br>
+                4. Answer NLP questions<br>
+                5. Get your score &amp; feedback
+                <br><br>
+                <strong>Demo students</strong><br>
+                test@test.com / test<br>
+                denys.kovalenko@student.lpnu.ua
+            </div>
+            """)
+
+            api_key = gr.Textbox(
+                label="Groq API Key",
+                placeholder="gsk_...",
+                type="password",
+                lines=1,
+            )
+            start_btn = gr.Button("▶ Start Exam", variant="primary")
+
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+                label="Exam Chat",
+                height=520,
+                show_label=False,
+                layout="bubble",
+            )
+            with gr.Row():
+                msg_input = gr.Textbox(
+                    placeholder="Type your answer here…",
+                    show_label=False,
+                    lines=1,
+                    scale=5,
+                    interactive=False,
+                )
+                send_btn = gr.Button("Send →", scale=1, variant="primary")
+
+    # Start Exam — clears chat history completely, creates new agent
+    start_btn.click(
+        fn=init_exam,
+        inputs=[api_key],
+        outputs=[chatbot, msg_input],
+    )
+
+    send_btn.click(
+        fn=user_message,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, msg_input],
+    )
+
+    msg_input.submit(
+        fn=user_message,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, msg_input],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(share=False, css=CSS)

exam_functions.py

@@ -0,0 +1,152 @@
+"""
+Exam backend functions for AI Examiner Agent.
+"""
+
+import json
+import random
+import os
+from datetime import datetime
+from typing import TypedDict, Literal
+
+TOPICS = [
+    "Tokenization and text preprocessing",
+    "Word embeddings (Word2Vec, GloVe, FastText)",
+    "Recurrent neural networks (RNN, LSTM, GRU)",
+    "Attention mechanism and Transformers",
+    "BERT and pre-trained language models",
+    "Named Entity Recognition (NER)",
+    "Sentiment analysis",
+    "Machine translation",
+    "Text classification",
+    "Language model evaluation metrics (BLEU, ROUGE, Perplexity)",
+]
+
+STUDENTS = [
+    {"name": "Stanislav Androshchuk", "email": "Stanislav.Androshchuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksandr Babilia", "email": "Oleksandr.Babilia.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vitalii Bahrynets", "email": "Vitalii.Bahrynets.mKNSSh.2025@lpnu.ua"},
+    {"name": "Dmytro Betsa", "email": "Dmytro.Betsa.mKNSSh.2025@lpnu.ua"},
+    {"name": "Kateryna Bilyk", "email": "Kateryna.Bilyk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Iryna Boiko", "email": "Iryna.Boiko.mKNSSh.2025@lpnu.ua"},
+    {"name": "Ihor Boklach", "email": "Ihor.Boklach.mKNSSh.2025@lpnu.ua"},
+    {"name": "Bohdan Boretskyi", "email": "Bohdan.Boretskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Yaroslav Borys", "email": "Yaroslav.Borys.mKNSSh.2025@lpnu.ua"},
+    {"name": "Denys Brativnyk", "email": "Denys.Brativnyk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksandr Vlasiuk", "email": "Oleksandr.Vlasiuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksandr Voznyi", "email": "Oleksandr.Voznyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Khrystyna Dolynska", "email": "Khrystyna.Dolynska.mKNSSh.2025@lpnu.ua"},
+    {"name": "Viktor Zharkivskyi", "email": "Viktor.Zharkivskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Olena Kalenchuk", "email": "Olena.Kalenchuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Dmytro Kostinskyi", "email": "Dmytro.Kostinskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Anastasiia Kudybovska", "email": "Anastasiia.Kudybovska.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Kuchynskyi", "email": "Vladyslav.Kuchynskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Olena Litovska", "email": "Olena.Litovska.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleh Lozovyi", "email": "Oleh.Lozovyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Roman Maior", "email": "Roman.Maior.mKNSSh.2025@lpnu.ua"},
+    {"name": "Yevhen Makarenko", "email": "Yevhen.Makarenko.mKNSSh.2025@lpnu.ua"},
+    {"name": "Serhii Matsyshyn", "email": "Serhii.Matsyshyn.mKNSSh.2025@lpnu.ua"},
+    {"name": "Maksym Myna", "email": "Maksym.Myna.mKNSSh.2025@lpnu.ua"},
+    {"name": "Artem Mikanov", "email": "Artem.Mikanov.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vitalii Mil", "email": "Vitalii.Mil.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Miniailo", "email": "Vladyslav.Miniailo.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Moiseienko", "email": "Vladyslav.Moiseienko.mKNSSh.2025@lpnu.ua"},
+    {"name": "Tymofii Nasobko", "email": "Tymofii.Nasobko.mKNSSh.2025@lpnu.ua"},
+    {"name": "Arsenii Ohar", "email": "Arsenii.Ohar.mKNSSh.2025@lpnu.ua"},
+    {"name": "Marta Oliinyk", "email": "Marta.Oliinyk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksii Oliinyk", "email": "Oleksii.Oliinyk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Roman Omelchuk", "email": "Roman.Omelchuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Maksym Orlianskyi", "email": "Maksym.Orlianskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Alina Pavliv", "email": "Alina.Pavliv.mKNSSh.2025@lpnu.ua"},
+    {"name": "Andrii Pytel", "email": "Andrii.Pytel.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksii Postovyi", "email": "Oleksii.Postovyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Myroslav Pronyshyn", "email": "Myroslav.Pronyshyn.mKNSSh.2025@lpnu.ua"},
+    {"name": "Yurii Pukhta", "email": "Yurii.Pukhta.mKNSSh.2025@lpnu.ua"},
+    {"name": "Denys Ratushniak", "email": "Denys.Ratushniak.mKNSSh.2025@lpnu.ua"},
+    {"name": "Nazar Savitskyi", "email": "Nazar.Savitskyi.mKNSSh.2025@lpnu.ua"},
+    {"name": "Oleksandr Siryk", "email": "Oleksandr.Siryk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Petro Slobodian", "email": "Petro.Slobodian.mKNSSh.2025@lpnu.ua"},
+    {"name": "Artem Somar", "email": "Artem.Somar.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Spivakov", "email": "Vladyslav.Spivakov.mKNSSh.2025@lpnu.ua"},
+    {"name": "Pavlo Stetsiuk", "email": "Pavlo.Stetsiuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Taraban", "email": "Vladyslav.Taraban.mKNSSh.2025@lpnu.ua"},
+    {"name": "Andrii Tarasov", "email": "Andrii.Tarasov.mKNSSh.2025@lpnu.ua"},
+    {"name": "Illia Feloniuk", "email": "Illia.Feloniuk.mKNSSh.2025@lpnu.ua"},
+    {"name": "Sviatoslav Shainoha", "email": "Sviatoslav.Shainoha.mKNSSh.2025@lpnu.ua"},
+    {"name": "Sviatoslav Shylkov", "email": "Sviatoslav.Shylkov.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vitalii Yuzvyn", "email": "Vitalii.Yuzvyn.mKNSSh.2025@lpnu.ua"},
+    {"name": "Vladyslav Yakymchuk", "email": "Vladyslav.Yakymchuk.mKNSSh.2025@lpnu.ua"},
+    # demo
+    {"name": "Test", "email": "test@test.com"},
+]
+
+DB_FILE = "exam_db.json"
+
+
+def _load_db() -> dict:
+    if os.path.exists(DB_FILE):
+        with open(DB_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {"exams": []}
+
+
+def _save_db(db: dict) -> None:
+    with open(DB_FILE, "w", encoding="utf-8") as f:
+        json.dump(db, f, ensure_ascii=False, indent=2)
+
+
+def start_exam(email: str, name: str) -> list[str]:
+    student = next(
+        (s for s in STUDENTS if s["email"].lower() == email.strip().lower()),
+        None,
+    )
+    if student is None:
+        raise ValueError(
+            f"Student with email '{email}' not found. Please check your email address."
+        )
+
+    topics = random.sample(TOPICS, k=random.randint(2, 3))
+
+    db = _load_db()
+    db["exams"].append({
+        "email": email,
+        "name": name,
+        "started_at": datetime.now().isoformat(),
+        "topics": topics,
+        "score": None,
+        "finished_at": None,
+    })
+    _save_db(db)
+    print(f"[DB] Exam started for {name} <{email}>. Topics: {topics}")
+    return topics
+
+
+_topic_queue: list[str] = []
+
+
+def set_topic_queue(topics: list[str]) -> None:
+    global _topic_queue
+    _topic_queue = list(topics)
+
+
+def get_next_topic() -> str:
+    if _topic_queue:
+        return _topic_queue.pop(0)
+    return ""
+
+
+class Message(TypedDict):
+    role: Literal["system", "user", "tool_call"]
+    content: str
+    datetime: str
+
+
+def end_exam(email: str, score: float, history: list[Message]) -> None:
+    db = _load_db()
+    for exam in reversed(db["exams"]):
+        if exam["email"].lower() == email.lower() and exam["score"] is None:
+            exam["score"] = score
+            exam["finished_at"] = datetime.now().isoformat()
+            exam["history"] = history
+            break
+    _save_db(db)
+    print(f"[DB] Exam finished for {email}. Score: {score}/10")

requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.30.0
+gradio>=4.44.0