Version: 2.0.x

Developer Guide Index

Experience a revolutionary approach to application development. Build powerful enterprise-grade applications using cutting-edge AI technology.

This developer guide offers a comprehensive learning path—from organizational management and application fundamentals to business logic implementation—complete with best practices for mastering complex application architecture through real-world scenarios.

How to use this guide: Beginners should follow the sequential learning path. Experienced developers can jump directly to scenario-based advanced guides.

First, complete Download and Installation.

Basic concepts

Master JitAI's core concepts and architecture principles. Build a solid theoretical foundation by understanding platform applications, element systems, development frameworks, and visual development tools.

Platform Architecture and Core Concepts

Learn JitAI's platform architecture, application concepts, JAAP protocol, element systems, and development frameworks—the foundational principles that power the platform.

Platform and applications

DevOps tools and services

Application creation and development

JAAP protocol and elements

Element types and element loading

Development framework

Business applications and application inheritance

Development tools

Extension

Platform installation and node activation

Set up your development environment by installing the platform and activating nodes. Master installation procedures, node activation workflows, and developer team management.

Download and Installation

Download and install JitAI platform for your deployment scenario—desktop or server versions available.

Desktop Version

Server Version

Node Activation and Developer Team

Activate nodes and manage developer teams—configure organization binding, add team members, and perform essential management operations.

What is Node

What is Developer Team

Create New Development Organization When Activating Node

Bind Node to Joined Organization When Activating

Use Organization Bind Code to Join and Bind When Activating Node

Join Organization via Bind Code When Logging into Existing Node

Viewing team ID

View and Refresh Organization Bind Code

Remove Organization Member

Platform Node Updates and Upgrades

Keep your platform nodes up-to-date with the latest features and stability improvements.

Update banner and entry

One‑click upgrade flow

Recommendations for clusters

Development tools and publishing services

Accelerate development with a powerful, integrated toolchain. Master visual development environments, DevOps management tools, and cloud publishing services for seamless development-to-deployment workflows.

JitAI Visual Development Tools

Navigate the visual development environment with confidence—explore IDE functional areas and seamlessly switch between visual and source code modes.

Element directory tree

Adding elements

Visual editor

Source code editor

Source code file tree

Application settings

Basic information

Default elements

Environment variables

DevOps Management Tool

Manage your entire application lifecycle with a comprehensive dual-console DevOps solution—from development through deployment and beyond.

Dual Console Architecture

Local node console

Organization management console

Core Capabilities Overview

Application lifecycle management

Runtime environment management

Node cluster management

Flexible configuration management

Version release and deployment

Multi-platform export

Application template ecosystem

JCS Cloud Application Publishing Service

Leverage the official cloud publishing service for centralized application repositories, version management, and seamless deployment across JitNodes.

Synchronizing runtime environment configuration from JCS

Retrieving version update information from JCS

Accessing cloud application repository through JCS

Creating and publishing applications

Master the complete workflow from application creation to distributed deployment. Learn application scaffolding, source code management, version publishing, runtime environment configuration, and infinitely scalable distributed architectures.

Creating and Deploying Applications

Create, configure, and deploy applications—from inheritance patterns to data configuration, master the fundamental development workflow.

Creating Your First Application

Developing Applications Based on Existing Templates

Inheriting from Applications

Duplicating Applications

Configuring Data Storage and Environment Variables

Deploying Applications

Deploying Applications on Specified Nodes

Deploying Applications in Specified Runtime Environments

Application Directory and Element Source Code

Navigate JitAI's JAAP-based directory structure—understand element code organization and source code export/import workflows.

Understanding application directory structure

Understanding element code directory structure

Exporting and importing application source code

Exporting source code zip packages

Exporting to WeChat MiniProgram

Importing application source code packages

Publishing and Upgrading Applications

Control your application lifecycle with version management, publishing workflows, and upgrade strategies—including semantic versioning and deployment best practices.

Managing application version and publishing

Understanding semantic versioning

Setting automatic updates

Writing meaningful update logs

Including source code

Including initialization data

Upgrading application versions

Planning application deployment strategies

Runtime Environment Management

Configure and manage runtime environments—create deployment targets, organize node clusters, and control application deployment strategies.

Understanding runtime environments

Managing node local default runtime environment

