Intelligent Agent

Overview

An intelligent agent is a virtual entity with a clearly defined identity and purpose, carefully designed by users through role instructions. Its core value lies in its ability to communicate naturally with users via conversational language, understand their needs, and utilize predefined knowledge, capabilities, and logical frameworks to think and reason. The agent proactively generates appropriate responses or performs relevant actions—including task completion, information provision, and service delivery—to meet user requirements or achieve specified objectives. Through user-friendly interfaces, simple integration methods, and broad application scenarios, intelligent agents can fulfill users' daily needs for intelligent assistants, information retrieval, and recommendation services. Additionally, intelligent agents can serve various vertical industries and business scenarios, effectively expanding market coverage and enhancing user engagement. Users can engage directly with intelligent agents in independent conversations to obtain contextual, coherent knowledge and services.

The Celia Open Platform is a capability-driven platform that Celia offers to developers, integrating intent frameworks with Huawei's large AI model capabilities. Built on this foundation, Celia Intelligent Agent Platform enables developers to create intelligent agents that provide innovative AI experiences in the era of large AI models, helping to drive business growth. Developers can utilize the Celia Intelligent Agent Platform to develop customized intelligent agents, delivering new intelligent solutions for users.

This document provides guidance on how to quickly build intelligent agents on the Celia Intelligent Agent Platform, focusing on intelligent Q&A and audio playback scenarios, and how to adapt these agents to meet specific use case requirements.

The development of an intelligent agent involves five key steps:

1. Agent creation: Developers must register an enterprise or personal account on the Celia Open Platform to gain access to HarmonyOS ecosystem development permissions. Using the Celia Intelligent Agent Platform, they can swiftly launch projects and customize their own dedicated intelligent agents.
2. Mode selection: Different agent modes are suited to different scenarios. Developers can choose the appropriate mode based on their business needs to develop and build intelligent agents tailored to specific use cases.
3. Agent orchestration: Developers can utilize a visual workflow orchestration framework to define agent capabilities, customize functionality, and optimize scenarios for better performance.
4. Function verification: Multiple verification methods are available, including real-time, visual, and scenario-based testing. Developers can perform interactive real-time testing or verify agents within actual application scenarios.
5. Release: Agents go through a review process to ensure security and compliance for publicly released information. This helps to safeguard release quality and further enhance user experience.

How to Develop

AI agent creation

Log in to the Celia Open Platform and click Try Now. The main page of Celia Intelligent Agent Platform is displayed. Click +Create Agent in the upper left corner to start the intelligent agent creation process. You can set the information about the intelligent agent, including the name, profile picture, intelligent agent description, intelligent agent category, and running device. For details, see the developer guide Quick Creation.

Permission application: Developers need to send an email to hagservice@huawei.com, provide the enterprise alliance account, platform (such as the intelligent agent platform) for which the whitelist needs to be enabled, and application reason, and wait for the whitelist to be enabled. After the enterprise whitelist is enabled, enterprise developers can use the platform.

Preparations: Real-device debugging and device plugin development must be performed on devices running HarmonyOS 5.1.0 Release or later.

Select a mode

Intelligent agents are classified into LLM, agent, and workflow modes. The intelligent agent mode varies according to the scenario.

In LLM mode, intelligent agents mainly rely on the capabilities of large language models (LLMs), such as language understanding, generation, and reasoning, to process tasks and answer questions. Generally, intelligent agents in this mode directly generate responses based on the knowledge and algorithms of LLMs and do not involve or involve few external tool calls and complex process control.

Intelligent agents in agent mode have high autonomy and flexibility. They can independently determine the process, select tools, and determine the task completion mode, and dynamically adjust the task execution policy based on different situations. They can call various external tools (such as APIs and databases) based on task requirements and properly arrange the workflow to complete complex tasks. (The agent mode is not described in the following sections. You need to apply for the permission separately.)

Intelligent agents in workflow mode coordinate the interaction between intelligent agents and tools through predefined code paths. They break down tasks into multiple steps according to a specific sequence or rule. Each step has a clear input and output. Intelligent agents execute the steps in sequence according to the preset process to achieve the task objectives. This mode emphasizes predictability and consistency and is suitable for scenarios where tasks are clear and processes are fixed.

The functions of capability expansion vary according to the orchestration mode of intelligent agents. For details about the differences between orchestration modes, see the intelligent agent classification in the developer guide. Developers can select an orchestration mode based on the differences between modes, set intelligent agent information, and create an intelligent agent in the corresponding mode.

