01#
Introduction
The Qizhi platform is designed for building generative AI native applications. Through the Qizhi platform, we can significantly simplify complex technical tasks and build various types of applications through visual orchestration, making creativity and innovation faster, better, and easier to achieve.
When we were kids, we played with building blocks, constructing castles, planes, or even entire cities by stacking various colors and shapes. Now, if there is a digital world of building blocks, we can use these “blocks” to build intelligent programs that can read, understand, and write text, and even converse with us. This is what the Qizhi platform aims to do and has already achieved; it is like a massive set of building blocks waiting for creators of AI applications to explore and build.
02#
Overview of Qizhi Platform
03#
Prompt Engineering
One of the core values of the Qizhi platform is that it provides a standard model interface, allowing us to freely switch between different models, including text, image, video, audio, and multi-modal models.
When it comes to models, you can think of them in terms of ChatGPT. A simple model can only generate text content, but as large models continue to evolve, their cross-modal capabilities are continuously enhanced, including:
1. Standard LLM:Receives a text string as input and returns a text string as output.
2. Chat Model:Takes a list of chat messages as input and returns a chat message.
3. Visual Model:Takes text and images or videos as input and returns a text string as output.
4. Speech Model:Takes speech as input and returns a text string as output.
The Qizhi platform provides a unified Prompt engineering system, supporting orchestration, debugging, optimization, and version management of Prompts, making it easier for us to construct the desired Prompt templates. We can save Prompt templates for reuse. Based on the platform, we can quickly implement the construction and tuning of Prompt engineering, with common functional processes as shown in the diagram below.
04#
RAG Pipeline
To address the limitations of purely parametric models, language models can adopt a semi-parametric approach, combining non-parametric corpus databases with parametric models. This approach is known as RAG (Retrieval-Augmented Generation).
1. Overall Process of RAG
The overall business chain of RAG mainly consists of five steps: knowledge production and processing, query rewriting, data retrieval, post-processing, and large model production.
The Qizhi platform, based on Native RAG, provides various general RAG capabilities combined with Advanced RAG and RAG-Fusion solutions:
Knowledge Slicing: Fixed character slicing, redundant slicing, semantic sentence slicing, regex slicing, etc.
Query Generation/Rewriting: Uses LLM models to rewrite the user’s initial query, generating multiple queries.
Vector Search: Conducts vector-based searches for each generated query, forming multi-route search retrieval.
Inverse Ranking Fusion: Applies inverse ranking fusion algorithms to reorder documents based on their relevance across multiple queries.
Re-ranking: Uses various re-ranking algorithms to reorder the results.
Output Generation: Generates final output based on the top K search results after reordering.
2. RAG Platform Plan
To facilitate user usage, the Qizhi platform provides a visual RAG Pipeline construction, allowing for quick setup of RAG applications. Below is the architecture diagram of Qizhi RAG.
The RAG platform provides knowledge base management, RAG application orchestration and debugging, supports one-click deployment of various popular open-source embedding models, and supports Rerank reordering, multi-version management, data and annotation, etc.
It also offers a series of functional modules and API services, including chunking services, embedding, vector services, knowledge base services, etc. For businesses with in-depth customization needs, more tailored RAG applications can be built through flexible combinations via APIs.
On the platform, users can quickly build a RAG application through visual orchestration, and then integrate the application into engineering projects by calling the application APIs:
05#
Workflow
-
Conversation Workflow: Designed for conversational scenarios, requiring multi-step logic in building responsive conversational applications. -
Text Workflow: Designed for automation and batch processing scenarios, suitable for high-quality translation, data analysis, content generation, and more.
|
Segment |
Node Type |
Description |
|
Start |
Start Node |
The start node is used to receive user questions, assigning the user input to variables and passing it to subsequent nodes. |
|
Identify User Intent |
Question Classification Node |
Fill in classification information in this node. This node will classify the user’s questions and forward them to different branches for processing based on the classification. For example: Monitoring-related issues will be directed to the monitoring branch for processing. |
|
Process User Questions |
Knowledge Base Node, Large Model Node |
|
|
End |
End Node |
Outputs the intelligent agent’s reply content. It can directly reference data from preceding nodes through output variables for the response content. |
06#
Plugins
Plugins are extensions of large model capabilities, typically expanding large model capabilities by calling external APIs. For example, the process of calling a plugin in OpenAI is shown in the diagram below:
Based on the plugin calling process and plugin description specifications of OpenAI, the Qizhi platform has designed and implemented a custom plugin development process, recognizing and calling plugins based on Function call, ReAct, etc., extracting the parameters required by the plugin from user input, calling the plugin API, and then summarizing the results of the plugin API responses through the large model. The diagram below illustrates the plugin process based on Function call:
For users, the process of creating custom plugins on the Qizhi platform is relatively simple. After writing the plugin’s API description in the ibrain.yaml file, users can upload it to the Qizhi platform, and upon verification, the plugin can be created. Once created, it can be used across various applications to extend the capabilities of large models. The process of creating plugins is shown in the diagram below:
07#
Agent
The Qizhi platform supports creating agents through basic templates and free creation.
According to the review paper on LLM-based Agents by the Natural Language Processing Team at Fudan University titled <<The Rise and Potential of Large Language Model Based Agents: A Survey>>, it mentions that “Agent = LLM + Perception + Planning + Memory + Tool Usage” is the basic architecture, where the large model LLM acts as the “brain” of the agent, providing reasoning and planning capabilities in this system. The overall architecture is shown in the diagram below:
The agent framework consists of several components, namely Perception, Planning, Memory, Action, etc., which will be briefly introduced:
-
Perception: Receives and processes multi-modal information from the external environment.
-
Planning: Mainly includes sub-goal decomposition, reflection, and improvement.
-
Memory: Includes short-term memory and long-term memory.
-
Action: Uses text or tools (calls external APIs to obtain additional information missing in model weights, including current information, code execution capabilities, access to proprietary information sources, etc.) to perform actions that impact the external environment.
"relationship_graph": {
"planner": ["engineer"],
"engineer": ["executor", "critic"],
"critic": ["engineer", "planner"],
"executor": ["engineer"]
}
08#
Memory (Coming Soon)
The Qizhi platform provides simple settings for businesses to enable agent memory functions. Once the memory function is activated, interactions in business scenarios with agents will be recorded and converted into long-term memory based on pre-defined business requirements. The conversion process mainly involves fact extraction during interactions, updating existing long-term memory, deletion, etc. When interacting with agents again in business scenarios, the memory service will provide the most relevant long-term memory based on the current context, offering a more relevant user experience.
Memory Application Case:
During conversations with the large model application, users reveal their preferences but are forgotten after multiple rounds of dialogue (the model responds incorrectly):
1. User: Sing a song for me.
2. Application: I can only sing pop songs, is that okay?
3. User: Yes, I like Jay Chou.
4. Application: Okay (clears throat), starting to sing Chrysanthemum Terrace.
5. … (over 100 rounds)
6. User: Play a song I like.
7. Application: Okay, what song do you like?
After a certain number of dialogues, using the memory function to store and extract transformations, we obtain key preference settings for the character, which can then be extracted based on user input (such as user preferences) in the future.
09#
Application Case: Build an AI Robot in 10 Minutes
On the Qizhi platform, it only takes 10 minutes, without writing a single line of code, to create an AI robot empowered by large model capabilities. This robot can respond to user inquiries 24/7 and can answer private domain questions, becoming a dedicated robot for the business.
Creating an AI robot on the Qizhi platform is very convenient:
-
Create a large model application, including conversation, plugins, workflows, agents, and other types of applications.
-
After creating the application, apply for API permissions, and then submit a form to create a Feishu robot on the Qizhi platform to convert the application into a Feishu robot.
-
You can also add private domain knowledge to the robot, enable knowledge retrieval enhancement (RAG), and add memory support for long-term memory, gradually enriching and expanding the robot’s capabilities to better meet user inquiries.
10#
Outlook
👆👆👆Welcome to Follow👆👆👆
Welcome to Leave Comments for Discussion