From fe20af747510b5339ff212f247fbdfe666b5ae22 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:17:41 +0200
Subject: [PATCH 1/9] chore: add genaiscript instructions

---
 .../instructions/genaiscript.instructions.md  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 .github/instructions/genaiscript.instructions.md

diff --git a/.github/instructions/genaiscript.instructions.md b/.github/instructions/genaiscript.instructions.md
new file mode 100644
index 00000000..a6135fec
--- /dev/null
+++ b/.github/instructions/genaiscript.instructions.md
@@ -0,0 +1,19 @@
+---
+applyTo: "**/*.genai.*"
+---
+
+## GenAIScript Code Generation Instructions
+
+GenAIScript is a custom runtime for node.js. It provides a set of unique APIs and support the TypeScript syntax, ESM, await/async.
+
+- GenAIScript documentation: https://microsoft.github.io/genaiscript/llms-full.txt
+- GenAIScript ambient type definitions: https://microsoft.github.io/genaiscript/genaiscript.d.ts
+
+## Guidance for Code Generation
+
+- you always generate TypeScript code using ESM modules for Node.JS.
+- you prefer using APIs from GenAIScript `genaiscript.d.ts` rather than node.js. Do NOT use node.js imports.
+- you keep the code simple, avoid exception handlers or error checking.
+- you add `TODOs` where you are unsure so that the user can review them
+- you use the global types in genaiscript.d.ts are already loaded in the global context, no need to import them.
+- save generated code in the `./genaisrc` folder with `.genai.mts` extension

From e91dd2418f409124383ebe68840303b5f65c9882 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:18:29 +0200
Subject: [PATCH 2/9] feat: add glossary script

---
 docs/scripts/.gitignore        |   3 +
 docs/scripts/glossary.genai.js | 164 +++++++++++++++++++++++++++++++++
 2 files changed, 167 insertions(+)
 create mode 100644 docs/scripts/.gitignore
 create mode 100644 docs/scripts/glossary.genai.js