Intelligent twins orchestration

After an intelligent agent is created, go to the orchestration page of the intelligent agent, add various capabilities to the intelligent agent, and optimize and improve the intelligent agent. The opening dialog allows users to quickly understand the functions or scenario settings of your agent. The preset questions allow users to quickly experience the capabilities of the agent by clicking. The role instructions (prompts) directly determine the effect of the agent you create. For more capabilities, developers can customize the background and capabilities of the agent by referring to the capability expansion function description.

The following figure shows the orchestration pages in LLM and workflow modes.

Function Verification

After an agent is set up, developers can chat with the agent in the debugging and preview area to test whether the agent functions are the same as expected, and optimize and adjust the agent configuration based on the agent execution process and response information. For details about the debugging process, see the debugging and preview function description in the developer guide. Two function verification modes are provided: real device test and debugging.

Release

After the function test is complete, click Save and Release to submit the agent to the release review phase. For details about the process, see the release, suspension, and upgrade process description in the developer guide. To ensure that your agent can pass the review, you can check your agent by referring to the release review specifications. After the agent is approved and released, you can use the complete agent on the Xiaoyi platform.

Intelligent Q&A Scenario

When to Use

The intelligent Q&A system has been widely used in multiple fields due to its efficient and convenient interaction features. Based on the knowledge base, the intelligent Q&A system can accurately match user requirements and provide accurate and professional answers. For example, in the medical scenario, if a user describes "cough + fever", the system recommends a department based on the symptom library and displays "possible flu risk". The core value of intelligent Q&A lies in solving the problem of information acquisition efficiency through natural language interaction. It usually directly generates responses based on the knowledge base or knowledge and algorithms in the large language model released by developers according to user input, implementing more accurate and personalized services. Accurate and standard answers (all answers are based on the knowledge base or official data preset by enterprises to avoid inconsistent answers caused by understanding deviation or memory errors of manual customer service) and controllable service quality (enterprises can update the knowledge base at any time to ensure that the answers are synchronized with the latest policies, such as tax law adjustment and product update).

Scenario Development

Model selection

The intelligent Q&A scenario mainly involves simple language interaction (such as chatting and knowledge query) and does not need to invoke external tools. Therefore, the LLM mode is preferred to generate answers based on internal knowledge. The LLM mode has core advantages in natural language processing, knowledge integration efficiency, and interaction experience. With these native advantages, the LLM mode becomes the mainstream choice for intelligent Q&A, especially suitable for knowledge-based, interactive, and cross-domain Q&A scenarios.

The Q&A agent intelligently integrates internal knowledge based on the knowledge base provided by developers to generate required answers. Therefore, in addition to selecting an intelligent agent in LLM mode, you need to customize the knowledge base for the required scenario.

Creating and Putting Away a Knowledge Base

1. Create a knowledge base: Click Create Knowledge Base on the knowledge base page of the workspace on the Xiaoyi Open Platform. On the page that is displayed, enter the knowledge base information and click Create. The knowledge base is created successfully.
2. Configuring a Knowledge Base: Click the name of the new knowledge base in the knowledge base list to go to the knowledge list page. Click Create Knowledge, import the file of the corresponding knowledge type, enter related information, and click OK. The knowledge is added successfully. For details about the process, see the developer guide Creating a Knowledge Base.
3. Putting away the knowledge base: Click Put Away of the corresponding knowledge and wait for the knowledge base to be reviewed and put away. Document knowledge can be put away only after data verification is complete.

Creating an Intelligent Agent in LLM Mode

1. Create an intelligent agent: Create an intelligent agent in LLM mode by referring to the preceding development procedure.
2. Orchestrate an intelligent agent: Go to the intelligent agent orchestration page, edit the opening dialog of the intelligent agent, and add the knowledge base that has been put away. Developers can also orchestrate the knowledge base based on actual service requirements.

Function verification

Debugging test or real machine test. To perform a real machine test, you need to add a whitelist, set a whitelist mobile phone or account, and release the mobile phone intelligent agent.

1. Debugging test: You can perform interaction tests on the debugging and preview pages and preview actual interaction scenarios. You can also click the debugging button in the upper right corner to go to the debugging details page and view detailed debugging information.

   

2. Real machine test: Click Real Machine Test in the upper right corner of the debugging and preview page to release the real machine test. Before the real machine test, you need to configure a whitelist. Developers (team accounts require administrator permissions) can add groups to manage real machine debugging users. Each team can create a maximum of 100 user groups, and each user group can add a maximum of 100 users. After the service is released to the real machine for debugging, users in the real machine debugging user whitelist can access the development and test service. For details, see the developer guide Real Machine Test.