Creating new runtime environments

Deploying in development mode

Deploying in production mode

Managing node clusters with runtime environments

Managing node addresses

Monitoring node status

Deploying applications in runtime environments

Deploying in production mode

Deploying in development mode

Distributed Cluster Architecture for Unlimited Horizontal Scaling

Build infinitely scalable distributed architectures—design enterprise cluster topologies for high availability and performance at scale.

Understanding the four-layer architecture model

Designing enterprise cluster deployment architecture

Implementing typical deployment topology

Organizing multi-dimensional environment division

Configuring entry address strategies

Implementing cluster scaling strategies

Deploying horizontal scaling modes

Implementing load balancing and fault tolerance

Understanding architecture constraints and best practices

Managing version constraints

Configuring network access constraints

Following deployment best practices

Frontend portals and pages

Craft beautiful, intuitive user interfaces. Build portal navigation, construct dynamic pages, design component layouts, and manage data flows—everything you need for exceptional user experiences.

Creating Portals

Design role-based portal interfaces—configure navigation menus, set permission controls, and deliver personalized user experiences.

Componentized Pages

Understand componentized pages—the foundation of JitAI's page system, built with functional components for data display and user interaction.

Creating Generic Pages

Build page interfaces visually—drag and drop components, configure events, and create rich interactive experiences without writing code.

Creating generic pages

Visual page editor

Component common operations

Enabling AI assistant for page

AI Data Management Page

Leverage AI-powered data management—intelligently browse, filter, edit, and perform batch operations with built-in assistance.

Create AI Data Management Page

Limit Page Table Query Data Through Default Filter Conditions

Configure Default Data Sort Rules

Hide Some Fields in Page Table

Configure Conditional Filter Fields

Configure Viewable and Editable Fields in Form

Configure Fields Displayed in Batch Edit Form

Enable AI Data Management Assistant

Convert to Generic Page for Modification

AI Data Analysis Page

Generate data visualizations using natural language—AI creates charts from your descriptions and lets you adjust styles and dimensions on the fly.

Create AI data analysis page

Page configuration

Runtime effects demo

Full code development

Quick create

Data Entry Pages

Rapidly build data entry forms for streamlined data collection and submission workflows.

Creating a data entry page

Configuring viewable and editable fields

Showing enter again button after submission

Showing result feedback after submission

Converting to generic page for modification

Markdown Page

Create document-rich pages with full Markdown support—perfect for documentation, guides, and formatted content.

Create Markdown Page

Markdown Syntax

Full Code Page Development

Take full control with code-based page development—implement complex business logic and create fully customized interfaces.

Creating React full-code pages

Creating Vue full-code pages

Using AI in portals and pages

Elevate user experiences with AI-powered intelligence. Integrate AI agents and smart components into portals and pages for personalized assistance and automated workflows.

Using AI Agent in Component Pages

Integrate AI Agent into component pages and subscribe to AI events for human-AI collaboration.

AI Agent event subscription

Send AI messages in pages

Direct call to AI agent

Using AI Elements in Pages

Invoke AI elements directly from pages—leverage AI agents, LLM services, and knowledge bases for dynamic, intelligent content generation.

Using AI agent in pages

Visual calling

Full code calling

Using large language models in pages

Calling business elements in pages

Power your pages with business logic and data operations. Invoke service functions and data model functions to build dynamic, data-driven interfaces with real-time processing capabilities.

Calling Service Functions in Pages

Execute business logic directly from pages—invoke service functions to process data, integrate external systems, and generate dynamic content.

Invoking service functions in standard pages

Invoking service functions in full-code pages

Handling complex parameters

Calling Data Model Functions in Pages

Perform CRUD operations and complex queries—invoke data model functions from pages for real-time database interactions and data display.

Calling syntax

Basic syntax in full-code pages

Data operation capabilities

Related documentation

Full-code UI components in pages

Build advanced custom UI components with complete programming control. Create sophisticated interactive elements, handle complex events, and deliver rich experiences beyond standard components.

UI Component Interface Specifications

Master full-code component development—understand interface specifications, props management, state handling, and lifecycle methods.

Component interface architecture

Core interface definitions

Interface interaction mechanism

Interface implementation specifications

Interface runtime sequence

Interface invocation explanation

