Posted inAI

Guide to Using Dify to Create No-Code AI Workflows: Optimizing Your Workflow

Artificial Intelligence tutorial - IT technology blog
Artificial Intelligence tutorial - IT technology blog

AI and the Challenges of Real-World Implementation

AI is transforming the way we work, from automating tasks to in-depth data analysis. However, turning an AI idea into a product often presents significant challenges. Selecting the right model, building interactive interfaces, managing data, and deploying APIs all require extensive knowledge of programming and Machine Learning.

I often see DevOps engineers and developers struggling to quickly test AI ideas without spending weeks writing code. This solution is especially needed for projects that require rapid Proof of Concept (PoC) deployment or small-scale internal applications (e.g., chatbots supporting 50-100 employees).

Comparing AI Application Development Methods

To build AI applications, we can choose one of the following approaches:

1. Manual Development with Code (Code-first Approach)

This is the traditional approach, where everything is controlled by code. Frameworks like LangChain, LlamaIndex, or self-coding Python with libraries such as transformers, PyTorch, TensorFlow are typical examples.

  • Advantages:
    • Highest flexibility, complete control over all aspects of the application.
    • Optimized performance, allowing deep adjustments to model architecture.
    • Suitable for special requirements needing strong customization.
  • Disadvantages:
    • Requires strong programming knowledge of Python, Machine Learning, and related libraries.
    • Long development time, especially for complex applications.
    • High personnel costs.

2. Low-code/No-code Platforms for AI (Dify and Similar Tools)

These platforms provide intuitive, drag-and-drop interfaces for building AI applications. Prominently among them is Dify, which helps users design AI workflows without writing a single line of code.

  • Advantages:
    • Rapid deployment of AI ideas, reducing development time.
    • Does not require deep programming skills, suitable for PMs, BAs, or developers looking to save time.
    • Intuitive, easy-to-learn, and easy-to-use interface.
    • Easy to test and iterate on ideas.
  • Disadvantages:
    • Flexibility and customization capabilities may be limited compared to manual coding.
    • Reliance on the features provided by the platform.
    • May encounter difficulties when dealing with overly complex or specific cases.

Why Choose Dify for Your AI Projects?

In practice, Dify is particularly effective for rapid AI idea implementation. It is especially ideal for Proof of Concept (PoC) or internal applications, significantly saving coding effort. This is also an important skill if you want to optimize the development and testing process for Large Language Model (LLM)-based applications.

With Dify, I can quickly transform ideas like customer support chatbots or document summarization tools into applications in just a few hours. This significantly saves time compared to the days or weeks it would have taken before.

Dify is particularly suitable for:

  • IT beginners who want to learn about AI without extensive coding.
  • Developers who want to quickly test LLM APIs.
  • Businesses looking to create internal AI applications customized for specific tasks.
  • Building AI products in the Proof of Concept (PoC) stage.

Detailed Guide to Using Dify to Create AI Workflows

1. Introduction to Dify

Dify is an open-source platform that allows you to develop LLM-based AI applications without code. It offers prominent features such as:

  • Prompt Engineering: Easily design and manage prompts.
  • RAG (Retrieval-Augmented Generation): Connect LLMs with your data sources to provide more accurate information.
  • Workflow Orchestration: Build complex processing flows with multiple steps and different AI models.
  • API Access: Deploy your AI application as an API for easy integration.

2. Installing and Setting Up Dify

You can use Dify Cloud or self-host on your own server. For beginners, I recommend trying Dify Cloud first. However, if you want complete control over your data and environment, self-hosting is the optimal choice. This article will guide you through self-hosting using Docker, a common method in DevOps.

Step 1: Prepare the Docker and Docker Compose Environment

Ensure your server has Docker and Docker Compose installed. If not, please install them according to Docker’s official guide.

Step 2: Clone the Dify repository

git clone https://github.com/dify-ai/dify.git
cd dify

Step 3: Start Dify with Docker Compose

docker compose up -d

This command will download the necessary Docker images and start Dify along with auxiliary services like PostgreSQL and Redis. This process may take a few minutes depending on your network speed.

Step 4: Access Dify Dashboard

Once the services have started, you can access the Dify Dashboard via your browser at http://localhost:8000 (or the server’s IP if running on a remote server).

