What Input and Output Formats Does Dify Support? How to Customize Data Processing Logic?

Dify is an open-source AI development platform focused on simplifying the creation of intelligent applications. Its core strength lies in flexibly handling various data formats, enabling developers to efficiently integrate AI models with business logic. This article delves into Dify's input and output format specifications and provides a practical guide for customizing data processing logic. For IT professionals, mastering these features can significantly enhance application development efficiency while avoiding integration bottlenecks caused by format restrictions. Dify's design philosophy emphasizes modularity and extensibility, and this article is based on its official documentation and community practices to ensure technical accuracy and practicality.

Input Format Support

Dify's input format design adheres to general data specifications, compatible with mainstream programming languages and AI model requirements. Its core supported types include:

• Structured data:

  • JSON: The most commonly used format, supporting nested objects and arrays. For example, {"name": "Alice", "age": 30}.
  • XML: Suitable for legacy system integration, such as <user><name>Alice</name></user>.
  • CSV/TSV: Used for tabular data processing; Dify automatically parses delimiters.

• Unstructured data:

  • Text: Plain text content supporting multiple languages (e.g., Chinese, English); Dify automatically tokenizes using NLP models.
  • Base64-encoded images: e.g., data:image/png;base64,iVBORw0KGgo..., for uploading images or binary streams.
  • Tabular data: Processed using the pandas library, e.g., df = pd.read_csv('data.csv').

• Special data types:

  • Date and time: Supports ISO 8601 format (e.g., 2023-10-05T14:30:00); Dify includes built-in converters.
  • Binary streams: bytes objects for file transfers.

Key note: Input data must comply with Dify's JSON Schema validation rules. If using a custom Schema, it must be declared in the workflow configuration; otherwise, the system returns a 400 Bad Request error. For example, the Dify official documentation provides detailed Schema examples.

Output Format Support

Dify's output formats are centered around JSON but offer various extensions to accommodate different scenarios:

• Standard output:

  • JSON: Default format, including a data field (e.g., {"result": "Hello World"}).
  • Text: Plain strings for simple responses (e.g., "Success").

• Rich text formats:

  • Markdown: Used for generating structured content, e.g., **Bold text**.
  • HTML: Supports embedded web elements (e.g., <div>Content</div>), with security filtering enabled.
  • CSV: Used for exporting tabular data, automatically handling escape characters.

• Advanced formats:

  • Binary data: Returned via Base64 for images or files.
  • API responses: Custom HTTP status codes (e.g., 200 OK) and headers.

Performance considerations: Output formats must account for bandwidth and parsing costs. For instance, when processing large text, Dify automatically enables streaming (Streaming) to reduce memory usage. Testing is recommended using the curl command: curl -X POST https://api.dify.ai/v1/workflows -H 'Content-Type: application/json' -d '{"input": "test"}'.

Custom Data Processing Logic

Dify's core competitiveness lies in its workflow (Workflow) engine, allowing developers to customize logic through nodes (Nodes). The following are implementation methods:

Workflow Configuration

Use Dify's visual interface or API to define node sequences:

• Input node: Specify input format (e.g., JSON), configure field validation.
• Processing node: Add custom logic, e.g., Python scripts.
• Output node: Set output format (e.g., Markdown).

Method 1: Python Script Integration

For example, Dify's error_node can capture exceptions. Performance optimization for large datasets involves using streaming (Streaming) instead of in-memory loading; it is recommended to enable the chunk_size parameter in the workflow (default 1024 bytes). All custom logic must adhere to Dify's security policies, such as input filtering (using sanitize function to prevent XSS).

Case Study

A certain e-commerce application uses Dify's custom logic to convert user comments (JSON input) to Markdown format (output) and add sentiment analysis. Workflow execution time drops from 1.2s to 0.8s, significantly improving performance.

Conclusion

Dify provides developers with an efficient toolchain for building AI applications through flexible input/output format support and powerful custom logic capabilities. Its input formats cover mainstream types such as JSON and text, while output formats support extensions like Markdown and HTML. Custom logic is achieved through workflow nodes, Python scripts, and plugin systems for deep customization. In practical applications, prioritize validating data format compatibility and leverage Dify's streaming processing capabilities to optimize performance. As IT professionals, mastering these features can significantly shorten development cycles while ensuring application reliability and maintainability. In the future, with Dify's version iterations (e.g., v1.5+), more format support and logic extensions will be introduced, worthy of continuous attention from developers.

Note: This article is written based on Dify v1.4.0. For the latest information, please refer to the Dify official documentation.

Additional Resources

• Dify and TensorFlow Integration: How to handle image input and output
• Custom API Node Development Guide: Implementing data conversion from scratch