Related documentation

Calling Page and Component Functions in Full-Code Components

Integrate full-code components seamlessly—invoke page functions and communicate with other components for cohesive interactions.

Calling principle

Practical examples

Basic component calling

Getting data from other components

Common component methods

Basic calling pattern

Related documentation

Emitting Events

Enable component communication with custom events—emit and handle events between full-code components, pages, and parent containers.

Event Subscription Principles

Responding to Events in Full-Code Components

Publishing Custom Events

Subscribable Event Types

Standard Component Events

Custom Events in Full-Code Components

Bidirectional Communication Example

Calling Full-Code Component Functions in Page Code

Control full-code components from page code—invoke exposed functions to manage component behavior and orchestrate data flow.

Calling mechanism

Calling timing and lifecycle

Related documentation

Using functional components in pages

Leverage a powerful component library for rapid development. Drag and drop tables, forms, charts, and more—build complex interfaces with simple, intuitive visual tools.

Form Components

Build sophisticated forms with validation, permission controls, and complex business rules—collect and manage data effortlessly.

Basic Configuration and Item Management

Field Validation and Interaction

Layout Design

Use Custom Controls to Render Fields

Event Configuration

Advanced Functions

Batch Edit Form Configuration

Batch Edit Form Events and Interaction

Data Correction Configuration

Data Correction Usage

Basic Table

Display data with rich table features—bind data sources, customize fields, enable pagination, sorting, and inline editing.

Set Data Source

Custom Display Fields

Display Fields by Group

Set Group Names and Background Colors

Configure Field Attributes

Freeze Fields

Inline Editing

Field Statistics

Custom Field Renderer and Field Editor

Add Button

Delete Button

Collapse Multiple Buttons to "More"

Set Page Size/Disable Selection/Disable Sorting/Refresh Data on First Load

Table Component Variables

Grouped Table

Organize data hierarchically—group table rows by specified fields for structured data management and analysis.

Grouped Field Configuration

Same Configuration as Basic Table

Same Events as Basic Table

Same Component Variables as Basic Table

Cascaded Table

Display parent-child data hierarchies—manage tree structures with expandable rows and nested relationships.

Cascaded Table Sample Data

Configure Cascaded Logic Fields

Cascaded Table Usage Effects

Same Configuration as Basic Table

Same Events as Basic Table

Same Table Variables as Basic Table

View More Components

Crosstab

Perform multi-dimensional data analysis—create pivot tables with row-column cross-analysis for statistical reports.

Initialization Configuration

Configure Dimensions and Metrics

Statistics by Year/Quarter/Month/Week/Day

Configure Metrics

Configure Calculated Metrics

Custom Metric Attributes

Configure Metric Statistics Methods

Metric Data Filtering

Configure Chart Styles

Header/Body Alignment

Row/Column Styles

Export/Refresh/Scroll Display Buttons

Show Total

Cross Table Events

Crosstab Component Variables

Row to Column

Special table mode that converts row data to column display, suitable for dynamic field display scenarios.

Basic Configuration

Custom Field Names/Alignment

Custom Field Renderer

Statistics Columns

Export/Edit/Default Load Data

Value Click Event

Button Configuration

Row to Column Event

Row to Column Component Variables

Statistical Charts

Rich data visualization chart components supporting bar charts, line charts, pie charts and other chart types.

Tree Components

Display hierarchical data structures with node expand/collapse and selection operations, providing clear data navigation experience.

Create Tree Component

Configure Hierarchical Fields

Refresh Data on First Load

Default Expand First Node

Single/Multiple Selection Mode

Cascade Tree Refresh Data on First Load

Cascade Tree Node Click Events

Cascade Tree Node Selection Events

List Components

Flexible data list display component supporting title, summary, button configuration, suitable for various list display scenarios.

Configure List Title

Set Summary Content

Show Field Titles in Summary

Set Summary Content Layout

List Component Button

Add Button

Modify Button Attributes

Button Collapse to More

Button Drag Sort

Set Bottom Button Size

Refresh Data on First Component Load

Enable Row Click Event

Default Select First Data

List Component Variables

Refresh List Component

Card and Media Display

Components for displaying card-style content and media files, including dashboard and gallery functions.

Full-Code Components

Develop page-level custom React components with full control over UI, logic, style, and model data operations.