Putaway and Upgrade

After the function test is complete, click Save and Putaway to submit the intelligent agent to the putaway review phase. For details, see the developer guide Putaway and Upgrade Process.

Audio playing scenario

When to Use

Audio playback has a wide range of application scenarios. It can be classified into multiple applicable types based on the application scenario, device type, and function requirements. Audio playback in different scenarios focuses on real-time performance, sound quality, device adaptation, offline capability, and privacy security.

Scenario Development

Model selection

An audio playback scenario app generally includes functions such as jumping to the playback page, playing audio, and obtaining the song name. If you want to implement the preceding functions through voice or text operations in an intelligent manner in a project that involves audio playback scenarios, you need to use the intelligent agent architecture of the device plug-in and workflow mode. This architecture not only solves intelligent interaction (voice/text instructions) in audio playback scenarios, but also provides an efficient local execution carrier, forming an efficient architecture of localized processing and process collaboration. With the workflow mode, node control (such as audio playback, page redirection, and information obtaining) is set. The device plug-in can locally coordinate the interaction of multiple modules and run the function modules on the local device.

Audio playback scenarios are mainly based on functions such as audio encoding and decoding, and require support from external tools. The audio playback function can be implemented on the device plug-in. In addition, audio playback scenarios generally involve functions such as page redirection, audio playback, and information obtaining. By designing process nodes, you can build the overall process required by the service. Therefore, in addition to selecting the intelligent agent in workflow mode, you also need to implement the device plug-in that adapts to the process nodes.

Creating and Releasing a Device Plug-in

1. Create a device plug-in: On the Plug-in page of the workspace of the Celia Open Platform, click Create Plug-in, select a device plug-in, and enter the app package name and name. Click Save. The device plug-in is created successfully, and the device plug-in editing page is displayed.
2. Configure the device plug-in: Click Create Tool. On the tool information page, enter the tool name and click Create to add a tool. Click Add Version, set parameters as prompted, and click Create. On the tool information page, add input and output parameters as required, and click Save. The tool configuration of the device plug-in is complete. You can add multiple tools by performing the preceding operations. Developers can configure the tools as required. For details about the configuration method, see the developer guide Creating a Device Plug-in.

   This scenario involves three functions: obtaining the song name, jumping to the playback page, and playing audio. Therefore, three tools corresponding to the functions are configured. The following figure shows the configuration information.

   Expand

   Data Details	Redirect to	Audio playback

3. Release: After configuring the device plugin information, click Release, enter the version information, and click OK. The device plugin is released for review. After the device plugin is released, you can use the released device plugin in other scenarios.

Device Plugin Development

As a function module running locally on the device, the device plugin provides capabilities on the HarmonyOS device. The code needs to be implemented on the device. The implementation of the audio playback scenario involves the following steps:

1. Create the entry/src/main/resources/base/profile/insight_intent.json file in the root directory of the device application project to bind the tool in the device plugin implemented in the previous step.

   intentName indicates the tool name, intentVersion indicates the tool version, and srcEntry indicates the service logic processing file of the InsightIntentExecutor class method based on the intent framework.

   Collapse

   Word wrap

   Dark theme

   Copy code

   {
     "insightIntents": [
       {
         "domain": "",
         "intentName": "PlayHiddenAudio",
         "intentVersion": "1.0.0",
         "srcEntry": "./ets/entryability/InsightIntentExecutorImpl.ets",
         "uiAbility": {
           "ability": "EntryAbility",
           "executeMode": [
             "background"
           ]
         }
       },
       {
         "domain": "",
         "intentName": "GetAudioName",
         "intentVersion": "1.0.0",
         "srcEntry": "./ets/entryability/InsightIntentExecutorImpl.ets",
         "uiAbility": {
           "ability": "EntryAbility",
           "executeMode": [
             "background"
           ]
         }
       },
       {
         "domain": "",
         "intentName": "OpenSecondPage",
         "intentVersion": "1.0.0",
         "srcEntry": "./ets/entryability/InsightIntentExecutorImpl.ets",
         "uiAbility": {
           "ability": "EntryAbility",
           "executeMode": [
             "background",
             "foreground"
           ]
         }
       }
     ]
   }

