+
+ 
+
+ 
+
+ 
+
+
+## Node
+Let's have a closer look of the workflow above. That whole process is simply made up of a few connected steps: **Uploading the image, Extracting the information, and Combining the results**.
+
+Each of these steps is called a **Node**.
+
+Think of them like runners in a relay race: each node has a specific task. Once it finishes its turn, it passes the baton to the next node in line.
+
+Dify offers you a box of ready-to-use nodes, such as the LLM, Knowledge Retrieval, If/Else, Tools, etc. You can connect these nodes just by dragging and dropping—it's like building with the Lego blocks! You can easily snap them together to create a powerful automated workflow.
+
+## It's Your Turn
+1. Go [Dify](https://dify.ai/) and click **Get Started** in the upper right corner.
+2. Click on Explore. This is a library which collects different workflow of different scenarios.
+
+
+ 
+
+3. Pick a template that looks like a right fit for you.Don't worry if you don't understand every setting yet—just look at how the nodes are connected.
\ No newline at end of file
diff --git a/en/use-dify/tutorials/workflow-101/lesson-02.mdx b/en/use-dify/tutorials/workflow-101/lesson-02.mdx
new file mode 100644
index 000000000..37a292b67
--- /dev/null
+++ b/en/use-dify/tutorials/workflow-101/lesson-02.mdx
@@ -0,0 +1,178 @@
+---
+title: "Lesson 2: Head and Tail (Start & Output Node)"
+sidebarTitle: Lesson 2
+---
+
+In the last lesson, we compared a Workflow to a Recipe. Today, we are stepping into the professional kitchen to prep our ingredients (Start) and get our serving plates ready (Output).
+
+## Creating the App
+
+
+
+
+
+
+
+ 
+
+
+Remember the Nodes we learned in Lesson 1? The user input node you see on the canvas now is where everything begins.
+
+Every complete workflow relies on a basic skeleton: the Start Node (The Head) and the End Node (The Tail).
+
+## The Start Node
+
+
+ 
+
+
+The Start Node is the only entrance to your entire workflow. It's like the "Prep Ingredients" step in cooking. Its job is to define what information the workflow needs to receive from the user to get started.
+
+We just selected "User Input" as our Start Node.
+
+### Core Concept: Variables
+
+Inside the Start Node, you will see the word **Variable**. Don't panic! You can think of a variable as a **Storage Box with a Label**.
+
+Each box is designed to hold a specific type of information:
+
+For example, if you are building a "Travel Planner", you need the user to provide two pieces of information: `Destination` and `Travel Days`.
+
+User A might want to go to "Japan for 5 days". User B might want to go to "Paris for 3 days".
+
+Every user provides different content, so every time the app runs, the stuff inside these "boxes" changes.
+
+This is the meaning of a "Variable"—digging a hole for the user to fill, helping your workflow to handle different requests flexibly every time.
+
+## The End Node (Output)
+
+
+ 
+
+
+This is the finish line of the workflow. Think of it as Serving the Dish and it defines what the user actually sees at the very end.
+
+For example, remember that Travel Planner we talked about? If the user inputs Destination: Paris and Duration: 5 Days in the User Input Node. The Output Node is where the system finally hands over the result: "Here is your complete 5-Day Itinerary for Paris."
+
+
+
+
+ 2. In the popup, we will create two variables (two storage boxes):
+
+ **Variable 1 (For the Customer Name)**
+
+
+ 
+
+
+ - Field Type: Text (Short Text)
+ - Variable Name: `customer_name`
+ - Label Name: Customer Name
+ - Keep other options as default and click **Save**
+
+ **Variable 2 (For the Email Content)**
+
+
+ 
+
+
+ - Field Type: Click the dropdown and select **Paragraph** (Since emails are usually long, a Paragraph box is bigger and holds more text)
+ - Variable Name: `email_content`
+ - Label Name: Original Email
+ - Max Length: Manually change this to **2000** to ensure it fits long emails
+
+ 
+
+ 
+
+
+We have successfully built basic frame of the workflow. The empty space in the middle is where we will place the LLM (AI Brain) Node in the next lesson to process this information.
+
+## Mini Challenge
+
+**Task**: If you needed to create a Travel Plan Generator, what variables should the Start Node include?
+
+
+
+
+In Lesson 2, we set up the Ingredients (Start Node) and the Serving Plate (Output Node). If the Start Node is the prep cook, the LLM Node is the Master Chef. It is the brain and core of your workflow. It handles all the thinking, analyzing, and creative writing. Whether you want to summarize an article, write code, or draft an email, this is the node that does the heavy lifting.
+
+## Configure the Model
+
+Before getting started, we need to connect to a Model Provider.
+
+
+
+ 
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+### Key Concept: The Prompt (The Instructions)
+
+**What is a Prompt?** Think of the Prompt as the specific note you attach to the order ticket. It tells the AI exactly **what to do** and **how to do it**.
+
+The most critical part is the ability to use **Variables** from the Start Node directly within your Prompt. This allows the AI to adapt its output based on the different "raw materials" you provide each time.
+
+In Dify, when you insert a variable like `customer_name` into the prompt, you are telling the AI: _"Go and look in the box labeled Customer Name and use the text inside."_
+
+## Hands-On 2: Write the Prompt
+
+Now, let's apply this. We are going to write a prompt that mixes instructions with our variables.
+
+
+
+
+ 
+
+
+ 5. Using the same way, select **customer name** in the prompt and replace it with the `customer_name` variable.
+ 
+
+ 
+
+
+ 
+
+
+ 
+
\ No newline at end of file
diff --git a/en/use-dify/tutorials/workflow-101/lesson-04.mdx b/en/use-dify/tutorials/workflow-101/lesson-04.mdx
new file mode 100644
index 000000000..c08fc1dbe
--- /dev/null
+++ b/en/use-dify/tutorials/workflow-101/lesson-04.mdx
@@ -0,0 +1,203 @@
+---
+title: "Lesson 4: The Cheat Sheet (Knowledge Retrieval)"
+sidebarTitle: Lesson 4
+---
+
+In the previous lessons, our AI email assistant can draft basic emails. But what if a customer asks about specific pricing plans or refund policy, the AI might start "Hallucinating"—which is a fancy way of saying it's "confidently making things up."
+
+How do we stop the AI from hallucination? We give it a Cheat Sheet.
+
+## What is Retrieval Augmented Generation (RAG)
+
+The technical name for this is RAG (Retrieval-Augmented Generation). Think of it as turning the AI from a chef who memorizes general recipes into a chef who has a Specific Cookbook right on the counter.
+
+It happens in three simple steps:
+
+**1. Retrieval (Find the Recipe)**
+
+When a user asks a question, the AI flips through your "Cookbook" (the files you uploaded) to find the most relevant pages.
+
+Example: Someone asks for "Grandma's Special Apple Pie." You go find that specific recipe page.
+
+**2. Augmentation (Prepare the Ingredients)**
+
+The AI takes that specific recipe and puts it right in front of its eyes so it doesn't have to rely on memory.
+
+Example: You lay the recipe on the counter and get the exact apples and cinnamon ready.
+
+**3. Generation (The Baking)**
+
+The AI writes the answer based only on the facts it just found.
+
+Example: You bake the pie exactly as the recipe says, ensuring it tastes like Grandma's, not a generic store-bought version.
+
+## The Knowledge Retrieval Node
+
+Think of this as placing a stack of reference materials right next to your AI Assistant. When a user asks a question, the AI first flips through this "Cheat Sheet" to find the most relevant pages. Then, it combines those findings with the user's original question to think of the best answer.
+
+In this practice, we will use the Knowledge Retrieval node to provide our AI Assistant with official "Cheat Sheets," ensuring its answers are always backed by facts!
+
+### Hands-On 1: Create the Knowledge Base
+
+
+
+
+ In Dify, you can sync from Notion or a website, but for today, let's upload a file from your device. Click [here](https://drive.google.com/file/d/1imExB0-rtwASbmKjg3zdu-FAqSSI7-7K/view) to download Dify Intro for the upload later.
+ 
+
+ 
+
+
+ **Index Method**
+
+ - **High Quality**: Use LLM model to process documents for more precise retrieval helps LLM generate high-quality answers
+ - **Economical**: Using 10 keywords per chunk for retrieval, no tokens are consumed at the expense of reduced retrieval accuracy
+
+
+ 
+
+ 
+
+
+ **Inverted Index**: This is the default structure Dify uses. Think of it like the Index at the back of a book—it lists key terms and tells Dify exactly which pages they appear on. This allows Dify to instantly jump to the right knowledge card based on keywords, rather than reading the whole book from start.
+
+ **Top K**: You'll see a slider set to 3. This tells Dify: "When the user asks a question, find the top 3 most relevant Knowledge Cards from the cookbook to show the AI." If you set it higher, the AI gets more context to read, but if it's too high, it might get overwhelmed with too much information.
+
+ 
+
+ 
+
+ 
+
+
+ Choose **What's Dify**, and click **Add**.
+
+
+ 
+
+ 
+
+ 
+
+
+ 
+
+ 
+
+
+## Mini Challenge
+
+1. What happens if a customer asks a question that isn't in the knowledge base?
+2. What kind of information could you upload as a knowledge base?
+3. Explore Chunk Structure, Index Method, and Retrieval Setting.
diff --git a/en/use-dify/tutorials/workflow-101/lesson-05.mdx b/en/use-dify/tutorials/workflow-101/lesson-05.mdx
new file mode 100644
index 000000000..28c0f9c3e
--- /dev/null
+++ b/en/use-dify/tutorials/workflow-101/lesson-05.mdx
@@ -0,0 +1,163 @@
+---
+title: "Lesson 5: The Crossroads of Your Workflow (Sorting and Executing)"
+sidebarTitle: Lesson 5
+---
+
+Right now, our Email Assistant treats every message following the same path of the workflow. That's not smart enough. An email asking about Dify's price should be handled differently than an email on bug reporting.
+
+To make our assistant truly intelligent, we need to teach it how to "Read the Room." We're going to set up a Crossroads that sends different types of emails down different tracks.
+
+## The If/Else Node
+
+
+ 
+
+
+If/Else node is just like a traffic light. It checks a condition (like: "Does this email mention pricing?") and sends the flow left or right based on the result.
+
+### Hands-On 1: Set up the Crossroads
+
+Let's upgrade our assistant so it can tell the difference between "Dify-related" emails and "Everything else."
+
+
+
+
+ 3. The Logic: Keep it as **Contains**. Type **Dify** in the input box
+
+
+ 
+
+
+ Now, the complete logic for the IF branch is: "If the email content contains the word 'Dify'."
+ 
+
+
+**B. The Unrelated Email Track (ELSE Branch)**
+
+For emails that are not related or mention Dify, we want to create a simple, polite, and general reply process.
+
+1. Create a new Node: Click the **(+)** next to ELSE and select a new **LLM Node (LLM 2)**
+2. Add prompt to this LLM node in system, using the prompt below:
+
+```text
+You are a professional customer service manager. Based on the `{x} email_content`, kindly inform the user that no relevant information was found and provide relevant guidance.
+
+Requirements:
+1. Address the customer as `{x} customer_name}` in a friendly tone.
+2. Thank them for their letter.
+3. Keep the tone professional and friendly.
+4. Sign off as "Anne."
+```
+
+
+ 
+
+
+Now we have two tracks generating two different replies. Imagine if we had 10 tracks, our workflow would look like a messy plate of spaghetti. To keep things clean, we use a Variable Aggregator. Think of it as a Traffic Hub where all the different roads merge back into one main highway.
+
+## Variable Aggregator
+
+
+ 
+
+
+Variable Aggregator is like a traffic hub where all the different roads merge back into one main highway.
+
+### Hands-On 3: Add Variable Aggregator
+
+
+
+ 
+
+
+ Now, no matter which LLM node generates the response, the Variable Aggregator node gathers the content and hands it to the Output Node.
+ 
+
+
+ Here's how the workflow looks:
+
+
+ 
+
+ 
+
+
+You can take Parameter Extractor as a highly organized scout. It reads a paragraph of texts (like an email) and picks out the specific piece of information you asked for, putting them into a neat and organized list.
+
+### Hands-On 1: Add Parameter Extractor
+
+Before we upgrade the email assistant, let's remove these nodes: Knowledge Retrieval, If/Else, LLM, LLM 2, and Variable Aggregator.
+
+
+
+ 
+
+
+ Since AI doesn't automatically know which specific information we need from the email, we must tell it to collect all the questions.
+ 
+
+
+ **Parameter Types**
+
+ If Parameter Extractor is a scout, then Type is the bucket they use to carry the info. You need the right bucket for the right information.
+
+ **Single Items (The Small Buckets)**
+
+ - **String (Text)**: For a single piece of text, e.g. customer's name
+ - **Number**: For a single digit, e.g. order quantity
+ - **Boolean**: A simple Yes or No (True/False), good for a judgement result or a decision
+
+ **List Items (The Arrays)**
+
+ - **Array[String]**: Array means "List," and String means "Text." So, `Array[String]` means we are using a basket that can hold multiple pieces of text—like all the separate questions in an email
+ - **Array[Number]**: A container that holds different numbers, e.g. a list of prices or commodities
+ - **Array[Boolean]**: Used to store multiple "Yes/No" judgment results. For example, checking a list containing multiple to-do items and returning whether each item is completed, such as `[Yes, No, Yes]`
+ - **Array[Object]**: An advanced folder that holds sets of data (like a contact list where each entry has a Name and a Phone Number)
+ 
+
+ 
+
+
+With iteration, your assistant has a team of identical twins. When you hand over a list (like questions in the mail list), a twin appears for every single item on that list. Each twin takes their assigned item and performs the exact same task you've set up, ensuring nothing gets missed.
+
+### Hands-On 2: Set up Iteration Node
+
+
+
+
+ **Advanced Options in Iteration**
+
+ In the Iteration panel, you'll see more settings. Let's have a quick walk-through.
+
+
+ 
+
+
+ **Parallel Mode: OFF (Default)**: When disabled, the workflow processes each item in the list one after another (finish Question 1, then move to Question 2). When enabled, the workflow attempts to process all items in the list simultaneously (similar to 5 chefs cooking 5 different dishes at the same time).
+
+ **Error Response Method**: Terminate on error by default.
+ - **Terminate**: This means if any single item in the list (e.g., the 2nd question) fails during the sub-process, the entire workflow will stop immediately
+ - **Ignore Error and Continue**: This means even if the 2nd question fails, the workflow will skip it and move on to process the remaining questions
+ - **Remove Abnormal Output**: Similar to ignore, but it also removes that specific failed item from the final output list results
+
+ Back to the workflow, you'll see a sub-process area under the Iteration node. Every node inside this box will run once for every question.
+ 
+
+ 
+
+
+ Since the iteration node generates an answer for each individual question, we need to gather all these answers to create one complete reply email.
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+Tools are the superpower for your AI workflow.
+
+The Dify Marketplace is like a Plugin Supermarket. It's filled with ready-made superpowers—searching Google, checking the weather, drawing images, or calculating complex math. You just install and plug them into your workflow with several clicks.
+
+Now, let's continue to upgrade on current workflow.
+
+### Hands-On 1: Upgrade the Sub-process Area in Iteration
+
+We are going to add a new logic to our assistant: Check the Knowledge Base first; if the answer isn't there, go search Google.
+
+To focus on the new logic, let's keep only these nodes: **User input, Parameter Extractor, and Iteration**.
+
+**Step 1: Knowledge Query and the Judge**
+
+1. **Enter the Iteration**
+
+ Click to enter the sub-process area of the Iteration node. Keep Knowledge Retrieval node, and make sure the query variable as `{x} item`. Delete the previous LLM node.
+
+2. **Add the Judge (LLM Node)**
+
+ Add an LLM node right after Knowledge Retrieval node. Its job is to decide if the Knowledge Base info can actually respond to the questions.
+
+ - **For Context session**: Select the `Knowledge Retrieval{x} result Array [Object]` from Knowledge Retrieval
+ - **System Prompt**:
+
+ ```text
+ Based on the context, determine if it contains enough information to answer `Iteration/(x) item`. If the information is insufficient, you MUST reply with: "Information not found in knowledge base."
+ ```
+
+
+ 
+
+
+Here's what it looks like on the canvas.
+
+
+ 
+
+
+**Step 2: Setting the Crossroads**
+1. Add If/Else Node
+ After LLM node, let’s add If/Else node. Set the rule: If LLM Output **Contains ** **Information not found in knowledge base**.
+ This means, when we can’t respond with the information in knowledge base.
+
+ 
+
+
+2. Add Tool for Searching
+ Let's connect a search tool after the IF branch. This indicates that when the knowledge base cannot find relevant answer information, we use web search to find the answers. After the IF node, click plus(+) icon and select Tool. In the search box, type Google. Hover over Google, click Install on the right, and then click Install again in the pop-up window.
+
+ 
+
+3. Install Google Search
+ Click Google Search in Google.
+
+ 
+
+
+Using Google Search for the first time requires authorization—it’s like needing a Wi-Fi password.
+
+#### Getting Your Password (API Key)
+
+ 
+
+1. Click API Key Authorization Configuration, then click Get your SerpApi API key from SerpApi. Sign in to get your private API key.
+ Tip: Your API Key is your passport to the outside world. Keep it safe and avoid sharing it with others.
+
+ 
+
+
+2. Copy and paste the API key in SerpApi API key. Click save.
+
+3. Once the API key is successfully authorized, the settings panel shows up immediately. Head to Query string field, and select `Iteration/{x} item`.
+
+ 
+
+
+Now, we need to different ways to answer depending on which path we’re looking at.
+
+* The Search Answer Path
+ Add a new LLM node to answer the question based on the search results. Connect it to the Google Search node.
+ Prompt: You are a Web Research Specialist. Based on the search results `(x) GoogleSearch / (x)text`, concisely answer the user's question `Iteration/{x}item`. Please do not mention the knowledge base in your response.
+
+ 
+
+
+
+* The Knowledge Searching Path
+ After the Else node, add a new LLM node to handle answers based on the knowledge base.
+ Prompt: You are a professional Dify Customer Service Manager. Strictly follow the context to reply to `Iteration/{x}item`.
+
+ 
+
+
+CRITICAL STEP: Combine the Information
+In the sub-process (inside the Iteration box), add a Variable Aggregator node that connects both LLM 2 and LLM 3 at the very end.
+
+In the Variable Aggregator panel, select the variables `LLM 2/{x}text String` and `LLM 2/{x}text String` as the Assign Variables. In this way, we’re merging the two possible answers into a single path.
+
+ 
+
+
+This is how the current workflow looks.
+
+ 
+
+
+**Step 3: The Final Email Assembly**
+Now that our logic branches have finished processing, let's combine all the answers into a single, polished email.
+
+1. Configure Iteration Output
+ Click on the Iteration node, and set `{x}Variable Aggregator/{x}output String` as the output variables.
+
+ 
+
+
+2. **Connect the Summary LLM**
+
+ After the Iteration node, connect a new LLM node to summarize all outputs. Feel free to use the prompt below:
+
+ ```text
+ You are a professional Customer Service Manager.
+ Please answer each question from `Parameter Extractor /{x} question_list` based on the `Iteration /{x} output`, and organize a clear and complete email reply for `User Input / {x} customer_name`.
+ Do not include content where the knowledge base could not find relevant information.
+ Signature: Anne.
+ ```
+
+
+ 
+
+
+3. **Finalize with the Output Node**
+
+ After the LLM node, add an End node. Set the output variable as `LLM 4/{x}text String`.
+
+
+ 
+
+
+We have now completed the entire setup and configuration of the workflow. Our email assistant can now answer questions based on the Knowledge Base and use Google Search for supplementary answers when needed.
+
+
+ 
+
+
+Try sending an email with question that definitely isn't in the knowledge base. Let's see if the AI successfully uses Google to find the related answers.
+
+## Mini Challenge
+
+1. What are other conditions you can choose in If/Else node?
+2. Browse marketplace to see if you can add another tool for this workflow?
\ No newline at end of file
diff --git a/en/use-dify/tutorials/workflow-101/lesson-08.mdx b/en/use-dify/tutorials/workflow-101/lesson-08.mdx
new file mode 100644
index 000000000..aaa659122
--- /dev/null
+++ b/en/use-dify/tutorials/workflow-101/lesson-08.mdx
@@ -0,0 +1,176 @@
+---
+title: "Lesson 8: The Agent Node"
+sidebarTitle: Lesson 8
+---
+
+Let's look back the upgrades we've made for our email assistants.
+
+- Learned to Read: It can search a Knowledge Base
+- Learned to Choose: It uses Conditions to make decisions
+- Learned to Multitask: It handles multiple questions via Iteration
+- Learned to Use Tools: It can access the Internet via Google Search
+
+You might have noticed that our workflow is no longer just a straight line (Step 1 → Step 2 → Step 3). It's becoming a system that analyzes, judges, and calls upon different abilities to solve problems. This advanced pattern is what we call an Agentic Workflow.
+
+**Agentic Workflow**
+
+An Agentic Workflow isn't just Input \> Process \> Output. It involves thinking, planning, using tools, and adjusting based on results. It transforms the AI from a simple Executor (who just follows orders) into an intelligent Agent (who solves problems autonomously).
+
+**Agent Strategies**
+
+To make Agents work smarter, researchers designed "Strategies"—think of these as different modes of thinking that guide the Agent.
+
+- ReAct (Reason + Act): The "Think, then Do" approach. The Agent thinks (What should I do?), acts (calls a tool), observes the result, and then thinks again. It loops until the job is done.
+
+- Plan-and-Execute: Make a full plan first, then do it step-by-step.
+
+- Chain of Thought (CoT): Writing out the reasoning steps before giving an answer to improve accuracy.
+
+- Self-Correction: Checking its own work and fixing mistakes.
+
+- Memory: Equipping the Agent with short-term or long-term memory allows it to recall previous conversations or key details, enabling more coherent and personalized responses.
+
+
+In Lesson 7, we manually built a Brain using Knowledge Retrieval -\> LLM to Decide-\> If/Else -\> Search. It worked, but it was complicated to build. Is there a simpler way? Yes, and here it is.
+
+## Agent Node
+The Agent Node is a highly packaged intelligent unit. You just need to set a Goal for it through instructions and provide the Tools it might need. Then, it can autonomously think, plan, select, and call tools internally (using the selected Agent Strategy, such as ReAct, and the model's Function Calling capability) until it completes your set goal. In Dify, this greatly simplifies the process of building complex Agentic Workflows.
+
+## Hands-on 1: Build with Agent Node
+Our goal is to replace that complex manual logic inside our Iteration loop with a single, smart Agent Node.
+
+
+
+ 
+
+ 
+
+
+ **Why ReAct here?**
+
+ ReAct (Reason + Act) is a strategy that mimics human problem-solving using a Think → Do → Check loop.
+ 1. Reason: The Agent thinks, "What should I do next?" (e.g., Check the Knowledge Base).
+ 2. Act: It performs the action.
+ 3. Observe: It checks the result. If the answer isn't found, it repeats the cycle (e.g., "Okay, I need to search Google").
+
+ This thinking-while-doing approach is perfect for complex tasks where the next step depends on the previous result.
+
+
+ 
+
+ **Why Function Calling?**
+
+ One of the core capabilities of an Agent Node is to autonomously call tools. Function Calling is the key technology that allows the model to understand when and how to use the tools you provide (like Google Search). If the model doesn't support this feature, the Agent cannot effectively interact with tools and loses most of its autonomous decision-making capabilities.
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+Click **Test Run**. Ask a mix of questions (some about Dify's history, some about breaking news). Watch how the Agent Node autonomously decides when to use the context and when to use Google!
+
+## Mini Challenge
+
+1. Could we use an Agent Node to replace the entire Iteration loop? How would you design the prompt to handle a list of questions all at once?
+2. What other information could you feed into the Agent's "Context" field to help it make better decisions?
\ No newline at end of file
diff --git a/en/use-dify/tutorials/workflow-101/lesson-09.mdx b/en/use-dify/tutorials/workflow-101/lesson-09.mdx
new file mode 100644
index 000000000..0afc000df
--- /dev/null
+++ b/en/use-dify/tutorials/workflow-101/lesson-09.mdx
@@ -0,0 +1,83 @@
+---
+title: "Lesson 9: Layout Designer (Template)"
+sidebarTitle: Lesson 9
+---
+
+In Lesson 8, we successfully built a powerful Agent that can think and search. However, you might have noticed a tiny issue: even though we asked the final LLM to list the answers, sometimes the formatting can be a bit messy or inconsistent (e.g., mixing bullet points with paragraphs).
+
+To fix this, we need a dedicated format assistant to organize the answers into a beautiful, standardized format before the final LLM writes the email.
+
+## Template
+
+It takes the original data (like your list of answers), follows a strict design template/standards you provide, and generates a perfectly formatted block of text, ensuring consistency every single time.
+
+## Hands-On 1: Polish the Email Layout
+
+
+
+ 
+
+
+ 3. In the code box, we use a tool called **Jinja2**
+
+ **What is Jinja2?**
+
+ In simple terms, Jinja2 is a tool that allows you to format variables (like your list of answers) into a text template exactly how you want. It uses simple symbols to mark where variables go and perform basic logic. With it, we can turn a raw list of data into a neat, standardized text block.
+
+ You can copy and paste the code below into the code box. This code processes every item in your answers list one by one, adding a dash `-` in front of each, to create a clean bulleted list.
+
+ ```jinja2
+ {% for answer in answers %}
+ - {{ answer }}
+ {% endfor %}
+ ```
+ 
+
+ 
+
+
+Click **Test Run**. Ask multiple questions in one email. Notice how the middle section of the reply is now a perfectly formatted bulleted list in a professional tone.
+
+
+## Mini Challenge
+
+1. How would you change the Jinja2 code to make a numbered list (1. Answer, 2. Answer) instead of bullet points?
+
+ 
+
+
+2. Once published, the gray-out buttons turned clickable now.
+
+ 1. **Share Your App**
+
+ Dify automatically generates a WebApp for you. This is a ready-to-use chat interface for your Email Assistant.
+
+ You can send this URL to colleagues or friends. They don't need to log in to Dify to use the email assistant.
+
+
+ 
+
+
+ 2. **Batch Run App**
+
+ If you have 100 emails to reply, copying and pasting them one by one will drag you down.
+
+ In Dify, all you need to do is to prepare a CSV file with the 100 emails. Upload it to Dify's Batch Run feature. Dify processes all 100 emails automatically and gives you back a spreadsheet with all the generated replies.
+
+ 
+
+
+ 3. **Others**
+
+ - **Access API Reference**: If you know coding, you can get an API Key to integrate this workflow directly into your own website or mobile app
+ - **Open in Explore**: Pin this app to your workspace sidebar for quick access next time
+ - **Publish as a Tool**: Package your workflow as a plugin so other Agents can use your Email Assistant as a tool
+
+## Monitor Your App
+As the creator, you need to understand the status of this assistant. By monitoring and using logs, you can check the health, performance, and costs.
+
+### The Command Center: Monitoring
+Click **Monitoring** on the left sidebar to see how your app is performing.
+
+| Name | Explanation |
+| ---------------------- | ------------------------------------------------------------------------------------ |
+| Total Messages | How many times users interacted with the AI today. It shows how popular your app is. |
+| Active Users | The number of unique people engaging with the AI. |
+| Token Usage | How much tokens the AI used. Watch for sudden spikes to control costs. |
+| Avg. User Interactions | Do the users ask follow-up questions? |
+
+### The Magnifying Glass: Logs
+Logs record the details of every single run: time, input, duration, and output. To access detailed records, click Logs in the left sidebar.
+
+**Why Logs?**
+- **Debugging**: User says "It doesn’t “work? Check the logs to replay the "crime scene" and see exactly which node failed.
+- **Performance**: See how long each node took. Find the blocker that is slowing things down.
+- **Understand Users**: Read what users are actually asking. Use this real data to update your Knowledge Base or improve your Prompts.
+- **Cost Control**: Check exactly how many tokens a specific run cost.
+
+| Name | Explanation |
+| ------------------- | ----------------------------------------------------------- |
+| Start Time | The time when the workflow was triggered |
+| Status | Success or Failure. |
+| Run Time | How long the whole process took. |
+| Tokens | The tokens consumed by this run. |
+| End User or Account | The specific user ID or account that initiated the session. |
+| Triggered By | WebApp interface or called via API. |
+
+You can click on each log entry to view more details. For example, you can identify frequently asked user questions and use them to timely update and modify your Knowledge Base.
+
+
+Building AI app is a new starting point, and this is the core of **LLMOps** (Large language model operations).
+
+1. **Observe**: Look at the Logs. What are users asking? Are they happy with the answers?
+2. **Analyze**: Hallucination happens on certain questions or some tools run out often
+3. **Optimize**: Go back to the Canvas. Edit the Prompt, add a document to the Knowledge Base, or tweak the workflow logic
+4. **Publish**: Release the upgraded version
+
+By repeating this cycle, your Email Assistant gets smarter and faster.
+
+## Conclusion
+
+**Thank you for your time and you're now a Dify builder with a new way of thinking:**
+
+Break down the task → Choose Nodes and Tools → Connect them with the right logic → Monitor and upgrade
+
+Now, feel free to open a template in Dify explore. Break it down and analyze it. Start from the scratch, build a workflow that solves a task in your daily work.
+
+May your workload get lighter and your imagination goes higher. Happy building with Dify.
diff --git a/images/difyworkflow101-lesson01-explore.png b/images/difyworkflow101-lesson01-explore.png
new file mode 100644
index 0000000000000000000000000000000000000000..e25396dfb8a06076c422f4034739ef206d31158d
GIT binary patch
literal 474903
zcmeFYWmsI>vNlS9BuH=w1a|_#9U6BhxVzIpF{SwDMzk91wVh|S~ygT6ye_#)r
zyE%%~vvaw3OSfl_;9;>{?pNZ-A;H;@0Cf%*)~d#n@L39v5Q7nEwL_O$9BV6+=##U+
z+tHkM2ZEd%7ti=}f0j=MpXm>sSx9##D4gSU(Q*13%{pBJh`5rp;w#3S&Kr|6rPeLH
zzVlbg3Iax7@)!_-elEwOUo39|gqAX^YK-_pR1hhuE!<~I>kl0A)9uW8MMK{bPW)>A
zq~C)K6!E9v@BZoKV~^=E#Cka71B=AtLiwd$Gj+FhawGrPST*>X<6MO7FUpd}8
z&RU6^8o1y)&Xs^!&()M>AB>|;0~I{W$+##Sd{8T)d*(1ZKhVN@XH{cE1-`CKE_MVI
zz9I1K_QLE?pKpGrnP?x~u5_9;`T!i>F(+%C_HFkLxuLGe8h}qDYA28scKT00K28N@
zKNxH*iHheA3(2HaApB+w7(&f|+q;@Cg(^38FtJO-Wy{jS?A~#b3vwnx=HRGrY2DnY
z8g$*1BwPoiV2GczJd&~ctrzVa-5H}LWV&V~>Qa{Np0r@FYc#>n;plX^b)FS<{8o*x
zbE-<=_9t{okh&K2+(c*;Tyw@qD{}uOPo;=YW3b?oVb$w+y|_q7%TPXHZ4FdIToq^=
z*V5A~AZ@`L-kZ#ynReqUQ6F8G8|N=-opnu$7YiMN!ExI?06!)jeDvOO-88wc8UI+(
zeX4i6gn~+d4#tRA%HW<1ADHA@uKh$y8}D+^MFcv742D_phXR&WOR{c+;!Nd6u1Hfn
z(LwE?120