✨ Features

• 🌈 Derived from Best Practices of Enterprise-Level AI Products: Built on the RICH interaction paradigm, delivering an exceptional AI interaction experience.
• 🧩 Flexible and Diverse Atomic Components: Covers most AI dialogue scenarios, empowering you to quickly build personalized AI interaction interfaces.
• ⚡ Out-of-the-Box Model Integration: Easily connect with inference services compatible with OpenAI standards.
• 🔄 Efficient Management of Conversation Data Flows: Provides powerful tools for managing data flows, enhancing development efficiency.
• 📦 Rich Template Support: Offers multiple templates for quickly starting LUI application development.
• 🛡 Complete TypeScript Support: Developed with TypeScript, ensuring robust type coverage to improve the development experience and reliability.
• 🎨 Advanced Theme Customization: Supports fine-grained style adjustments to meet diverse use cases and personalization needs.

📦 Installation

1npm install @ant-design/x --save

1yarn add @ant-design/x

1pnpm add @ant-design/x

🖥️ Import in Browser

Add script and link tags in your browser and use the global variable antd.

We provide antdx.js, antdx.min.js, and antdx.min.js.map in the dist directory of the npm package.

We do not recommend using the built files because they cannot be tree-shaken and will not receive bug fixes for underlying dependencies.

Note: antdx.js and antdx.min.js depend on react, react-dom, dayjs, antd, @ant-design/cssinjs, @ant-design/icons, please ensure these files are loaded before using them.

🧩 Atomic Components

Based on the RICH interaction paradigm, we provide numerous atomic components for various stages of interaction to help you flexibly build your AI dialogue applications:

• Components Overview
• Playground

Below is an example of using atomic components to create a simple chatbot interface:

1import React from 'react';
2import {
3  // Message bubble
4  Bubble,
5  // Input box
6  Sender,
7} from '@ant-design/x';
8
9const messages = [
10  {
11    content: 'Hello, Ant Design X!',
12    role: 'user',
13  },
14];
15
16const App = () => (
17  <>
18    <Bubble.List items={messages} />
19    <Sender />
20  </>
21);
22
23export default App;

⚡️ Integrating Model Inference Service

We help you integrate standard model inference services out of the box by providing runtime tools like useXAgent, XRequest, etc.

Here is an example of integrating Qwen:

Note: 🔥 dangerouslyApiKey has security risks, more details can be found in the documentation.

1import { useXAgent, Sender, XRequest } from '@ant-design/x';
2import React from 'react';
3
4const { create } = XRequest({
5  baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
6  dangerouslyApiKey: process.env['DASHSCOPE_API_KEY'],
7  model: 'qwen-plus',
8});
9
10const Component: React.FC = () => {
11  const [agent] = useXAgent({
12    request: async (info, callbacks) => {
13      const { messages, message } = info;
14      const { onUpdate } = callbacks;
15
16      // current message
17      console.log('message', message);
18      // messages list
19      console.log('messages', messages);
20
21      let content: string = '';
22
23      try {
24        create(
25          {
26            messages: [{ role: 'user', content: message }],
27            stream: true,
28          },
29          {
30            onSuccess: (chunks) => {
31              console.log('sse chunk list', chunks);
32            },
33            onError: (error) => {
34              console.log('error', error);
35            },
36            onUpdate: (chunk) => {
37              console.log('sse object', chunk);
38              const data = JSON.parse(chunk.data);
39              content += data?.choices[0].delta.content;
40              onUpdate(content);
41            },
42          },
43        );
44      } catch (error) {
45        // handle error
46      }
47    },
48  });
49
50  const onSubmit = (message: string) => {
51    agent.request(
52      { message },
53      {
54        onUpdate: () => {},
55        onSuccess: () => {},
56        onError: () => {},
57      },
58    );
59  };
60
61  return <Sender onSubmit={onSubmit} />;
62};

🔄 Efficient Data Flow Management

We help you efficiently manage the data flow of AI chat applications out of the box by providing the useXChat runtime tool:

Here is an example of integrating OpenAI:

1import { useXAgent, useXChat, Sender, Bubble } from '@ant-design/x';
2import OpenAI from 'openai';
3import React from 'react';
4
5const client = new OpenAI({
6  apiKey: process.env['OPENAI_API_KEY'],
7  dangerouslyAllowBrowser: true,
8});
9
10const Demo: React.FC = () => {
11  const [agent] = useXAgent({
12    request: async (info, callbacks) => {
13      const { messages, message } = info;
14
15      const { onSuccess, onUpdate, onError } = callbacks;
16
17      // current message
18      console.log('message', message);
19
20      // history messages
21      console.log('messages', messages);
22
23      let content: string = '';
24
25      try {
26        const stream = await client.chat.completions.create({
27          model: 'gpt-4o',
28          // if chat context is needed, modify the array
29          messages: [{ role: 'user', content: message }],
30          // stream mode
31          stream: true,
32        });
33
34        for await (const chunk of stream) {
35          content += chunk.choices[0]?.delta?.content || '';
36          onUpdate(content);
37        }
38
39        onSuccess(content);
40      } catch (error) {
41        // handle error
42        // onError();
43      }
44    },
45  });
46
47  const {
48    // use to send message
49    onRequest,
50    // use to render messages
51    messages,
52  } = useXChat({ agent });
53
54  const items = messages.map(({ message, id }) => ({
55    // key is required, used to identify the message
56    key: id,
57    content: message,
58  }));
59
60  return (
61    <>
62      <Bubble.List items={items} />
63      <Sender onSubmit={onRequest} />
64    </>
65  );
66};
67
68export default Demo;

Use modularized antd

@ant-design/x supports ES modules tree shaking by default.

TypeScript

@ant-design/x provides a built-in ts definition.

Non-React Implementations

Welcome to contribute!

Companies using antdx

Ant Design X is widely used in AI-driven user interfaces within Ant Group. If your company and products use Ant Design X, feel free to leave a comment here.

Contributing

Please read our CONTRIBUTING.md first.

If you'd like to help us improve antd, just create a Pull Request. Feel free to report bugs and issues here.

If you're new to posting issues, we ask that you read How To Ask Questions The Smart Way and How to Ask a Question in Open Source Community and How to Report Bugs Effectively prior to posting. Well written bug reports help us help you!

Need Help?

If you encounter any issues while using Ant Design X, you can seek help through the following channels. We also encourage experienced users to assist newcomers via these platforms.

When asking questions on GitHub Discussions, it's recommended to use the Q&A tag.

1. GitHub Discussions
2. GitHub Issues