diff --git a/docs/scripts/.gitignore b/docs/scripts/.gitignore
new file mode 100644
index 00000000..5585b550
--- /dev/null
+++ b/docs/scripts/.gitignore
@@ -0,0 +1,3 @@
+genaiscript.d.ts
+tsconfig.json
+jsconfig.json
\ No newline at end of file
diff --git a/docs/scripts/glossary.genai.js b/docs/scripts/glossary.genai.js
new file mode 100644
index 00000000..90f902ad
--- /dev/null
+++ b/docs/scripts/glossary.genai.js
@@ -0,0 +1,164 @@
+// GenAIScript to create a shared glossary from markdown files in lessons
+script({
+  title: "Generate Glossary from Lessons",
+  description: "Process all markdown files under /lessons/** to create a shared glossary.md file",
+  parameters: {
+    force: {
+      type: "boolean",
+      description: "Force regeneration of the entire glossary",
+      default: false,
+    },
+  },
+});
+
+// Find all markdown files under lessons, excluding translations
+const files = await workspace.findFiles("lessons/**/*.md", {
+  ignore: "**/translations/**",
+});
+
+console.log(`Found ${files.length} markdown files to process`);
+
+// Check if glossary.md already exists
+const glossaryPath = "glossary.md";
+let existingGlossary = "";
+try {
+  const glossaryFile = await workspace.readText(glossaryPath);
+  existingGlossary = glossaryFile?.content || "";
+  console.log("Found existing glossary.md, will extend it");
+} catch (error) {
+  console.log("No existing glossary.md found, will create new one");
+}
+
+// Extract existing terms from glossary if it exists
+const existingTerms = new Set();
+if (existingGlossary) {
+  const termMatches = existingGlossary.matchAll(/^- \*\*([^*]+)\*\*/gm);
+  for (const match of termMatches) {
+    existingTerms.add(match[1].toLowerCase());
+  }
+  console.log(`Found ${existingTerms.size} existing terms in glossary`);
+}
+
+// Process each markdown file
+let allContent = "";
+for (const file of files) {
+  console.log(`Processing: ${file.filename}`);
+  const fileContent = await workspace.readText(file.filename);
+  const content = fileContent?.content || "";
+  allContent += `\n\n--- ${file.filename} ---\n\n${content}`;
+}
+
+// Create the prompt for extracting technical terms
+$`
+You are tasked with creating a comprehensive glossary of technical terms from the provided content.
+
+## Content to analyze:
+${allContent}
+
+## Instructions:
+1. Extract technical terms related to:
+   - Generative AI and Machine Learning concepts
+   - Programming and development terms
+   - Web development technologies
+   - APIs and software development concepts
+   - AI/ML frameworks and tools
+   - Data science and computational terms
+
+2. For each term, provide a concise one-line definition (maximum 20 words)
+
+3. Focus on terms that would be valuable for developers learning about AI and JavaScript
+
+4. Exclude common programming terms that most developers would know (like "function", "variable", "array") and historical terms that are only there for the storytelling aspect of the lessons.
+
+5. Format each entry as: **Term**: Definition
+
+${
+  existingTerms.size > 0
+    ? `## Existing terms to avoid duplicating:
+${Array.from(existingTerms).join(", ")}`
+    : ""
+}
+
+## Output format:
+Provide only the glossary entries, one per line, sorted alphabetically. Do not include any headers, explanations, or other text.
+`;
+
+// Get the AI response with new terms
+const newTermsResponse = env.vars.response || "";
+
+// Combine existing and new terms
+let finalGlossary = "";
+
+if (existingGlossary && !env.vars.force) {
+  // Parse existing glossary and add new terms
+  const lines = existingGlossary.split("\n");
+  const headerEndIndex = lines.findIndex(
+    (line) => line.trim() === "" && lines[lines.indexOf(line) - 1]?.includes("technical terms")
+  );
+
+  if (headerEndIndex > 0) {
+    // Keep existing header
+    finalGlossary = lines.slice(0, headerEndIndex + 1).join("\n") + "\n";
+  } else {
+    // Create new header
+    finalGlossary = `# Glossary\n\nA comprehensive list of technical terms used throughout the lessons.\n\n`;
+  }
+
+  // Get existing entries
+  const existingEntries = [];
+  const termPattern = /^- \*\*([^*]+)\*\*: (.+)$/gm;
+  let match;
+  while ((match = termPattern.exec(existingGlossary)) !== null) {
+    existingEntries.push({ term: match[1], definition: match[2] });
+  }
+
+  // Parse new entries
+  const newEntries = [];
+  const newTermLines = newTermsResponse.split("\n").filter((line) => line.trim());
+  for (const line of newTermLines) {
+    const termMatch = line.match(/\*\*([^*]+)\*\*:\s*(.+)/);
+    if (termMatch) {
+      const term = termMatch[1].trim();
+      const definition = termMatch[2].trim();
+      if (!existingTerms.has(term.toLowerCase())) {
+        newEntries.push({ term, definition });
+      }
+    }
+  }
+
+  // Combine and sort all entries
+  const allEntries = [...existingEntries, ...newEntries];
+  allEntries.sort((a, b) => a.term.toLowerCase().localeCompare(b.term.toLowerCase()));
+
+  // Add all entries to glossary
+  for (const entry of allEntries) {
+    finalGlossary += `- **${entry.term}**: ${entry.definition}\n`;
+  }
+
+  console.log(`Added ${newEntries.length} new terms to existing glossary`);
+} else {
+  // Create completely new glossary
+  finalGlossary = `# Glossary\n\nA comprehensive list of technical terms used throughout the lessons.\n\n`;
+
+  const newTermLines = newTermsResponse.split("\n").filter((line) => line.trim());
+  const entries = [];
+
+  for (const line of newTermLines) {
+    const termMatch = line.match(/\*\*([^*]+)\*\*:\s*(.+)/);
+    if (termMatch) {
+      entries.push({ term: termMatch[1].trim(), definition: termMatch[2].trim() });
+    }
+  }
+
+  entries.sort((a, b) => a.term.toLowerCase().localeCompare(b.term.toLowerCase()));
+
+  for (const entry of entries) {
+    finalGlossary += `- **${entry.term}**: ${entry.definition}\n`;
+  }
+
+  console.log(`Created new glossary with ${entries.length} terms`);
+}
+
+// Write the glossary file
+await workspace.writeText(glossaryPath, finalGlossary);
+console.log(`Glossary saved to ${glossaryPath}`);

From 7064d25535b0550339cc6fc1297f90edcf4d08a2 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:33:57 +0200
Subject: [PATCH 3/9] chore: update instructions

---
 .github/instructions/genaiscript.instructions.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/instructions/genaiscript.instructions.md b/.github/instructions/genaiscript.instructions.md