Model Filter

Advanced filtering component based on data models, supporting simple, complex and free filtering modes.

Universal Filter

Flexible universal filtering component supporting custom field configuration and multiple trigger modes.

Filter Field Configuration

Quick Layout

Show Query/Reset Buttons

Condition Change Trigger Query

First Load Filter

Filter Usage

Calendar

Schedule management and time arrangement component supporting event creation, editing, and view switching.

Data Model Preparation and Component Creation

Basic Configuration

Schedule Type

Day/Week/Month View Switch

Switch Time

List Display and Search

Drag Schedule

Button Configuration

Refresh Data on First Component Load

New Schedule

Drag Agenda

Timeline

Timeline display component suitable for showing historical records and process progress.

Data Model Preparation and Component Creation

Refresh Data on First Component Load

Gantt Chart

Project management and progress tracking component supporting task dependencies and progress visualization.

Data Model Preparation and Component Creation

Basic Configuration

Progress

Hierarchical Relationship

Sequential Relationship

Day/Week/Month/Quarter/Year View Switch

List Display Fields

Floating Layer Display Fields

Button Configuration

Refresh Data on First Component Load

Drag Date Progress

Allow Add Schedule

Button Components

Various types of button components supporting different styles and interactive effects.

Button Component Creation

Button Title/Icon/Type/Size Configuration

Button Click Event

Layout Components (Editing in Progress)

Page layout and container components including popups, tabs and other interface structural elements.

📝 Documentation is being improved, please stay tuned...

Approval Components

Workflow-integrated UI components for submitting approval requests, processing approval tasks, and managing approval history with event-driven notifications.

Initiate application component

Creating initiate application component

Parameter configuration

After processing/refresh events

Approval processing component

Creating approval processing component

Parameter configuration

Retaining historical approval records

After processing/refresh events

Payment Components

Functional UI elements enabling multi-platform payment processing with native Alipay and WeChat Pay support for complete transaction lifecycle management.

Creating payment components

Initiate payment function

Event logic

Component usage

Data Parsing and Import

Powerful data import and parsing tools supporting Excel file batch import, data cleaning, conditional filtering, and master-detail table association import.

Import Component

Adding Import Component to Page

Import Serial Number Fields

Set Required Fields

Import Subtable Data

Append Import/Update Import

Import Data by Conditions

Add Import Description Text

Pre-processing/Post-trigger Functions

Import Hint Button Click Event

Parse Excel

Create Parse Excel Component

Configure Field Aliases

Adjust Field Order

Delete Parse Fields

Create Custom Buttons

Post-parse Events

Full Code Components

Fully customized code components supporting highly personalized function implementation.

Component Interface Specifications

Component Interface Architecture

Core Interface Definitions

Calling Page and Component Functions

Emitting Events

Event Subscription Principles

Bidirectional Communication

Calling Component Functions in Page Code

Click "View More Components" above to collapse

AI large language models

Integrate leading LLMs like GPT-4, Claude, and Tongyi Qianwen. Enable intelligent dialogue, text generation, and code assistance—with multi-vendor failover and private deployment options.

Create AI Large Language Model Element

Integrate major LLM providers—configure API keys, set up retry mechanisms, and invoke AI functions in your applications.

Mainstream LLM Vendor Support List

Creating LLM vendor elements

Retry and backup API key mechanism

Private LLM integration

LLM Input and Output

Configure LLM inputs and outputs—optimize prompts, model parameters, and response handling for peak performance.

Calling LLM in pages

Function input 1: Setting the language model

Function input 2: Using prompts

Function output: Output control

Calling LLM in backend functions

LLM programming interface

runLlm

embedDocuments

rerankDocuments

Implement multimodal AIGC using LLM functions

Discover how to leverage LLM functions to create multimodal AI-generated content with text, images, and other media types.

📝 Coming soon...

AI knowledge base

Transform enterprise documents into intelligent, searchable knowledge bases. Enable automatic document processing, intelligent chunking, and semantic retrieval—empowering AI to answer questions accurately from your organizational knowledge.

Creating Knowledge Base Elements

Build AI knowledge bases—understand core components, system architecture, and the principles behind semantic search.

Creating AI knowledge base elements

Knowledge Base Document Management