2. Business logic processing when the bound endpoint plug-in is invoked
   Collapse

   Word wrap

   Dark theme

   Copy code

   import { insightIntent, InsightIntentExecutor } from '@kit.AbilityKit';
   import { BusinessError } from '@kit.BasicServicesKit';
   import AudioPlayHandler from './intentHandlers/AudioPlayHandler';
   import TextGetHandler from './intentHandlers/TextGetHandler';
   import PageNavigateHandler from './intentHandlers/PageNavigateHandler';
   import { window } from '@kit.ArkUI';
   
   export default class InsightIntentExecutorImpl extends InsightIntentExecutor {
     // Instruction implementation class.
     private audioHandler = new AudioPlayHandler();
     private textHandler = new TextGetHandler();
     private pageHandler = new PageNavigateHandler();
   
     // Intention execution method for backend execution.
     async onExecuteInUIAbilityBackgroundMode(
       intentName: string,
       params: Record<string, object>
     ): Promise<insightIntent.ExecuteResult> {
   
       try {
         switch (intentName) {
           // Play audio intention.
           case 'PlayHiddenAudio':
             const stringParam: Record<string, string> = this.convertToRecord(params);
             return this.audioHandler.execute(stringParam);
   
           // Obtain audio name intent.
           case 'GetAudioName':
             return this.textHandler.execute();
   
           default:
             return {
               code: -1,
               result: {
                 'status': 'failed',
                 'message': `not valid intent name, ${intentName}`
               }
             };
         }
       } catch (error) {
         return {
           code: -2,
           result: {
             'status': 'failed',
             'message': `Intent execution failed: ${(error as BusinessError).message}`
           }
         };
       }
     }
   
     private convertToRecord(origin: Record<string, object>): Record<string, string> {
       const result: Record<string, string> = {};
       Object.keys(origin).forEach(key => {
         result[key] = String(origin[key]);
       });
   
       return result;
     }
   
     // Execution method of backend execution intention.
     async onExecuteInUIAbilityForegroundMode(name: string, param: Record<string, Object>, pageLoader: window.WindowStage):
       Promise<insightIntent.ExecuteResult> {
       switch (name) {
         // Open the second page intention.
         case 'OpenSecondPage':
           return this.pageHandler.execute();
         default:
           pageLoader.loadContent('pages/MainPage');
           break;
       }
       return Promise.resolve({
         code: -1,
         result: {
           message: 'unknown intent'
         }
       } as insightIntent.ExecuteResult)
     }
   }

   InsightIntentExecutorImpl.ets
3. Functionality Development
   • Implement the function to obtain the song name and return the read result.
     Collapse

     Word wrap

     Dark theme

     Copy code

     import { insightIntent } from '@kit.AbilityKit';
     import { BusinessError } from '@kit.BasicServicesKit';
     import { MediaService } from '../../utils/audioplayer/MediaService';
     
     export default class TextGetHandler {
       async execute(): Promise<insightIntent.ExecuteResult> {
         try {
           // Execute the method of obtaining the name of the played audio.
           const audioName: string = MediaService.getInstance().getAudioFileName();
     
           // Return result.
           return {
             code: 0,
             result: {
               status:'success',
               audioName: audioName.toString(),
               message: 'get audio name success'
             }
           };
         } catch (error) {
           throw new Error(`get audio name failed: ${(error as BusinessError).message}`);
         }
       }
     }

     TextGetHandler.ets
   • Use deep linking to implement redirection to the playback page.

     Configure the skills tag in the module.json5 file to identify the redirection scenario.

     Collapse

     Word wrap

     Dark theme

     Copy code

     "skills": [
       {
         "entities": ["entity.system.browsable"],
         "actions": [
           "ohos.want.action.viewData"
         ],
         "uris": [
           {
             "scheme": "demo",
             "host": "aiagentdemo.com",
             "path": "SecondPage"
           }
         ]
       }
     ]

     module.json5

     In the onNewWant() lifecycle callback in the EntryAbility.ets file, obtain and parse the app link passed by the launcher, and customize subsequent service processing.

     Collapse

     Word wrap

     Dark theme

     Copy code

     onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
       hilog.info(DOMAIN, 'testTag', 'Received URI:', want.uri);
       const uri = want.uri;
       if (uri) {
         const urlObj = url.URL.parseURL(uri);
         let pathname = urlObj.pathname;
         uiContext?.getRouter().pushUrl({ url: 'pages' + pathname });
       }
     }

     EntryAbility.ets

     Execute the page redirection and return the redirection result.

     Collapse

     Word wrap

     Dark theme

     Copy code

     import { insightIntent } from '@kit.AbilityKit';
     import { BusinessError } from '@kit.BasicServicesKit';
     
     export default class PageNavigateHandler {
       async execute(): Promise<insightIntent.ExecuteResult> {
         try {
           // Execute page redirection.
           let uiContext: UIContext | null | undefined = null;
           uiContext = AppStorage.get('uiContext')
           uiContext?.getRouter().pushUrl({ url: 'pages/SecondPage' });
     
           return {
             code: 0,
             result: {
               status: 'success',
               message: 'Navigation successful',
               targetPage: 'SecondPage'
             }
           };
         } catch (error) {
           throw new Error(`Page navigation failed: ${(error as BusinessError).message}`);
         }
       }
     }

     PageNavigateHandler.ets
   • You can customize the audio playback function based on service requirements.
     Collapse

     Word wrap

     Dark theme

     Copy code

     import { insightIntent } from '@kit.AbilityKit';
     import { BusinessError } from '@kit.BasicServicesKit';
     import { MediaService } from '../../utils/audioplayer/MediaService';
     
     export default class AudioPlayHandler {
     
       async execute(param: Record<string, string>): Promise<insightIntent.ExecuteResult> {
         try {
           // Analyze the parameters passed in by the plugin on the parsing end.
           const rawAudioName = param.audioName;
           const audioName = rawAudioName.toString();
     
           // The method of playing audio can be customized by developers according to their actual business needs.
           MediaService.getInstance().initAudioPlayer(audioName);
     
           // Return the result to the end plugin.
           return {
             code: 0,
             result: {
               status: 'success',
               message: `play audio ${audioName} started`,
             }
           };
         } catch (error) {
           throw new Error(`Audio play failed: ${(error as BusinessError).message}`);
         }
       }
     }

     AudioPlayHandler.ets