index a6135fec..6d53bf1a 100644
--- a/.github/instructions/genaiscript.instructions.md
+++ b/.github/instructions/genaiscript.instructions.md
@@ -11,9 +11,9 @@ GenAIScript is a custom runtime for node.js. It provides a set of unique APIs an
 
 ## Guidance for Code Generation
 
-- you always generate TypeScript code using ESM modules for Node.JS.
+- you always generate JavaScript code using ESM modules for Node.JS.
 - you prefer using APIs from GenAIScript `genaiscript.d.ts` rather than node.js. Do NOT use node.js imports.
 - you keep the code simple, avoid exception handlers or error checking.
 - you add `TODOs` where you are unsure so that the user can review them
 - you use the global types in genaiscript.d.ts are already loaded in the global context, no need to import them.
-- save generated code in the `./genaisrc` folder with `.genai.mts` extension
+- save generated code with `.genai.js` extension

From 18d410c9a8deadff17a13886fe5b501134ae1f39 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:34:10 +0200
Subject: [PATCH 4/9] fix: prompt output

---
 docs/scripts/glossary.genai.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/docs/scripts/glossary.genai.js b/docs/scripts/glossary.genai.js
index 90f902ad..c6203329 100644
--- a/docs/scripts/glossary.genai.js
+++ b/docs/scripts/glossary.genai.js
@@ -49,7 +49,7 @@ for (const file of files) {
 }
 
 // Create the prompt for extracting technical terms
-$`
+const { text: newTermsResponse } = await prompt`
 You are tasked with creating a comprehensive glossary of technical terms from the provided content.
 
 ## Content to analyze:
@@ -83,9 +83,6 @@ ${Array.from(existingTerms).join(", ")}`
 Provide only the glossary entries, one per line, sorted alphabetically. Do not include any headers, explanations, or other text.
 `;
 
-// Get the AI response with new terms
-const newTermsResponse = env.vars.response || "";
-
 // Combine existing and new terms
 let finalGlossary = "";
 

From 9c0608f36c0fdb5b83e45d49bbf5a33558383e8b Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:34:19 +0200
Subject: [PATCH 5/9] docs: add glossary

---
 glossary.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 glossary.md

diff --git a/glossary.md b/glossary.md
new file mode 100644
index 00000000..3d5b416e
--- /dev/null
+++ b/glossary.md
@@ -0,0 +1,25 @@
+# Glossary
+
+A comprehensive list of technical terms used throughout the lessons.
+
+- **API**: A set of rules enabling software applications to communicate with each other, commonly used in generative AI integration.
+- **Augmented Prompt**: A prompt enhanced with additional context or information to improve the relevance of AI-generated responses.
+- **Chain-of-Thought Prompting**: A technique guiding models to break down complex tasks into sequential reasoning steps for better accuracies in outputs.
+- **Context Window**: The amount of past input that a language model can consider when generating responses, measured in tokens.
+- **CSV**: A data format consisting of values separated by commas, often used for structured data retrieval and modification.
+- **Few-Shot Prompting**: A method of providing minimal examples to the model to influence its output with specific context or format.
+- **GitHub Codespaces**: A cloud-based environment for coding, testing, and running applications directly from GitHub repositories.
+- **JSON**: A lightweight data-interchange format used for structured information exchange between systems, including generative AI responses.
+- **Large Language Model (LLM)**: AI models trained on large text datasets to generate human-like responses for diverse applications.
+- **Maieutic Prompting**: A technique involving follow-up queries to challenge or validate AI-generated responses for accuracy and reasoning.
+- **Managed Identity**: A secure cloud mechanism that provides applications with automatic authentication to access resources without managing passwords.
+- **Meta Prompts**: Instructions added before a user's prompt to refine or restrict the AI's behavior and output format.
+- **Multimodal Capabilities**: AI functionality to process various formats like text, image, or video input and deliver diverse outputs.
+- **Node.js**: A runtime environment allowing developers to execute JavaScript code server-side for building scalable applications.
+- **OpenAI**: A pioneering organization in AI research and APIs for language models integrated into applications for generative tasks.
+- **Prompt Engineering**: The process of crafting effective prompts to guide AI models toward desired responses and behaviors.
+- **RAG (Retrieval-Augmented Generation)**: A technique combining retrieval-based methods with generative models for more accurate, data-grounded outputs.
+- **System Message**: A prompt in conversational AI that specifies contextual boundaries or personality for the assistant.
+- **TensorFlow.js**: A JavaScript-based machine learning library enabling browser and Node.js-based AI/ML applications and training.
+- **Tokenizer**: A tool used to convert text into tokens, providing structure for how data is inputted or analyzed by models.
+- **XML**: A markup language formatting structured data for information storage, exchange, or generative model input/output.

From 5039a848774234b8b480a372d45791daa2b9a859 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:50:14 +0200
Subject: [PATCH 6/9] feat: improve script

---
 docs/scripts/glossary.genai.js | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/docs/scripts/glossary.genai.js b/docs/scripts/glossary.genai.js
index c6203329..75d5ded1 100644
--- a/docs/scripts/glossary.genai.js
+++ b/docs/scripts/glossary.genai.js
@@ -9,6 +9,7 @@ script({
       default: false,
     },
   },
+  temperature: 0.1,
 });
 
 // Find all markdown files under lessons, excluding translations
@@ -66,11 +67,15 @@ ${allContent}
 
 2. For each term, provide a concise one-line definition (maximum 20 words)
 
-3. Focus on terms that would be valuable for developers learning about AI and JavaScript
+3. Focus on terms that would be valuable for developers learning about AI and JavaScript. Avoid terms that are too basic or not relevant to the context of AI and JavaScript development
 
 4. Exclude common programming terms that most developers would know (like "function", "variable", "array") and historical terms that are only there for the storytelling aspect of the lessons.
 
-5. Format each entry as: **Term**: Definition
+5. Exclude terms that are too similar to existing terms. For example, "Chain of Thought" and "Chain of Thought Prompting" are too similar and should not both be included.
+
+6. Format each entry as: **Term**: Definition
+
+7. It's OK to not output anything if no new terms are found. In that case, just return an empty string.
 
 ${
   existingTerms.size > 0
@@ -85,6 +90,7 @@ Provide only the glossary entries, one per line, sorted alphabetically. Do not i
 
 // Combine existing and new terms
 let finalGlossary = "";
+let glossarySize, previousSize = 0;
 
 if (existingGlossary && !env.vars.force) {
   // Parse existing glossary and add new terms
@@ -132,6 +138,8 @@ if (existingGlossary && !env.vars.force) {
     finalGlossary += `- **${entry.term}**: ${entry.definition}\n`;
   }
 
+  previousSize = existingEntries.length;
+  glossarySize = allEntries.length;
   console.log(`Added ${newEntries.length} new terms to existing glossary`);
 } else {
   // Create completely new glossary
@@ -153,9 +161,14 @@ if (existingGlossary && !env.vars.force) {
     finalGlossary += `- **${entry.term}**: ${entry.definition}\n`;
   }
 
+  glossarySize = entries.length;
   console.log(`Created new glossary with ${entries.length} terms`);
 }
 
 // Write the glossary file
 await workspace.writeText(glossaryPath, finalGlossary);
 console.log(`Glossary saved to ${glossaryPath}`);
+
+env.output.appendContent(`Glossary generated with ${glossarySize} terms (previously ${previousSize} terms).\n\n`);
+env.output.appendContent(`Glossary saved to \`${glossaryPath}\``);
+

From cebe2e31281c3680b3e90d7027ccb3e44ca1a7bd Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:50:28 +0200
Subject: [PATCH 7/9] docs: update glossary

---
 glossary.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/glossary.md b/glossary.md
index 3d5b416e..ae43a84a 100644
--- a/glossary.md
+++ b/glossary.md
@@ -3,13 +3,24 @@
 A comprehensive list of technical terms used throughout the lessons.
 
 - **API**: A set of rules enabling software applications to communicate with each other, commonly used in generative AI integration.
+- **API key**: A private key used to authenticate requests to an application programming interface.
 - **Augmented Prompt**: A prompt enhanced with additional context or information to improve the relevance of AI-generated responses.
+- **Azure OpenAI**: A cloud service for deploying and scaling OpenAI models like GPT for applications.
+- **Braided Search**: Combines algorithmic search with human-provided examples to find more contextually relevant results in AI applications.
+- **Caesar cipher**: A substitution cipher shifting characters by a fixed number of places in the alphabet.
 - **Chain-of-Thought Prompting**: A technique guiding models to break down complex tasks into sequential reasoning steps for better accuracies in outputs.
+- **Completions API**: API to generate text or code based on inputs, used for predictive or generative tasks in AI models.
 - **Context Window**: The amount of past input that a language model can consider when generating responses, measured in tokens.
 - **CSV**: A data format consisting of values separated by commas, often used for structured data retrieval and modification.
+- **Embedding**: Numeric vector representation of data, often used for semantic search or clustering in machine learning.
 - **Few-Shot Prompting**: A method of providing minimal examples to the model to influence its output with specific context or format.
+- **Full-Stack Development**: Development of both the client (frontend) and server (backend) in software applications.
 - **GitHub Codespaces**: A cloud-based environment for coding, testing, and running applications directly from GitHub repositories.
+- **GitHub Models**: A platform hosting pre-trained AI models for use and integration with GitHub development workflows.
+- **Interactive Development Environments (IDEs)**: Software providing coding, debugging, and testing tools for developers.
 - **JSON**: A lightweight data-interchange format used for structured information exchange between systems, including generative AI responses.
+- **Knowledge Bases**: Data repositories used to enhance AI applications by providing reliable, domain-specific information.
+- **LangChain**: A framework for building AI applications that focus on chaining multiple models and functionalities together.
 - **Large Language Model (LLM)**: AI models trained on large text datasets to generate human-like responses for diverse applications.
 - **Maieutic Prompting**: A technique involving follow-up queries to challenge or validate AI-generated responses for accuracy and reasoning.
 - **Managed Identity**: A secure cloud mechanism that provides applications with automatic authentication to access resources without managing passwords.
@@ -19,7 +30,10 @@ A comprehensive list of technical terms used throughout the lessons.
 - **OpenAI**: A pioneering organization in AI research and APIs for language models integrated into applications for generative tasks.
 - **Prompt Engineering**: The process of crafting effective prompts to guide AI models toward desired responses and behaviors.
 - **RAG (Retrieval-Augmented Generation)**: A technique combining retrieval-based methods with generative models for more accurate, data-grounded outputs.
+- **Semantic Search**: Search method leveraging the meaning of terms for more contextually accurate and nuanced results.
+- **Structured Output**: Data output organized in predefined formats like tables or JSON, enabling easier integration with systems.
 - **System Message**: A prompt in conversational AI that specifies contextual boundaries or personality for the assistant.
 - **TensorFlow.js**: A JavaScript-based machine learning library enabling browser and Node.js-based AI/ML applications and training.
 - **Tokenizer**: A tool used to convert text into tokens, providing structure for how data is inputted or analyzed by models.
+- **Vector Search**: Retrieval technique comparing encoded vectors to find semantically similar information in AI applications.
 - **XML**: A markup language formatting structured data for information storage, exchange, or generative model input/output.

From 384ec4449a3cbc83f174d387d0f357bf1095b9f0 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:59:41 +0200
Subject: [PATCH 8/9] feat: improve prompt

---
 docs/scripts/glossary.genai.js | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/docs/scripts/glossary.genai.js b/docs/scripts/glossary.genai.js
index 75d5ded1..f32ce507 100644
--- a/docs/scripts/glossary.genai.js
+++ b/docs/scripts/glossary.genai.js
@@ -1,6 +1,6 @@
 // GenAIScript to create a shared glossary from markdown files in lessons
 script({
-  title: "Generate Glossary from Lessons",
+  title: "Generate glossary from lessons",
   description: "Process all markdown files under /lessons/** to create a shared glossary.md file",
   parameters: {
     force: {
@@ -57,7 +57,7 @@ You are tasked with creating a comprehensive glossary of technical terms from th
 ${allContent}
 
 ## Instructions:
-1. Extract technical terms related to:
+1. Extract technical terms from the content to analyze related to:
    - Generative AI and Machine Learning concepts
    - Programming and development terms
    - Web development technologies
@@ -69,13 +69,14 @@ ${allContent}
 
 3. Focus on terms that would be valuable for developers learning about AI and JavaScript. Avoid terms that are too basic or not relevant to the context of AI and JavaScript development
 
-4. Exclude common programming terms that most developers would know (like "function", "variable", "array") and historical terms that are only there for the storytelling aspect of the lessons.
+4. Exclude thise terms and concepts:
+   - Common programming terms that most developers would know (like "function", "variable", "array")
+   - Historical terms or concepts that are only there for the storytelling aspect of the lessons
+   - Terms that are too similar to existing terms. For example, "Chain of Thought" and "Chain of Thought Prompting" are too similar and should not both be included.
 
-5. Exclude terms that are too similar to existing terms. For example, "Chain of Thought" and "Chain of Thought Prompting" are too similar and should not both be included.
+5. Format each entry as: **Term**: Definition
 
-6. Format each entry as: **Term**: Definition
-
-7. It's OK to not output anything if no new terms are found. In that case, just return an empty string.
+6. It's OK to not output anything if no new terms are found. In that case, just return an empty string.
 
 ${
   existingTerms.size > 0
@@ -170,5 +171,5 @@ await workspace.writeText(glossaryPath, finalGlossary);
 console.log(`Glossary saved to ${glossaryPath}`);
 
 env.output.appendContent(`Glossary generated with ${glossarySize} terms (previously ${previousSize} terms).\n\n`);
-env.output.appendContent(`Glossary saved to \`${glossaryPath}\``);
-
+env.output.appendContent(`Glossary saved to \`${glossaryPath}\`.\n`);
+env.output.appendContent(`Make sure to perform a manual review before committing the changes to ensure accuracy and relevance of the terms.\n\n`);

From 051352b4bed7ebd3578ac444ab2050197e711734 Mon Sep 17 00:00:00 2001
From: sinedied <noda@free.fr>
Date: Thu, 10 Jul 2025 09:59:47 +0200
Subject: [PATCH 9/9] docs: update glossary

---
 glossary.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/glossary.md b/glossary.md
index ae43a84a..91005c02 100644
--- a/glossary.md
+++ b/glossary.md
@@ -5,18 +5,22 @@ A comprehensive list of technical terms used throughout the lessons.
 - **API**: A set of rules enabling software applications to communicate with each other, commonly used in generative AI integration.
 - **API key**: A private key used to authenticate requests to an application programming interface.
 - **Augmented Prompt**: A prompt enhanced with additional context or information to improve the relevance of AI-generated responses.
+- **Azure AI Studio**: A platform to build, evaluate, and deploy AI models using Microsoft Azure.
 - **Azure OpenAI**: A cloud service for deploying and scaling OpenAI models like GPT for applications.
-- **Braided Search**: Combines algorithmic search with human-provided examples to find more contextually relevant results in AI applications.
 - **Caesar cipher**: A substitution cipher shifting characters by a fixed number of places in the alphabet.
 - **Chain-of-Thought Prompting**: A technique guiding models to break down complex tasks into sequential reasoning steps for better accuracies in outputs.
+- **Chatbot**: An application designed to simulate conversation with human users, often using natural language processing.
 - **Completions API**: API to generate text or code based on inputs, used for predictive or generative tasks in AI models.
 - **Context Window**: The amount of past input that a language model can consider when generating responses, measured in tokens.
 - **CSV**: A data format consisting of values separated by commas, often used for structured data retrieval and modification.
 - **Embedding**: Numeric vector representation of data, often used for semantic search or clustering in machine learning.
+- **Escape Hatch**: A technique instructing AI to admit lack of knowledge when data is insufficient to ensure accurate responses.
 - **Few-Shot Prompting**: A method of providing minimal examples to the model to influence its output with specific context or format.
 - **Full-Stack Development**: Development of both the client (frontend) and server (backend) in software applications.
+- **Function Calling**: A method for passing structured prompt data into specific functions within an application programmatically.
 - **GitHub Codespaces**: A cloud-based environment for coding, testing, and running applications directly from GitHub repositories.
 - **GitHub Models**: A platform hosting pre-trained AI models for use and integration with GitHub development workflows.
+- **GitHub Token**: An authentication method to access GitHub-hosted APIs or services securely.
 - **Interactive Development Environments (IDEs)**: Software providing coding, debugging, and testing tools for developers.
 - **JSON**: A lightweight data-interchange format used for structured information exchange between systems, including generative AI responses.
 - **Knowledge Bases**: Data repositories used to enhance AI applications by providing reliable, domain-specific information.
@@ -24,6 +28,7 @@ A comprehensive list of technical terms used throughout the lessons.
 - **Large Language Model (LLM)**: AI models trained on large text datasets to generate human-like responses for diverse applications.
 - **Maieutic Prompting**: A technique involving follow-up queries to challenge or validate AI-generated responses for accuracy and reasoning.
 - **Managed Identity**: A secure cloud mechanism that provides applications with automatic authentication to access resources without managing passwords.
+- **Markdown**: A lightweight markup language for formatting plain text into structured layouts, like tables or lists.
 - **Meta Prompts**: Instructions added before a user's prompt to refine or restrict the AI's behavior and output format.
 - **Multimodal Capabilities**: AI functionality to process various formats like text, image, or video input and deliver diverse outputs.
 - **Node.js**: A runtime environment allowing developers to execute JavaScript code server-side for building scalable applications.