Manage documents, fine-tune parameters, and optimize performance—test queries and configure vectorization settings.

Knowledge base settings

Query testing

Vectorization configuration

Knowledge base configuration parameters

Full-Text and Semantic Search Using Knowledge Base Elements

Learn how to call knowledge bases in backend visual programming and understand how configuration settings participate in the query flow.

Calling AI knowledge base in backend visual programming

Semantic search

Adding a document

Deleting a document

Searching by keywords

How AI knowledge base settings participate in query flow

Integrating Knowledge Base into Agent

Integrate knowledge base into Agent to implement RAG.

Relationship Between Knowledge Base and Agent

Technical Integration Principles

Integration Modes

Using Knowledge Base in Agent

Deploying Vector Databases as Standalone Services

Intelligent storage engine for enterprise knowledge. Convert text into vector data to achieve semantic-level precise search.

Standalone deployment solution: Chroma vector database

Advantages of standalone deployment

Installing Chroma for standalone deployment

Connecting to a standalone Chroma database

Local configuration for development and testing

Vector database programming interface

AI Knowledge Base API Exposure

Expose AI Knowledge Base capabilities through API interfaces for external system integration.

📝 Coming soon...

AI agent

Build intelligent agents with reasoning and action capabilities. From creating Agents, configuring tools and knowledge bases, to managing memory, file spaces, and runtime extensions—master the full AI Agent development and integration workflow.

📝 English version coming soon... Please refer to the Chinese version for the latest content.

Skills

Capture reusable business experience, workflows, output standards, and prompting capabilities as Skills so multiple AI Agents can share the same professional capability set.

Learning Path

Capture Reusable Domain Expertise

Understand how Skills capture business workflows, output standards, decision rules, and examples as reusable capabilities for Agents.

What belongs in a Skill

Skills, Agents, knowledge bases, and tools

Reuse one Skill across multiple Agents

Start from one repeatable task

Create Standard Skills

Create a standard Skill from the IDE Skills entry, define its name and description, and open the editor to maintain reusable capability content.

Create from the IDE Skills entry

Use the name to describe capability

Use the description to define scope

Install the Skill after creation

Design Stable and Reusable Skills

Learn how to design Skills with clear boundaries, stable workflows, checkable output, and long-term maintainability.

Start from one repeatable task

Define capability scope

Use execution steps

Stabilize output format

Validate before reuse

Manage Skill Attachments

Move complex rules, glossaries, templates, and examples into attachments so the main Skill prompt stays clear.

What belongs in attachments

Split business rules

Maintain glossaries and templates

Main prompt and attachments

Install Skills in Agents

Install completed Skills into Agents, then choose intelligent mode, custom mode, or disabled mode based on the Agent's task scope.

Why Agents need Skills

Open Skills configuration

Intelligent mode

Custom mode

Install Skills in AI Agents

Scenario Practices

Build Query Skills

Use a data query scenario to learn how to design query Skills around data models, query templates, and field definitions.

Focus one Skill on one data scenario

Classify query requirements

Generate and verify templates

Core file structure

Checklist

AI File Storage

Prepare readable and writable file spaces for Agents, including Agent workspaces, user file spaces, and organization shared files.

📝 English version coming soon... Please refer to the Chinese version for the latest content.

AI Speech Recognition

Turn user recordings into text that Agents can process. Create speech recognition services, configure speech-to-text models, and enable voice input in Agent input and output settings.

📝 English version coming soon... Please refer to the Chinese version for the latest content.

Data modeling

Build a robust data foundation visually—no SQL expertise required. Create tables, design field types, establish relationships, and manage data with intuitive visual tools.

Creating Data Tables

Build your data foundation—create tables, configure fields, design data types, and set constraints for optimal data integrity.

Data table creation entry

Designing table fields and data types

Field operation buttons

Setting data titles

Configuring table indexes for query optimization

Multi-column composite unique constraints

Composite indexes

Source code mode

Creating Tables from Existing Database Schema

Quickly create data table elements from existing database tables, supporting rapid model generation.

Creating tables from existing database schema

Built-in Data Management Tools

Utilize built-in data management tools for efficient data operations and administration.

Built-in data management tools

Creating Data Model Functions

Design and implement custom data model functions to extend data processing capabilities.