Register the first admin account to start using it.

3. Building Your First AI Workflow with Dify (Example: Article Summarization)

Now, we will create a simple workflow to summarize article content. This is a scenario I often use to process long documents, significantly saving time.

Step 1: Add a Provider Model

First, you need to connect Dify with a Large Language Model (LLM) provider. I will use OpenAI as an example.

  1. Go to “Settings” -> “Model Providers”.
  2. Select “OpenAI” and enter your API Key.
  3. Save.

Step 2: Create a New Application

  1. On the Dashboard, select “Create App”.
  2. Choose the application type “Workflow”.
  3. Name your application (e.g., “Article Summarizer”) and add a description.

Step 3: Design the Workflow

You will be taken to the workflow design interface. The basic nodes will be displayed.

  1. Input Node: Drag and drop a “Text Input” node onto the canvas. Name the variable article_content. This is where the user enters the article content to be summarized.
  2. LLM Node (Summarization):

    • Drag and drop an “LLM” node onto the canvas and connect it from the “Text Input” node.
    • Configure the LLM node:
      • Model: Select an OpenAI model (e.g., gpt-3.5-turbo or gpt-4o).
      • Prompt: Write a prompt to instruct the model to summarize. You can use the variable {{article_content}} from the Input Node. Example:
        • You are a professional summarization assistant. Summarize the following content into 3-5 key bullet points, ensuring the most important meanings are preserved:

{{article_content}}
  3. Output Node: Drag and drop an “Output” node and connect it from the “LLM” node. Name the output variable summary_output and assign its value as the output from the LLM node (usually {{llm.output}} or the variable name you configured in the LLM node).

Once completed, save your workflow.

Step 4: Test and Verify the Workflow

  1. On the workflow interface, click the “Debug” or “Run” button in the top right corner.
  2. Enter a long text passage into the article_content field (e.g., a paragraph from this article).
  3. Observe the summarization result in the Output section.

Step 5: Deploy and Integrate Your AI Application

Dify allows you to deploy your workflow as an API, making it easy to integrate into other applications.

  1. In the “Overview” section of the application, you will see the “API” section.
  2. Dify will provide a unique API Endpoint and API Key for your application.

You can call this API using curl or any programming language. Below is an example using curl:

curl -X POST 'YOUR_DIFY_APP_API_ENDPOINT'
-H 'Authorization: Bearer YOUR_DIFY_API_KEY'
-H 'Content-Type: application/json'
-d '{
    "inputs": {
        "article_content": "Content of the article you want to summarize..."
    },
    "response_mode": "blocking",
    "user": "itfromzero-user"
}'

And here is an example using Python:

import requests

url = "YOUR_DIFY_APP_API_ENDPOINT"
api_key = "YOUR_DIFY_API_KEY"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

data = {
    "inputs": {
        "article_content": "Content of the article you want to summarize, which can be a long passage from a website or document."
    },
    "response_mode": "blocking", # or streaming
    "user": "itfromzero-user"
}

response = requests.post(url, headers=headers, json=data)

if response.status_code == 200:
    print("Summarization successful:")
    print(response.json()['answer'])
else:
    print(f"Error: {response.status_code} - {response.text}")

Replace YOUR_DIFY_APP_API_ENDPOINT and YOUR_DIFY_API_KEY with your application’s information.

Extending with RAG and Other Advanced Features

Dify doesn’t stop at simple workflows. You can:

  • Integrate Datasets (RAG): Upload documents (PDF, Word, TXT) into Dify to create a Knowledge Base. Then, in the workflow, you can add a “Retrieval” node to query information from this Dataset before sending it to the LLM, helping the model answer more accurately and specifically.
  • Use Tool Calling: Allow LLMs to interact with external tools (APIs, custom functions) to perform more complex tasks.
  • Conversation Applications: Build smart conversational chatbots, storing chat history.

Conclusion

Dify offers powerful and accessible capabilities, opening the door for anyone wanting to explore and apply the power of AI without grappling with code. I believe that mastering a platform like Dify will significantly optimize your workflow, from quickly validating ideas to deploying practical AI solutions in projects. Start experimenting with Dify today to experience the benefits yourself!

Share:
Tags: