diff --git a/backend/nodejs/controllers/ChatController.js b/backend/nodejs/controllers/ChatController.js
index cd2503b..00c7908 100644
--- a/backend/nodejs/controllers/ChatController.js
+++ b/backend/nodejs/controllers/ChatController.js
@@ -17,6 +17,7 @@ export default class ChatController extends BaseController {
             // Read prompt and mode from the POST body
             const prompt = req.body.prompt;
             const mode = req.body.mode || "default";
+            const destination = req.body.destination || "chat";
 
             if (!prompt) {
                 return res.status(400).json({ error: "Prompt is required" });
@@ -26,18 +27,23 @@ export default class ChatController extends BaseController {
             res.setHeader("Cache-Control", "no-cache");
             res.setHeader("Connection", "keep-alive");
 
-            const stream = await this.chatService.getChatResponse(prompt, mode);
-
-            stream.on("data", (chunk) => {
-                res.write(`data: ${chunk.toString()}\n\n`);
+            const responseOrStream = await this.chatService.getChatResponse(prompt, mode);
+            if (typeof responseOrStream === 'string') {
+                res.write(`data: ${JSON.stringify({ fullContent: responseOrStream })}\n\n`);
+                res.write("data: [DONE]\n\n");
+                return res.end();
+            }
+             responseOrStream.on("data", (chunk) => {
+                res.write(chunk.toString()+"\n");
             });
-            
-            stream.on("end", () => {
+            responseOrStream.on("end", () => {
+                res.write("[DONE]\n");
                 res.end();
             });
         } catch (error) {
             console.error("Chat API Error:", error);
-            res.write("data: Error occurred while fetching response\n\n");
+            res.write(`data: {"fullContent":"ERROR: ${error.message}"}\n\n`);
+            res.write("data: [DONE]\n\n");
             res.end();
         }
     }
diff --git a/backend/nodejs/services/ChatService.js b/backend/nodejs/services/ChatService.js
index 5fd2170..b24d1e1 100644
--- a/backend/nodejs/services/ChatService.js
+++ b/backend/nodejs/services/ChatService.js
@@ -4,10 +4,18 @@ import JSONStreamService from "./JSONStreamService.js";
 export default class ChatService {
     constructor() {
         this.conversationHistory = [];
+        this.quizInProgress = false;
+        this.currentQuestion = null;
+        this.correctAnswer = null;
+        this.lastAnsweredBy = null;
     }
 
     clearHistory() {
         this.conversationHistory = [];
+        this.quizInProgress = false;
+        this.currentQuestion = null;
+        this.correctAnswer = null;
+        this.lastAnsweredBy = null;
     }
 
     async getChatResponse(prompt, mode) {
@@ -16,68 +24,172 @@ export default class ChatService {
         }
 
         let formattedPrompt;
+        let isQuizAnswer = false;
+        let immediateLocalResponse = null;
+        
         switch (mode) {
             case "steps":
+                this.clearHistory();
                 formattedPrompt = `Explain in a step by step format: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
             case "example":
+                this.clearHistory();
                 formattedPrompt = `Explain with a real world example: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
             case "flashcards":
+                this.clearHistory();
                 formattedPrompt = `Generate 10 questions and answers on this subject: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
+            case "quizmaster":
+                this.clearHistory();
+                if (prompt.toLowerCase().includes("start quiz")){
+                    const topic = prompt.replace(/start quiz/i, "").trim();
+                    formattedPrompt = `Generate exactly one question, with its answer, strictly related to '${topic}' without introducing any unrelated details, 
+                        explanations, extra text, or deviations. Respond ONLY with this JSON structure:
+                        [
+                          {
+                            "Question": "[the generated question]",
+                            "Answer": "[the generated answer]"
+                          }
+                        ]
+                        DO NOT use multiple objects in the array. Combine Question and Answer in the same object. DO NOT add any other keys, explanations, or formatting.
+                        Failure to adhere to this format will result in an invalid response. Do not include additional text, formatting, alternative structures, 
+                        variables, markdown, escapes, line breaks, or placeholders`;
+                    this.quizInProgress = true;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                } else if (this.quizInProgress && prompt.toLowerCase().includes("next question")){
+                    const topic = prompt.replace(/next question/i, "").trim();
+                    formattedPrompt = `Generate exactly one more question, with its answer, strictly related to '${topic}' without introducing any unrelated details, 
+                        explanations, extra text, or deviations. Respond ONLY with this JSON structure:
+                        [
+                          {
+                            "Question": "[the generated question]",
+                            "Answer": "[the generated answer]"
+                          }
+                        ]
+                        DO NOT use multiple objects in the array. Combine Question and Answer in the same object. DO NOT add any other keys, explanations, or formatting.
+                        Failure to adhere to this format will result in an invalid response. Do not include additional text, formatting, alternative structures, 
+                        variables, markdown, escapes, line breaks, or placeholders`;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                }else if (this.quizInProgress && prompt.toLowerCase().includes("end quiz")){
+                    this.quizInProgress = false
+                    this.currentQuestion = null;
+                    this.correctAnswer = null;
+                    this.lastAnsweredBy = null;
+                    immediateLocalResponse = "The quiz has ended. Thanks for playing!";
+                } else if (this.quizInProgress && this.currentQuestion && this.correctAnswer){
+                    isQuizAnswer = true;
+                    immediateLocalResponse = this.validateQuizAnswer(prompt);
+                }else if (this.quizInProgress){
+                    immediateLocalResponse = `I'm in quiz mode right now. Type "start quiz [topic]" to start a new quiz, "next question" for another question, or "end quiz" to finish.`;
+                } else {
+                    formattedPrompt = prompt;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                }
+                break
             default:
+                this.clearHistory();
                 formattedPrompt = prompt;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                break
+        }
+        if(immediateLocalResponse !== null || isQuizAnswer) {
+            return immediateLocalResponse;
         }
-
-        // Add user input to conversation history
-        this.conversationHistory.push({ role: "user", content: formattedPrompt });
-
         try {
-            const response = await axios.post(
-                "https://ai.api.parsonlabs.com/v1/chat/completions",
-                {
-                    model: "deepseek-r1:1.5b",
-                    messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
-                    stream: true,
-                },
-                {
-                    headers: { "Content-Type": "application/json" },
-                    responseType: "stream",
-                }
-            );
+            if(mode==='quizmaster' && this.quizInProgress){
+                const res = await axios.post(
+                    "http://bappity.net:11434/v1/chat/completions",
+                    {
+                        model: "deepseek-r1:1.5b",
+                        messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
+                    },
+                    { headers: {"Content-Type": "application/json" } }
+                );
+                const fullText = res.data.choices?.[0]?.message?.content || "";
+                this.conversationHistory.push({ role:"assistant", content: fullText.trim() });
+                return fullText;
+            }else{
+                const response = await axios.post(
+                    "http://bappity.net:11434/v1/chat/completions",
+                    {
+                        model: "deepseek-r1:1.5b",
+                        messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
+                        stream: true,
+                    },
+                    {
+                        headers: { "Content-Type": "application/json" },
+                        responseType: "stream",
+                    }
+                );
 
-            // Pipe the response stream through the JSONStreamService
-            const jsonStreamService = new JSONStreamService();
-            response.data.pipe(jsonStreamService);
+                // Pipe the response stream through the JSONStreamService
+                const jsonStreamService = new JSONStreamService();
+                response.data.pipe(jsonStreamService);
 
             // Builds and stores the assistant message as it is being streamed in
-            let assistantMessage = "";
-            jsonStreamService.on("data", (data) => {
-                try {
-                    const textData = data.toString().trim();
-                    if (textData === "[DONE]") return; // Ignore the [DONE] marker
-                    const parsedData = JSON.parse(textData);
-                    if (parsedData.fullContent) {
-                        assistantMessage = parsedData.fullContent;
+                let assistantMessage = "";
+                let previousFullContent = "";
+            
+                jsonStreamService.on("data", (data) => {
+                    try {
+                        const textData = data.toString().trim();
+                        if (textData === "[DONE]") return; // Ignore the [DONE] marker
+                        const parsedData = JSON.parse(textData);
+                        if (parsedData.fullContent) {
+                            const newFull = parsedData.fullContent;
+                            const diff = newFull.substring(previousFullContent.length);
+                            previousFullContent = newFull;
+                            assistantMessage = newFull;
+                        }
+                    } catch (e) {
+                        console.error("Error parsing streamed data:", e);
                     }
-                } catch (e) {
-                    console.error("Error parsing streamed data:", e);
-                }
-            });
+                });
 
-            // Stores the full assistant message in the conversation history array when stream ends
-            jsonStreamService.on("end", () => {
-                if (assistantMessage) {
-                    assistantMessage = assistantMessage.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-                    this.conversationHistory.push({ role: "assistant", content: assistantMessage });
-                }
-            });
+                // Stores the full assistant message in the conversation history array when stream ends
+                jsonStreamService.on("end", () => {
+                    if (assistantMessage) {
+                        const cleaned = assistantMessage.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+                        this.conversationHistory.push({ role: "assistant", content: cleaned });
+                    }
+                });
 
-            return jsonStreamService;
+                return jsonStreamService;
+            }
         } catch (error) {
             console.error("Chat API Error:", error);
             throw new Error("Error occurred while fetching response");
         }
     }
+    validateQuizAnswer(prompt){
+        let username = "";
+        let userAnswer = prompt;
+        const colonIndex = prompt.indexOf(':');
+        if (colonIndex > 0) {
+            username = prompt.substring(0, colonIndex).trim();
+            userAnswer = prompt.substring(colonIndex+1).trim();
+        }
+        if (this.isCorrectAnswer(userAnswer, this.correctAnswer)){
+            if(this.lastAnsweredBy){
+                return `That's correct, ${username}! But ${this.lastAnsweredby} already answered this question correctly. The answer is ${this.correctAnswer}. Type "next question" for another question.`;
+            }else{
+                this.lastAnsweredBy = username;
+                return `Correct, ${username} gets 1 exp!. The answer was ${this.correctAnswer}. Type "next question" for another question.`;
+            }
+        }else{
+            return `Sorry ${username}, that's not correct. Try again!`;
+        }
+    }
+    isCorrectAnswer(userAnswer, correctAnswer){
+        if (!userAnswer || !correctAnswer) return false
+
+        const normalUserAnswer = userAnswer.toLowerCase().trim();
+        const normalCorrectAnswer = correctAnswer.toLowerCase().trim();
+        if (normalUserAnswer.includes(normalCorrectAnswer) || normalCorrectAnswer.includes(normalUserAnswer)) return true;
+        return false
+    }
 }
diff --git a/backend/nodejs/services/JSONStreamService.js b/backend/nodejs/services/JSONStreamService.js
index 402cb3e..6102691 100644
--- a/backend/nodejs/services/JSONStreamService.js
+++ b/backend/nodejs/services/JSONStreamService.js
@@ -102,4 +102,4 @@ export default class JSONStreamService extends Transform {
         }
         return null;
     }
-}
\ No newline at end of file
+}
diff --git a/frontend/nodejs/public/images/AI Assistant.png b/frontend/nodejs/public/images/AI Assistant.png
new file mode 100644
index 0000000..cb2b055
Binary files /dev/null and b/frontend/nodejs/public/images/AI Assistant.png differ
diff --git a/frontend/nodejs/views/chat/partials/chatProcessing.ejs b/frontend/nodejs/views/chat/partials/chatProcessing.ejs
index 48f64fb..c638609 100644
--- a/frontend/nodejs/views/chat/partials/chatProcessing.ejs
+++ b/frontend/nodejs/views/chat/partials/chatProcessing.ejs
@@ -1,24 +1,69 @@
 <script>
     // Process AI content, separating <think> tags from visible content
     function processAIContent(content) {
-        const thinkMatch = content.match(/<think>([\s\S]*?)(?:<\/think>|$)/);
-        if (!thinkMatch) {
-            return {
-                thoughts: "",
-                visible: content
-            };
+        console.log("[parser] Raw content:", content);
+        const thoughtMatches = content.match(/<think>[\s\S]*?<\/think>/g) || [];
+        const thoughts = thoughtMatches.map(match => match.replace(/<\/?think>/g, "").trim()).join("\n");
+        const strippedContent = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        
+        let question = '';
+        let answer = '';
+
+        const isQuizMode = (window.chatMode === 'quizmaster');
+        if(isQuizMode){
+            try {
+                const jsonBlockMatch = strippedContent.match(/```json\s*([\s\S]*?)```/);
+                if (jsonBlockMatch && jsonBlockMatch[1]) {
+                    const jsonString = jsonBlockMatch[1].trim();
+                    const parsed = JSON.parse(jsonString);
+                    if (Array.isArray(parsed) && parsed.length > 0) {
+                        const first = parsed[0];
+                        question = first.Question?.toString().trim() || '';
+                        answer = first.Answer?.toString().trim() || '';
+                    }
+                } else {
+                    const start = strippedContent.indexOf('[');
+                    const end = strippedContent.lastIndexOf(']');
+                    if (start !== -1 && end !== -1) {
+                        const jsonString = strippedContent.substring(start, end + 1);
+                        const parsed = JSON.parse(jsonString);
+                        if (Array.isArray(parsed) && parsed.length > 0) {
+                            const first = parsed[0];
+                            question = first.Question?.toString().trim() || '';
+                            answer = first.Answer?.toString().trim() || '';
+                        }
+                    }
+                }
+            } catch (e) {
+                console.warn("Failed to parse JSON from AI:", e);
+            }
+            if (answer) {
+            window.quizCorrectAnswer = answer;
+            }
         }
-        const thoughtContent = thinkMatch[1];
-        let visibleContent = content.replace(/<think>[\s\S]*?(?:<\/think>|$)/, "");
-        return {
-            thoughts: thoughtContent,
-            visible: visibleContent
+        const visible = (isQuizMode && question)
+            ? `${question}\n\nYourName: YourAnswer`
+            : strippedContent;
+        return{
+            thoughts,
+            visible,
+            question,
+            answer
         };
+        console.log("[parser] Stripped content:", strippedContent);
+        console.log("[parser] Returning visible:", visible);
     }
 
+
     // Render the full AI response into the container
     function renderFullResponse(fullRawContent, container, isFinal = false) {
+        const $container = $(container);
+        if ($container.length ===0) {
+            console.error('Container not found for AI response.');
+            return;
+        }
         const processedContent = processAIContent(fullRawContent);
+        $container.empty();
         // Retrieve the current default from settings.
         const thoughtsDefault = $('input[name="thoughtsDefault"]:checked').val();
         if (typeof window.persistedThoughtsState === 'undefined') {
@@ -41,7 +86,7 @@
             innerDiv.className = 'markdown-content';
             innerDiv.innerHTML = processMathContent(processedContent.thoughts);
             detailsElement.appendChild(innerDiv);
-            container.appendChild(detailsElement);
+            container.append(detailsElement);
 
             detailsElement.addEventListener('toggle', function () {
                 window.persistedThoughtsState = detailsElement.open;
@@ -77,4 +122,4 @@
             return escapeMap[match];
         });
     }
-</script>
\ No newline at end of file
+</script>
diff --git a/frontend/nodejs/views/chat/partials/chatSettings.ejs b/frontend/nodejs/views/chat/partials/chatSettings.ejs
index 10e5fbc..ec56343 100644
--- a/frontend/nodejs/views/chat/partials/chatSettings.ejs
+++ b/frontend/nodejs/views/chat/partials/chatSettings.ejs
@@ -16,6 +16,9 @@
             <label>
                 <input type="radio" name="mode" value="flashcards"> Generate Flashcards
             </label>
+            <label>
+                <input type="radio" name="mode" value="quizmaster"> Quizmaster
+            </label>
         </div>
         <!-- New Thoughts Default Segment -->
         <div class="segment-group">
@@ -27,10 +30,21 @@
                 <input type="radio" name="thoughtsDefault" value="closed"> Closed
             </label>
         </div>
+        <!-- Output Destination -->
+        <div class="segment-group">
+            <span class="segment-group-heading">Send AI output to:</span>
+            <label>
+                <input type="radio" name="destination" value="chat" checked> Chat Window
+            </label>
+            <label>
+                <input type="radio" name="destination" value="note"> Notes Editor
+            </label>
+        </div>
     </div>
 </div>
 
 <script>
+    window.chatMode = 'default';
     // Toggle dropdown settings menu
     $('#settings-toggle').on('click', function (e) {
         e.stopPropagation();
@@ -54,10 +68,21 @@
     });
 
     //Handle mode selection
-    $('#settings-dropdown input[type="radio"]').on('change', function () {
+    $('#settings-dropdown input[type="radio"][name="mode"]').on('change', function () {
         const selectedMode = $(this).val();
         $('#response-mode').val(selectedMode);
+        window.chatMode = selectedMode;
 
         $("#prompt").attr("placeholder", `Message the AI (${$('input[name="mode"]:checked').closest("label").text().trim()})`);
+        if (selectedMode === "quizmaster") {
+            $("#quizmaster-help").show();
+        } else {
+            $("#quizmaster-help").hide();
+        }
+    });
+
+    $('#settings-dropdown input[type="radio"][name="destination"]').on('change', function() {
+        const selectedDestination = $(this).val();
+        $('#output-destination').val(selectedDestination);
     });
-</script>
\ No newline at end of file
+</script>
diff --git a/frontend/nodejs/views/chat/partials/chatStream.ejs b/frontend/nodejs/views/chat/partials/chatStream.ejs
index 2952de3..b9cfc89 100644
--- a/frontend/nodejs/views/chat/partials/chatStream.ejs
+++ b/frontend/nodejs/views/chat/partials/chatStream.ejs
@@ -1,3 +1,10 @@
+<script type="module">
+    window.quizCorrectAnswer = null;
+    window.lastQuizQuestion = null;
+    window.lastQuizAnsweredBy = null;
+    window.chatMode = null;
+</script>
+
 <script>
     $(document).ready(function () {
         // Set the placeholder based on the selected chat mode
@@ -6,75 +13,223 @@
         // Handle the form submission and stream the AI response
         $('#chat-form').on('submit', function (e) {
             e.preventDefault();
-            const prompt = $('#prompt').val();
-            const chatMode = $('input[name="mode"]:checked').val();
+            const prompt = $('#prompt').val().trim();
+            if(!prompt) return;
+            const mode = $('input[name="mode"]:checked').val();
+            if (window.chatMode === "quizmaster" && mode !== "quizmaster") {
+                $.post("/chat/reset-quiz-state");
+            }
+            window.chatMode = mode;
             const thoughtsDefault = $('input[name="thoughtsDefault"]:checked').val();
+            const destination = $('input[name="destination"]:checked').val() || 'chat';
 
             $('#prompt').val("");
             adjustTextareaHeight($('#prompt')[0]);
 
             const modeText = $('input[name="mode"]:checked').closest("label").text().trim();
-            const messageId = 'ai-response-' + Date.now();
-            $('#chat-output').append(`
-                <div class="chat-message user-message">
-                    <div class="chatboxHeader"><span>You (${modeText}):</span></div>
-                    <pre>${escapeHTML(prompt)}</pre>
-                </div>
-                <div id="${messageId}" class="chat-message ai-response">
-                    <div class="chatboxHeader"><span>AI (${modeText}):</span></div>
-                    <div class="ai-content"></div>
-                </div>
-            `);
-            updateScroll(300);
-            const container = document.querySelector(`#${messageId} .ai-content`);
+            let container=null;
+            let messageId='';
 
-            var lastFullContent = '';
-            var receivedLength = 0;
+            if(destination === 'chat'){
+                messageId = 'ai-response-' + Date.now();
+                $('#chat-output').append(`
+                    <div class="chat-message user-message">
+                        <div class="chatboxHeader"><span>You (${modeText}):</span></div>
+                        <pre>${escapeHTML(prompt)}</pre>
+                    </div>
+                    <div id="${messageId}" class="chat-message ai-response">
+                        <div class="chatboxHeader"><span>AI (${modeText}):</span></div>
+                        <div class="ai-content"></div>
+                    </div>
+                `);
+                updateScroll(300);
+                container = document.querySelector(`#${messageId} .ai-content`);
+            } else if (destination === 'note'){
+                const editor=Quill.find(document.querySelector('#editor'));
+                if (editor) {
+                    const endIndex = editor.getLength();
+                    editor.insertText(endIndex, `You: ${prompt}\n`);
+                    const aiIndex = editor.getLength();
+                    editor.insertText(aiIndex, `AI: \n`);
+                    $('#prompt').val('');
+                    window.aiResponseIndex = aiIndex;
+                    if (window.socket && typeof window.socket.emit === 'function'){
+                        const delta = editor.getContents();
+                        window.socket.emit('text-change', delta);
+                    }
+                }
+            }
+            let lastFullContent = '';
+            let receivedLength = 0;
+            let finalUpdateDone = false;
+            let partialTextArrived = false;
 
             $.ajax({
                 url: '/chat/getChatResponse',
                 type: 'POST',
                 contentType: 'application/json',
-                data: JSON.stringify({ prompt: prompt, mode: chatMode }),
+                data: JSON.stringify({ prompt: prompt, mode: mode, destination: destination
+                }),
                 xhr: function () {
                     var xhr = new window.XMLHttpRequest();
                     xhr.responseType = 'text';
                     xhr.addEventListener('progress', function () {
+                        if (destination == 'note' || mode === 'quizmaster') return;
                         const chunk = xhr.responseText.substring(receivedLength);
                         receivedLength = xhr.responseText.length;
-                        const lines = chunk.split('\n');
-                        lines.forEach(function (line) {
-                            if (line.indexOf("data: ") === 0) {
-                                const jsonPart = line.substring(6);
-                                if (jsonPart === "[DONE]") return;
-                                if (jsonPart.trim().endsWith('"}')) {
-                                    try {
-                                        // Ensure the JSON is properly formatted by replacing unescaped newlines
-                                        const sanitizedJsonPart = jsonPart.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-
-                                        const parsedData = JSON.parse(sanitizedJsonPart);
-                                        if (parsedData.fullContent) {
-                                            lastFullContent = parsedData.fullContent;
-                                            renderFullResponse(lastFullContent, container, false);
-                                            updateScroll();
-                                        }
-                                    } catch (e) {
-                                        console.error("Error parsing streamed data:", e, jsonPart);
+                        try {
+                            const lines = xhr.responseText.split('\n');
+                            let latestFullContent = "";
+                        
+                            for (let i = lines.length - 1; i >= 0; i--) {
+                                const line = lines[i].trim();
+                                if (!line || line === "[DONE]") continue;
+                            
+                                try {
+                                    const parsed = JSON.parse(line);
+                                    if (parsed && parsed.fullContent !== undefined) {
+                                        latestFullContent = parsed.fullContent;
+                                        break;
                                     }
+                                } catch (e) {
+                                    continue;
                                 }
                             }
-                        });
+                        
+                            if (latestFullContent && container) {
+                                const processed = {
+                                    thoughts: "",
+                                    visible: latestFullContent.replace(/<think>[\s\S]*?<\/think>/g, "").trim(),
+                                    question: "",
+                                    answer: ""
+                                };
+                                container.innerHTML = '';
+                                const visibleContentDiv = document.createElement('div');
+                                visibleContentDiv.className = 'markdown-content';
+                                visibleContentDiv.innerHTML = processed.visible;
+                                container.appendChild(visibleContentDiv);
+                                updateScroll();
+                            
+                                lastFullContent = latestFullContent;
+                                partialTextArrived = true;
+                            }
+                        } catch (e) {
+                            console.error("Error handling streaming response:", e);
+                        }
                     });
+                
                     xhr.addEventListener('loadend', function () {
-                        renderFullResponse(lastFullContent, container, true);
+                        console.log("Raw responseText:", this.responseText);
+                        if (finalUpdateDone) return;
+                        finalUpdateDone = true;
+                        let finalContent = lastFullContent;
+                        if (!finalContent) {
+                            try {
+                                const lines = this.responseText.split('\n');
+                                console.log("Parsed lines:", lines);
+                                for (let i = 0; i < lines.length; i++) {
+                                    for (let i = 0; i < lines.length; i++) {
+                                        const line = lines[i].trim();
+                                        if (!line || line === "data: [DONE]") continue;
+                                        let jsonPart = line;
+                                        if (line.startsWith("data: ")) {
+                                            jsonPart = line.substring(6);
+                                        }
+                                        try {
+                                            const parsed = JSON.parse(jsonPart);
+                                            if (parsed && parsed.fullContent) {
+                                                finalContent = parsed.fullContent;
+                                                break;
+                                            }
+                                        } catch (e) {
+                                            console.error("Failed to parse line:", line, e);
+                                        }
+                                    }
+                                }
+                            } catch (e) {
+                                console.error("Error extracting final content:", e);
+                            }
+                        }
+                        console.log("Final content extracted for note mode:", finalContent);
+
+                        if (finalContent) {
+                            const processed = processAIContent(finalContent);
+    
+                            if (mode === 'quizmaster') {
+                                window.lastQuizQuestion = processed.question;
+                                window.quizCorrectAnswer = processed.answer;
+                            }
+
+                            if (destination === 'chat' && container) {
+                                container.innerHTML = '';
+                                const visibleContentDiv = document.createElement('div');
+                                visibleContentDiv.className = 'markdown-content';
+                                visibleContentDiv.innerHTML = processed.visible;
+                                container.appendChild(visibleContentDiv);
+                                updateScroll();
+                            }
+
+                            if (destination === 'note') {
+                                updateNoteWithAIResponse(processed, true, mode);
+                            }
+
+                            console.log("Final visible content:", processed.visible);
+                            console.log("Correct answer set to:", window.quizCorrectAnswer);
+                        }
                     });
                     return xhr;
                 },
                 error: function (err) {
                     alert('An error occurred while streaming the response.');
                     console.error(err);
+
+                    if (destination === 'note') {
+                        const editor = Quill.find(document.querySelector('#editor'));
+                        if (editor) {
+                            const text = editor.getText();
+                            const typingIndex = text.lastIndexOf('AI is typing...');
+                            if (typingIndex !== -1) {
+                                editor.deleteText(typingIndex, 'AI is typing...'.length);
+                                editor.insertText(typingIndex, 'AI: Error occurred while fetching response');
+
+                                if (window.socket && typeof window.socket.emit === 'function') {
+                                    const delta = editor.getContents();
+                                    window.socket.emit('text-change', delta);
+                                }
+                            }
+                        }
+                    }
                 }
             });
+            function updateNoteWithAIResponse(processedContent, isFinal=false, mode) {
+                if (mode === 'quizmaster') {
+                    window.lastQuizQuestion = processedContent.question;
+                    window.quizCorrectAnswer = processedContent.answer;
+                }
+                let visibleContent = processedContent.visible.trim();
+                if (visibleContent.startsWith('"') && visibleContent.endsWith('"')) {
+                    visibleContent = visibleContent.substring(1, visibleContent.length -1).trim();
+                }
+                const editorElement = document.querySelector('#editor')
+                const editor = Quill.find(editorElement);
+                if (!editor) return;
+
+                if (typeof window.aiResponseIndex !== 'undefined'){
+                    const aiIndex = window.aiResponseIndex;
+                    const currentLength = editor.getLength();
+                    editor.deleteText(aiIndex, currentLength - aiIndex);
+                    editor.insertText(aiIndex, `AI: ${visibleContent}\n`);
+                } else {
+                    const currentLength = editor.getLength();
+                    editor.insertText(currentLength, `AI: ${visibleContent}\n`);
+                }
+                if (window.socket && typeof window.socket.emit === 'function') {
+                    const delta = editor.getContents();
+                    window.socket.emit('text-change', delta);
+                
+                }
+            }
+            adjustTextareaHeight($('#prompt')[0]);
         });
 
         // Adjust textarea height on keydown and input events
@@ -90,4 +245,4 @@
         });
         adjustTextareaHeight($('#prompt')[0]);
     });
-</script>
\ No newline at end of file
+</script>
diff --git a/frontend/nodejs/views/notes/notesAI.ejs b/frontend/nodejs/views/notes/notesAI.ejs
index cee6f06..7a1bf64 100644
--- a/frontend/nodejs/views/notes/notesAI.ejs
+++ b/frontend/nodejs/views/notes/notesAI.ejs
@@ -14,6 +14,7 @@
         </div>
 
         <div id="ai-assistant">
+            <img src="/images/AI Assistant.png" alt="AI Assistant" style="max-width: 100%; height: auto; display: block; margin-bottom: 10px;">
             <h2>Ai Assistant</h2>
             <%- include('../chat/partials/chatSettings.ejs') %>
 
@@ -24,6 +25,17 @@
                 <button type="submit">Send</button>
             </form>
 
+        <div id="quizmaster-help" style="display: none; margin-top: 10px; padding: 10px; background-color: #f5f5f5; border-radius: 5px;">
+            <h4 style="margin-top: 0;">Quizmaster Mode</h4>
+            <p>When Quizmaster mode is active and output is set to "Notes Editor", the AI will post quiz questions directly to the shared notes.</p>
+            <ul style="margin-bottom: 0;">
+                <li><strong>Start a quiz:</strong> Type "start quiz [topic]" </li>
+                <li><strong>Answer questions:</strong> Type your answer in the note (prefix your answer with your name and colon) </li>
+                <li><strong>Next question</strong> Type "next question" or "next question [topic]" </li>
+                <li><strong>End quiz:</strong> Type "end quiz" to finish. </li>
+            </ul>
+        </div>
+
             <div id="chat-output"></div>
             <%- include('../chat/partials/ui/chatUIMessages.ejs') %>
             <%- include('../chat/partials/ui/chatUIMarkup.ejs') %>
@@ -36,3 +48,16 @@
     <!-- AI Chat Processing -->
     <%- include('../chat/partials/chatProcessing.ejs') %>
     <%- include('../chat/partials/chatStream.ejs') %>
+<script>
+    function notesAIInit() {
+        if(typeof UI !=='undefined' && typeof UI.init === 'function'){
+            UI.init();
+        }
+        if (!Editor || !Editor.quill) {
+            setTimeout(notesAIInit, 300);
+            return;
+        }
+    }
+
+    $(document).ready(notesAIInit);
+    </script>
diff --git a/frontend/nodejs/views/notes/partials/components/editor.ejs b/frontend/nodejs/views/notes/partials/components/editor.ejs
index 0e25c14..5965661 100644
--- a/frontend/nodejs/views/notes/partials/components/editor.ejs
+++ b/frontend/nodejs/views/notes/partials/components/editor.ejs
@@ -3,6 +3,7 @@
     // Editor Setup
     // -----------------------------
     const Editor = {
+        quill: null,
         init() {
             // Initialize Quill editor and modules
             Quill.register('modules/cursors', QuillCursors);
@@ -21,90 +22,122 @@
         setupEventListeners() {
             // Listen for text changes and broadcast updates
             this.quill.on('text-change', (delta, oldDelta, source) => {
-                if (source === 'user') {
-                    State.changes.push(delta);
-                    // Send user inactivity signal after 10s
-                    Utils.timer('inactivity', WebSocketManager.sendInactivitySignal, 10000);
-                    // Delay sending changes to the server for batching
-                    Utils.timer('delay', () => {
-                        let combinedChanges = new this.Delta();
-                        State.changes.forEach(change => {
-                            combinedChanges = combinedChanges.compose(change);
-                        });
-                        try {
-                            const content = JSON.stringify(combinedChanges);
-                            API.updateNote(content, State.currentID);
-                            State.changes = [];
-                        } catch (error) {
-                            console.error(error);
-                        }
-                    }, 1000);
-                    // Send live update via WebSocket if connected
-                    WebSocketManager.sendUpdate(delta.ops);
-                }
-            });
+                if (source !== 'user') return;
+                console.log("[editor] text-change fired");
+                const enteredNewline = delta.ops.some(op => typeof op.insert === 'string' && op.insert.includes('\n'));
+                if (!enteredNewline) return;
+                setTimeout(() => {
+                    console.log("[editor] Checking last line after Enter");
+                    const text = this.quill.getText().trim();
+                    const lines = text.split('\n').filter(line => line.trim() !== '');
+                    const lastLine = lines[lines.length - 1];
+                    console.log("[editor] Last line:", lastLine);
+                    console.log("[editor] Current correct answer:", window.quizCorrectAnswer);
 
-            // Listen for cursor/selection changes and broadcast position
-            this.quill.on('selection-change', (range, oldRange, source) => {
-                if (source === 'user' && State.ws?.id) {
-                    this.cursors.moveCursor(State.ws.id, range);
-                    this.cursors.update();
-                    WebSocketManager.sendCursorPosition(State.ws.id, range);
-                }
-            });
-        },
+                    const match = lastLine.match(/^(.+?):\s*(.+)$/);
+                    console.log("[editor] Regex match result:", match);
+                    if (match && window.quizCorrectAnswer) {
+                        const username = match[1].trim();
+                        const userAnswer = match[2].trim();
 
-        setContent(data) {
-            if (data.id && data.id.length > 0) {
-                State.currentID = data.id;
+                        if (isCorrectAnswer(userAnswer, window.quizCorrectAnswer)) {
+                            const message = `Correct, ${username}!`;
+                            this.quill.insertText(this.quill.getLength(), `\n${message}\n`);
+                            window.lastQuizAnsweredBy = username;
+                            window.quizCorrectAnswer = null;
+                        } else {
+                            const message = `Sorry, ${username}, try again.`;
+                            this.quill.insertText(this.quill.getLength(), `\n${message}\n`);
+                        }
+                    }
+                }, 50);
+                State.changes.push(delta);
+                // Send user inactivity signal after 10s
+                Utils.timer('inactivity', WebSocketManager.sendInactivitySignal, 10000);
+                // Delay sending changes to the server for batching
+                Utils.timer('delay', () => {
+                    let combinedChanges = new this.Delta();
+                    State.changes.forEach(change => {
+                        combinedChanges = combinedChanges.compose(change);
+                    });
+                    try {
+                        const content = JSON.stringify(combinedChanges);
+                        API.updateNote(content, State.currentID);
+                        State.changes = [];
+                    } catch (error) {
+                        console.error(error);
+                    }
+                }, 1000);
+                // Send live update via WebSocket if connected
+                WebSocketManager.sendUpdate(delta.ops);
+            });
+        // Listen for cursor/selection changes and broadcast position
+        this.quill.on('selection-change', (range, oldRange, source) => {
+            if (source === 'user' && State.ws?.id) {
+                this.cursors.moveCursor(State.ws.id, range);
+                this.cursors.update();
+                WebSocketManager.sendCursorPosition(State.ws.id, range);
             }
-            this.quill.deleteText(0, this.quill.getLength());
-            this.quill.setContents(JSON.parse(data.content));
-            this.quill.enable();
-        },
+        });
+    },
 
-        setPreviewContent(data) {
-            this.quill.deleteText(0, this.quill.getLength());
-            this.quill.setContents(JSON.parse(data.content));
-            this.quill.disable();
-        },
+    setContent(data) {
+        if (data.id && data.id.length > 0) {
+            State.currentID = data.id;
+        }
+        this.quill.deleteText(0, this.quill.getLength());
+        this.quill.setContents(JSON.parse(data.content));
+        this.quill.enable();
+    },
 
-        clearOtherUserCursors() {
-            this.cursors.cursors().forEach(cursor => {
-                // Don't remove our own cursor
-                if (State.ws && cursor.id !== State.ws.id) {
-                    this.cursors.removeCursor(cursor.id);
-                }
-            });
-        },
+    setPreviewContent(data) {
+        this.quill.deleteText(0, this.quill.getLength());
+        this.quill.setContents(JSON.parse(data.content));
+        this.quill.disable();
+    },
 
-        removeCursor(id) {
-            // Only remove if it exists and isn't ours
-            if (id && (!State.ws || id !== State.ws.id)) {
-                this.cursors.removeCursor(id);
-                console.log(`Removed cursor for user ${id}`);
+    clearOtherUserCursors() {
+        this.cursors.cursors().forEach(cursor => {
+            // Don't remove our own cursor
+            if (State.ws && cursor.id !== State.ws.id) {
+                this.cursors.removeCursor(cursor.id);
             }
-        },
+        });
+    },
 
-        updateContentFromWS(delta) {
-            try {
-                this.quill.updateContents(delta);
-                this.quill.update();
-            } catch (error) {
-                console.error('Error parsing message:', error);
-            }
-        },
+    removeCursor(id) {
+        // Only remove if it exists and isn't ours
+        if (id && (!State.ws || id !== State.ws.id)) {
+            this.cursors.removeCursor(id);
+            console.log(`Removed cursor for user ${id}`);
+        }
+    },
 
-        createCursor(id, name, color) {
-            if (!this.cursors.cursors().some(cursor => cursor.id === id)) {
-                this.cursors.createCursor(id, name, color);
-            }
-        },
+    updateContentFromWS(delta) {
+        try {
+            this.quill.updateContents(delta);
+            this.quill.update();
+        } catch (error) {
+            console.error('Error parsing message:', error);
+        }
+    },
 
-        updateCursorPosition(id, range) {
-            this.createCursor(id, 'OtherUser', 'orange');
-            this.cursors.moveCursor(id, range);
-            this.cursors.update();
+    createCursor(id, name, color) {
+        if (!this.cursors.cursors().some(cursor => cursor.id === id)) {
+            this.cursors.createCursor(id, name, color);
         }
-    };
-</script>
\ No newline at end of file
+    },
+
+    updateCursorPosition(id, range) {
+        this.createCursor(id, 'OtherUser', 'orange');
+        this.cursors.moveCursor(id, range);
+        this.cursors.update();
+    }
+};
+function isCorrectAnswer(userAnswer, correctAnswer) {
+    if (!userAnswer || !correctAnswer) return false;
+    const normUser = userAnswer.toLowerCase().trim();
+    const normCorrect = correctAnswer.toLowerCase().trim();
+    return normUser === normCorrect || normUser.includes(normCorrect) || normCorrect.includes(normUser);
+}
+</script>