Creating data model functions

Aggregated Table Model

Multi-table data integration and statistical analysis, supporting complex data aggregation and calculation functions.

Create aggregated table model

Multi-table data merge

Multi-table horizontal join

Group aggregate statistics

Extending custom calculation fields

Aggregate then filter

Filter first then aggregate (recommended)

Extension Table Model

Data extension based on existing tables, implementing business field extension and multi-table data integration through association with other data tables.

Extension table creation

Connection design

Setting baseline table filter conditions

Adding data tables

Real-time editing of statistics table configuration

Field statistics

Adding formula fields

Modifying field aliases

Function design

Creating functions

Source code viewing and editing

Using Data Models in Pages and Functions

Learn how to effectively use data models in frontend pages and backend function logic for data operations.

Built-in model functions

Calling data models in pages

Calling data models in functions

Creating Data Object Models

Specialized data structures engineered for full-code development environments, similar to DTOs, used for structured data expression and transmission in business logic.

Creating data object models

Using data object models

Customizing fields

Overriding model functions

Defining new functions

Calling Data Models with AI Agents

Add data model functions as Agent tools, enabling AI to intelligently perform CRUD operations and automated data processing.

Data models as Agent tools

Managing Database Connections

Configure and manage multiple database connections, supporting multi-data source application development.

Creating database connections

Multi-database connection management

Database connection security configuration

Connection testing and troubleshooting

Supported Database Vendors

Learn about various database types and connection configurations supported by JitAI.

Scenario selection recommendations

Cloud vendor compatibility

Database element usage

Transaction management

Ensure data integrity in complex operations—master transaction control, implement atomic operations, and handle concurrency safely.

Transaction Management

Control database transactions and maintain consistency—ensure reliable, atomic data operations across your application.

Default transaction management mechanism

Manual transaction commit/rollback

Transaction decorator

User and permission management

Build secure user systems with flexible authentication and authorization. Support multiple login methods, organizational hierarchies, and fine-grained permissions—ensure data security while enabling role-based access.

Configure secure authentication—support multiple login methods including password, phone, OAuth, and third-party providers.

Creating login authentication

Account password login

DingTalk self-built QR code login

WeCom self-built QR code login

WeChat login

WeChat official account login

WeChat mini program login

GitHub login

Google login

Define application roles and allocate permissions—implement fine-grained access control for portals, menus, and components.

Built-in application roles

Anonymous user

Developer

Administrator

Creating application roles

Application role permission configuration

Specifying accessible portals and menus

Managing application role members in the Developer Portal

Component button permission control

Component data field read/write/statistics permission control

Hierarchical management of multiple application roles

Application role member management

Member addition and removal

Member management scope settings in organization

Roles and Business Element Permissions

Apply advanced role-based access control to business elements, data models, and functional components.

Portal-level data operation type and scope control

Agent Tool Permission Control

Secure AI Agent operations—configure permission controls for tool execution and ensure safe, authorized agent actions.

Configuring Agent tool execution permissions

Workspace App Guides

Add JitAI applications to enterprise workspaces and configure password-free login and mobile access.

WeCom workspace app guide

DingTalk workspace app guide

Feishu workspace app guide

Business logic development

Implement powerful business logic with visual programming. Handle complex rules, respond to user actions, and execute background tasks—all as intuitive as assembling building blocks.

Creating Service Elements

Encapsulate reusable backend logic—create service functions that provide API interfaces and data processing capabilities.

Creating service functions

Editing service functions in source code mode

Adding new dependency libraries

Using cross-app service elements to call authorized APIs

Creating cross-app service elements

Using cross-app service elements in function logic

Calling Elements in Service Functions

Orchestrate comprehensive business logic—invoke data models, services, external APIs, and AI elements from service functions.

Using platform APIs to call other elements

Typical examples

Calling data model functions

Calling other service functions

Calling external APIs

Calling AI large language models

Calling AI agents

Service Elements Usage Scenarios

Discover practical patterns and best practices—apply service elements effectively across diverse business contexts and architectures.

Where service functions are used

Helping AI understand service functions accurately

Background Tasks

Automate workflows with scheduled and asynchronous tasks—execute complex background processes reliably.

Creating tasks

Scheduled tasks

Date field tasks

General configuration items

