dify-docs/en/develop-plugin/getting-started/cli.mdx

---
dimensions:
  type:
    primary: conceptual
    detail: architecture
  level: beginner
standard_title: CLI
language: en
title: Dify Plugin CLI
description: Install the Dify Plugin CLI, scaffold a new plugin project, and run it against a Dify instance for local development
---

The Dify Plugin CLI manages your plugin development workflow, from project initialization to packaging. This guide covers installing the CLI, scaffolding a plugin project, and running it against a Dify instance.

<Note>
This is the Dify Plugin CLI (the `dify` command) for building plugins. It is not the Dify CLI ([difyctl](/en/cli/overview)), which runs and manages Dify apps from the command line.
</Note>

## Prerequisites

Before you begin, make sure you have:

- Python 3.12
- Homebrew (macOS only, used to install the CLI)

## Install the CLI

<Tabs>
  <Tab title="Mac">
    ```bash
    brew tap langgenius/dify
    brew install dify
    ```
  </Tab>
  <Tab title="Linux">
    Download the latest binary from the [Dify Plugin Daemon releases page](https://github.com/langgenius/dify-plugin-daemon/releases). Pick `dify-plugin-linux-amd64` for x86_64 hosts or `dify-plugin-linux-arm64` for ARM hosts.

    ```bash
    chmod +x dify-plugin-linux-amd64
    sudo mv dify-plugin-linux-amd64 /usr/local/bin/dify
    ```
  </Tab>
  <Tab title="Windows">
    Download `dify-plugin-windows-amd64.exe` (or `dify-plugin-windows-arm64.exe`) from the [Dify Plugin Daemon releases page](https://github.com/langgenius/dify-plugin-daemon/releases), rename it to `dify.exe`, and add its folder to your `PATH`.
  </Tab>
</Tabs>

Verify the installation:

```bash
dify version
```

## Create a Plugin Project

Create a new plugin project with:

```bash
dify plugin init
```

Fill in the required fields when prompted:

```bash
Edit profile of the plugin
Plugin name (press Enter to next step): hello-world
Author (press Enter to next step): langgenius
Description (press Enter to next step): hello world example
Repository URL (Optional) (press Enter to next step): Repository URL (Optional)
  Enable multilingual README: [✔] English is required by default

Languages to generate:
    English: [✔] (required)
  → 简体中文 (Simplified Chinese): [✔]
    日本語 (Japanese): [✘]
    Português (Portuguese - Brazil): [✘]

Controls:
  ↑/↓ Navigate • Space/Tab Toggle selection • Enter Next step
```

Choose `python` and press Enter to use the Python plugin template, then select the type of plugin you want to build:

```bash
Select the type of plugin you want to create, and press `Enter` to continue
Before starting, here's some basic knowledge about Plugin types in Dify:

- Tool: Tool Providers like Google Search, Stable Diffusion, etc. Used to perform specific tasks.
- Model: Model Providers like OpenAI, Anthropic, etc. Use their models to enhance AI capabilities.
- Endpoint: Similar to Service API in Dify and Ingress in Kubernetes. Extend HTTP services as endpoints with custom logic.
- Trigger: Webhook-based providers that turn third-party platform events into workflow start signals.
- Agent Strategy: Implement your own agent strategies like Function Calling, ReAct, ToT, CoT, etc.

Based on the ability you want to extend, Plugins are divided into six types: Tool, Model, Extension, Agent Strategy, Datasource, and Trigger.

- Tool: A tool provider that can also implement endpoints. For example, building a Discord Bot requires both sending and receiving messages.
- Model: Strictly for model providers, no other extensions allowed.
- Extension: For simple HTTP services that extend functionality.
- Agent Strategy: Implement custom agent logic with a focused approach.
- Datasource: Provide datasource for Dify Knowledge Pipeline.
- Trigger: Build webhook integrations that emit events to kick off workflows.

We've provided templates to help you get started. Choose one of the options below:
-> tool
  agent-strategy
  llm
  text-embedding
  rerank
  tts
  speech2text
  moderation
  extension
  datasource
  trigger
```

When prompted for the minimal Dify version, leave it blank to use the latest version:

```bash
Edit minimal Dify version requirement, leave it blank by default
Minimal Dify version (press Enter to next step): 
```

The CLI creates a new directory named after your plugin and sets up the basic project structure. Move into it:

```bash
cd hello-world
```

## Run the Plugin

From the `hello-world` directory, copy the example environment file:

```bash
cp .env.example .env
```

Edit the `.env` file to set your plugin's environment variables, such as API keys or other configurations. To get the debugging credentials, log in to your Dify environment, click **Plugins** in the top-right corner, then click the debug icon. In the pop-up window, copy the **API Key** and **Host Address**.

```bash
INSTALL_METHOD=remote
REMOTE_INSTALL_URL=debug-plugin.dify.dev:5003
REMOTE_INSTALL_KEY=********-****-****-****-************
```

<Note>
  `REMOTE_INSTALL_URL` combines host and port in `host:port` form. The host and port are shown together in the **API Key** card on the Plugins page.
</Note>

Install the dependencies and run your plugin:

```bash
pip install -r requirements.txt
python -m main
```