Creating and Putting Away a Workflow

1. Create a workflow: On the workflow page of the Xiaoyi Open Platform workspace, click Create Workflow, enter the workflow information, and click OK. The workflow is created successfully and the workflow editing page is displayed.
2. Orchestrate workflows.
   1. After creating a workflow, click Add Node on the canvas, click the Plug-in button, select a released device plug-in in the workspace, and click Add to add the required plug-in to the canvas.
   2. The functions of obtaining the song name, jumping to the playback page, and playing audio are parallel. You can click Add Node on the canvas, add a selector, click the added selector, and set conditions corresponding to different branches on the selector editing page on the right. If the conditions are met, the corresponding branch is run in the next step. (You can click the plus sign (+) on the right of the condition branch to add a branch.)
      Expand

      Creating a Selector	Selector Condition Branch

   3. Connect the corresponding nodes according to the task execution sequence.

      

3. Test and put away: Click Trial Run. The debugging page is displayed. You can test the entire process. (The device plug-in adaptation cannot be debugged on the Xiaoyi Open Platform. Only the entire workflow process can be tested.) After the test is successful, click Put Away. The putaway review phase starts. After the review is approved, you can add the plug-in to the intelligent body.

   

Intelligent Body Orchestration in Workflow Mode

After the device plug-in and workflow required for the audio playback scenario are developed and released, the intelligent body is built.

1. Create an intelligent body: Create an intelligent body in workflow mode by referring to the preceding development steps.
2. Orchestrate an intelligent body: Go to the intelligent body orchestration page, orchestrate the opening dialog of the intelligent body, and add the released workflow. Developers can build the intelligent body based on actual service requirements.

Function verification

1. Debugging and testing: You can perform interaction tests on the debugging and preview pages and preview actual interaction scenarios. You can also click the debugging button in the upper right corner to go to the debugging details page and view detailed debugging information.
   Expand

   Debugging and Preview	Debugging Description

2. Real device test: Device plug-ins involve applications on the device side. Therefore, platform debugging cannot be used for joint commissioning with applications on the device side. You can only experience the actual effect of the intelligent body on the device side. For details about the test process, see the developer guide Real Device Test.

Putaway and upgrade

After the function test is complete, click Save and Put Away to submit the intelligent body to the putaway review phase. For details about the process, see the developer guide Putaway/Uninstallation and Upgrade Process. After the release, you can search for and use the created intelligent body on the intelligent body page of Xiaoyi on the device side. The figure below shows the preview.

Summary

Intelligent agents are characterized by human-like interaction and intelligent decision-making, and can cover multiple scenarios. The interaction intelligence and scenario customization features of intelligent agents can meet user and industry requirements. The Celia Agent platform provides developers with full-process tool support from creation to release, helping developers quickly implement intelligent agents.