Developing task execution functions

Viewing execution records

Source code mode

Event Handling

Implement reactive business logic—monitor and respond to system events, model changes, and custom triggers.

Agent tool call events

Replacing event internal functions with service functions

Enabling events

Executing events synchronously or asynchronously

Viewing event execution records

Viewing and editing full code

Approval process

Streamline enterprise approvals with visual workflow design. Drag and drop to create flowcharts, configure approvers and conditions, and automate routing—transform paper-based processes into efficient digital workflows.

Approval Process Basic Configuration

Creation and basic settings of approval processes, including process node configuration and path design.

Creating Processes

Configuring Process Nodes

Approval Workflow Default Pages

Prediction Capabilities

Additional Process Configuration

Synchronizing Approval Information to Data Table Models

Prediction Functionality

Synchronizing to Third-party Approval To-do Systems

Comment Functionality

Sharing Capabilities

Printing Approval Forms

Reusing Existing Approval Workflows

Start Node Configuration

Configuration of approval process start node, defining conditions and rules for application initiation.

Process Cancellation Function

Approval Reminder

Approval Draft

Message Notification

Pages Used by Current Node

Summary Display

Field View Edit Permissions

Layout Control Permissions

Approval Node Configuration

Detailed configuration of approval links, including approver settings and approval rules.

Approver Settings

Approval Flow Rules

Approval Workflow Processing Rules

Approval Extended Functionality Configuration

Deduplication Approval

Time-limited Processing

Approval Drafts

Approval Feedback

Handwritten Signatures

Batch Approval Permissions

Message Notifications

SMS Notifications

Approval Page and Permission Control

Pages Used by Current Node

Summary Information Display

Field Permissions

Layout Control Permissions

Special Node Configuration

Configuration methods for special process nodes such as condition nodes and parallel nodes.

CC Node

CC Recipients

SMS Notification

Pages Used by Current Node

Field Permission

Layout Control Permissions

Sub-process Initiator

Sub-process Flow Rules

When Main Process Flows to Sub-process

Sub-process Post-flow Function Design

Update Main Process Data When Single Sub-process Ends

Update Main Process Data When All Sub-processes End

Approval Page Customization

Customize approval interface and user experience to improve approval efficiency.

Advanced Approval Page Customization

Approval Page Types

Custom Page Creation Methods

Approval Process Usage

Practical application and operation guide of approval process, including initiating and processing approvals.

Initiating Applications

To-Do Center

Detail Pages

Delegating to Others for Processing

Approval Workflow Management Pages

Calling Business Logic Elements in Approval Process

Learn how to call business logic elements within approval processes to implement complex business rules and automated decisions.

Calling Business Logic Through Approval Events

Function Processing in Subprocesses

Integrating AI in Approval Process

Integrate artificial intelligence capabilities into approval processes to achieve intelligent routing, automated review, and smart decision making.

📝 Coming soon...

File processing

Handle files effortlessly—upload and download multiple formats, dynamically generate Word and Excel documents, and streamline all file operations.

File Storage

Configure file upload and storage—support local disk, cloud providers (OSS, S3, MinIO), and comprehensive file management.

Local storage configuration

Adding local storage

Specifying disk storage directory

Cloud storage service configuration

Alibaba Cloud OSS

China Mobile Cloud EOS

Using environment variables to prevent config info leak

Setting application default storage service

Calling file upload in frontend code

Creating File Templates

Document template generation and processing, supporting dynamic content filling and format conversion.

Word template

Creating word template

Creating word template variables

Using template variables in Word documents

Excel template

Creating Excel template

Creating Excel template variables

Using template variables in Excel documents

Template variable style description

Text styles

Numeric styles

Date-time styles

Multi-value styles (complex types)

Generating and Printing Files Using File Templates

Learn how to use file templates to generate and print documents programmatically, including dynamic content population and output formatting.

Printing Word templates

Printing Excel templates

Generating attachments

External API integration

Connect to the broader ecosystem—integrate third-party APIs, payment gateways (WeChat Pay, Alipay), and SMS services to extend your application's capabilities.

Creating Universal External API Elements

Integrate third-party HTTP APIs seamlessly—manage RESTful calls with standard methods, preprocessing, and response handling.

Creating External APIs

Public Configuration

Access Domain

Public Request Headers

Request Preprocessing

Response Postprocessing

API Interface Management

API Interface Grouping

API Interface Testing and Calling

API Interface Testing

API Calling

Built-in Payment Services

Integrate mainstream payment platforms to implement online payment and transaction functions.

Configuring WeChat Payment Service

Configuring Alipay Payment Service

Using Payment Services

Built-in SMS Service

SMS sending and notification service integration, supporting verification codes and message push.

Alibaba Cloud SMS

Creating Alibaba Cloud SMS Service

AWS SNS SMS

Creating AWS SNS SMS service

Twilio SMS

Creating Twilio SMS service

Using SMS Service in Mobile Login

Using SMS Service in Approval Workflows

SMS Notification Function

Cache management

Boost performance with intelligent caching. Configure caching strategies to optimize data access speed and ensure smooth operation under high concurrency.

Cache Configuration and Usage

Application cache strategy configuration to improve system performance and response speed.

Cache Service Configuration

Multi-cache Service Management

Cache Programming Interface Usage

Internal API exposure

Expose application capabilities as APIs—generate standard interfaces, manage permissions, and monitor usage to enable external system integrations.

API Authorization

Permission control and access authorization management for API interfaces.

API Authorization Creation

API Authorization Detail

Call Records

API Exposure Examples for Various Elements

Comprehensive examples demonstrating how to expose different types of elements as APIs, including data models, services, and custom functions.

API Authorization for Service Functions

API Authorization for Data Models

API Authorization for Large Language Model Functions

API Authorization for AI Agents

API Authorization for Approval Processes

Using SDK to Call Authorized Element APIs

Learn how to use official SDKs to call authorized element APIs, including authentication, request handling, and error management.

Using Python SDK

Using Node.js SDK

Using Java SDK

Using Cross-App Service Elements to Call Authorized APIs

Implement cross-application API calls using service elements, enabling seamless integration between different JitAI applications.

Using Cross-App Service Elements

Internationalization

Reach global audiences—support multiple languages, regional settings, and dynamic language switching for truly international applications.

Creating Language Packages

Learn how to create custom language packages for your application, including structure definition and content organization.

Creating language packages

Translating built-in terms

Adding new terms

Importing terms

Extending System Built-in Language Packages

Extend and customize existing system language packages to meet specific business requirements and regional needs.

How to Translate Page Terms

Master the techniques for translating page content, including dynamic text replacement and context-aware translations.

Automatic text translation

Dynamic text translation

DOM node attribute translation

Using API translation

Translation Ignore Rules

Configure rules to exclude specific content from translation, ensuring proper handling of brand names, technical terms, and other non-translatable content.

Basic usage

Advanced configuration

Configuration method

Default Language

Configure the default language for your application to ensure optimal user experience for first-time visitors and users without explicit language preferences.

Default language configuration

Language selection strategy

Configuration recommendations

Frontend UI customization

Craft unique brand experiences—customize themes, develop exclusive UI components, and align interfaces with your corporate identity while enhancing user experience.

Global Styles

Application overall style and theme configuration, unifying interface style and user experience.

Creating a global style element

Modifying the global style

More style variables

Debugging the theme

Custom Controls

Develop personalized UI components to meet special business needs and interaction requirements.

Creating Custom Control Element

Modifying Custom Control

Using Custom Control in Forms

Using Custom Control in Tables

Custom Control Parameters

Component Customization

Platform provides two main approaches for component customization to meet different development needs and scenarios.

Developing Full-code Components

Extending Component Type Elements

Page Customization

Specific development technologies and usage patterns for full-code pages, including style processing, component usage, resource management, and data operations.

Portal Customization

Full-code custom portals provide flexible solutions for navigation layout adjustment, interface style customization, and interaction method optimization.

Creating Custom Portal

Core File Structure

Important APIs and Methods

Portal Basic APIs

Page Rendering and Navigation

Permission Verification

Advanced guide

Master complex architectures and best practices through real-world scenarios—in-depth guides for advanced application development.

Development and Operations Process

Optimize your workflow—master development processes, debugging techniques, and production deployment for stable applications and efficient team collaboration.

Local Development and Debugging

Team Collaborative Development

Application Layer Stability Guarantee

Frontend Debugging Guide