Knowledge graph - ontology capabilities

1. Create a Knowledge Graph instance

1. Log in to the RDS AI Application development console and go to the instance purchase page.

2. On the purchase page, configure the following parameters, ensuring you select Knowledge Graph for the RDS AI Application Module.

   Parameter	Description
   RDS AI Application Project Name	A custom name to identify the instance in the console.
   Region	Select the region where your business operates. This setting cannot be changed after the instance is created. For lower network latency, deploy the instance in the same region as your applications.
   VPC, Primary Zone, and Network	Select an existing VPC and vSwitch. If none exist, click Create to create them in the VPC console.
   RDS AI Application Module	Knowledge Graph is a required selection. You can also select Supabase and Long-term Memory depending on your business needs.
   Dashboard Username	This value is fixed to supabase and cannot be changed.
   Dashboard Password	The password must be 8 to 32 characters long and contain at least three of the following: uppercase letters, lowercase letters, digits, and underscores (_). This password is used to sign in to the Knowledge Graph workbench.
   Billing Method	The available billing methods are subscription and pay-as-you-go. The subscription option is recommended for long-term use.
   Engine	Available engines are PostgreSQL 17 and PostgreSQL 18. We recommend PostgreSQL 17 unless you have specific requirements.
   SLR Authorization	Ensure the AliyunServiceRoleForRds and AliyunServiceRoleForRdsPgsqlOnEcs service-linked roles have a green check mark. If not, follow the on-screen instructions to authorize them.
   Edition	Select the Basic Edition for testing and feature validation. For production environments, we recommend the High-availability Edition.
   Instance Type Category, Instance Type	Select an instance type that meets your data volume and concurrency requirements. For this demo, we recommend selecting at least pg.n2.2c.1m (2 vCPUs, 4 GB).
   Storage Space	The default is 20 GB. You can adjust this value to match the scale of your business data.
   Database Password	The password must be 8 to 32 characters long and meet the same requirements as the Dashboard Password. This password is for connecting directly to the PostgreSQL database to perform data operations.

3. Review your order, complete the payment, and wait for the instance to be created. This process typically takes several minutes.

2. Configure the IP address whitelist

1. In the instance list of the RDS AI Application development console, click the target project name to go to the instance details page.

2. Add your local client's public IP address to the IP address whitelist and save the changes.

3. Sign in to Knowledge Graph

1. In the RDS AI Application development console, click the target project name to go to the instance details page.

2. In the Network Information section, copy the public endpoint (for example, 59.xxxx.182:80).

3. In a browser, open the public endpoint and sign in with the Dashboard Username supabase and the Dashboard Password you set during instance creation. After signing in, you are directed to the Knowledge Graph workbench, where you will perform all subsequent operations, such as building datasets, modeling ontologies, and generating skills.

1. Connect directly to the RDS PostgreSQL instance

1. Log in to the RDS console.

2. In the instance list, find the PostgreSQL instance associated with your RDS AI instance, and click the instance ID to open the Details page.

3. On the Database Connection page, copy the public endpoint (for example, pgm-xxxxxxxx.rds.aliyuncs.com), and record the corresponding port, database name, username, and password.

2. Create the business table schema

Use any PostgreSQL client, such as psql, DataGrip, or Navicat, to connect to the RDS PostgreSQL instance. In the target database, such as supabase_db, run the following DDL to create the tables, foreign keys, indexes, and constraints for a food delivery ordering system.

-- ============================================================
-- DDL for database: supabase_db  schema: public
-- Generated via information_schema + pg_catalog queries
-- ============================================================

SET search_path TO public;

-- ─── Extensions ───
CREATE EXTENSION IF NOT EXISTS "age";
CREATE EXTENSION IF NOT EXISTS "pg_cron";
CREATE EXTENSION IF NOT EXISTS "pg_graphql";
CREATE EXTENSION IF NOT EXISTS "pg_net";
CREATE EXTENSION IF NOT EXISTS "pg_stat_statements";
CREATE EXTENSION IF NOT EXISTS "pg_trgm";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";
CREATE EXTENSION IF NOT EXISTS "pgjwt";
CREATE EXTENSION IF NOT EXISTS "supabase_vault";
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "vector";

-- ─── Enum Types ───
CREATE TYPE memory_type AS ENUM ('explicit', 'implicit', 'feedback');
CREATE TYPE order_status AS ENUM ('pending', 'confirmed', 'preparing', 'delivering', 'completed', 'cancelled');

-- ─── Table: addresses ───
CREATE TABLE addresses (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    user_id uuid NOT NULL,
    label text,
    address text NOT NULL,
    lat numeric(10,8),
    lng numeric(11,8),
    contact_name text,
    contact_phone text,
    is_default boolean DEFAULT false NOT NULL,
    created_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: menus ───
CREATE TABLE menus (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    shop_id uuid NOT NULL,
    name text NOT NULL,
    description text,
    price numeric(10,2) NOT NULL,
    category text,
    tags jsonb DEFAULT '[]'::jsonb,
    is_available boolean DEFAULT true NOT NULL,
    image_url text,
    created_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: order_feedbacks ───
CREATE TABLE order_feedbacks (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    order_id uuid NOT NULL,
    user_id uuid NOT NULL,
    rating integer NOT NULL,
    comment text,
    liked_items jsonb DEFAULT '[]'::jsonb,
    disliked_items jsonb DEFAULT '[]'::jsonb,
    created_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: order_items ───
CREATE TABLE order_items (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    order_id uuid NOT NULL,
    menu_id uuid NOT NULL,
    quantity integer DEFAULT 1 NOT NULL,
    unit_price numeric(10,2) NOT NULL,
    note text,
    created_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: orders ───
CREATE TABLE orders (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    user_id uuid NOT NULL,
    shop_id uuid NOT NULL,
    status order_status DEFAULT 'pending'::order_status NOT NULL,
    total_price numeric(10,2) NOT NULL,
    delivery_address jsonb NOT NULL,
    note text,
    created_at timestamptz DEFAULT now() NOT NULL,
    updated_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: shops ───
CREATE TABLE shops (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    name text NOT NULL,
    description text,
    location text,
    category text,
    is_open boolean DEFAULT true NOT NULL,
    rating numeric(2,1) DEFAULT 5.0,
    phone text,
    business_hours jsonb DEFAULT '{}'::jsonb,
    created_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: user_memories ───
CREATE TABLE user_memories (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    user_id uuid NOT NULL,
    agent_id text DEFAULT 'default'::text NOT NULL,
    memory_type memory_type NOT NULL,
    memory_key text NOT NULL,
    memory_value jsonb NOT NULL,
    confidence numeric(3,2) DEFAULT 0.50 NOT NULL,
    source text,
    created_at timestamptz DEFAULT now() NOT NULL,
    updated_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: user_taste_profiles ───
CREATE TABLE user_taste_profiles (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    user_id uuid NOT NULL,
    flavor_tags jsonb DEFAULT '[]'::jsonb,
    allergy_tags jsonb DEFAULT '[]'::jsonb,
    diet_type text DEFAULT 'normal'::text NOT NULL,
    spice_level integer DEFAULT 2 NOT NULL,
    sweetness_level integer DEFAULT 2 NOT NULL,
    updated_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Table: users ───
CREATE TABLE users (
    id uuid DEFAULT uuid_generate_v4() NOT NULL,
    phone text NOT NULL,
    name text,
    email text,
    default_address_id uuid,
    telegram_id text,
    whatsapp_id text,
    created_at timestamptz DEFAULT now() NOT NULL,
    updated_at timestamptz DEFAULT now() NOT NULL
);

-- ─── Primary Keys ───
ALTER TABLE _ontology_changelog ADD PRIMARY KEY (id);
ALTER TABLE addresses ADD PRIMARY KEY (id);
ALTER TABLE menus ADD PRIMARY KEY (id);
ALTER TABLE order_feedbacks ADD PRIMARY KEY (id);
ALTER TABLE order_items ADD PRIMARY KEY (id);
ALTER TABLE orders ADD PRIMARY KEY (id);
ALTER TABLE shops ADD PRIMARY KEY (id);
ALTER TABLE user_memories ADD PRIMARY KEY (id);
ALTER TABLE user_taste_profiles ADD PRIMARY KEY (id);
ALTER TABLE users ADD PRIMARY KEY (id);

-- ─── Unique Constraints ───
ALTER TABLE user_memories ADD CONSTRAINT user_memories_user_id_agent_id_memory_key_key UNIQUE (user_id, agent_id, memory_key);
ALTER TABLE user_taste_profiles ADD CONSTRAINT user_taste_profiles_user_id_key UNIQUE (user_id);
ALTER TABLE users ADD CONSTRAINT users_phone_key UNIQUE (phone);
ALTER TABLE users ADD CONSTRAINT users_telegram_id_key UNIQUE (telegram_id);
ALTER TABLE users ADD CONSTRAINT users_whatsapp_id_key UNIQUE (whatsapp_id);

-- ─── Foreign Keys ───
ALTER TABLE addresses ADD CONSTRAINT addresses_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
ALTER TABLE menus ADD CONSTRAINT menus_shop_id_fkey FOREIGN KEY (shop_id) REFERENCES shops(id) ON DELETE CASCADE;
ALTER TABLE order_feedbacks ADD CONSTRAINT order_feedbacks_order_id_fkey FOREIGN KEY (order_id) REFERENCES orders(id) ON DELETE CASCADE;
ALTER TABLE order_feedbacks ADD CONSTRAINT order_feedbacks_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id);
ALTER TABLE order_items ADD CONSTRAINT order_items_menu_id_fkey FOREIGN KEY (menu_id) REFERENCES menus(id);
ALTER TABLE order_items ADD CONSTRAINT order_items_order_id_fkey FOREIGN KEY (order_id) REFERENCES orders(id) ON DELETE CASCADE;
ALTER TABLE orders ADD CONSTRAINT orders_shop_id_fkey FOREIGN KEY (shop_id) REFERENCES shops(id);
ALTER TABLE orders ADD CONSTRAINT orders_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id);
ALTER TABLE user_memories ADD CONSTRAINT user_memories_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
ALTER TABLE user_taste_profiles ADD CONSTRAINT user_taste_profiles_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
ALTER TABLE users ADD CONSTRAINT fk_users_default_address FOREIGN KEY (default_address_id) REFERENCES addresses(id) ON DELETE SET NULL;

-- ─── Indexes ───
CREATE INDEX idx_addresses_default ON public.addresses USING btree (user_id, is_default) WHERE (is_default = true);
CREATE INDEX idx_addresses_user_id ON public.addresses USING btree (user_id);
CREATE INDEX idx_menus_available ON public.menus USING btree (shop_id, is_available) WHERE (is_available = true);
CREATE INDEX idx_menus_category ON public.menus USING btree (category);
CREATE INDEX idx_menus_name_trgm ON public.menus USING gin (name gin_trgm_ops);
CREATE INDEX idx_menus_shop_id ON public.menus USING btree (shop_id);
CREATE INDEX idx_menus_tags ON public.menus USING gin (tags);
CREATE INDEX idx_feedbacks_order_id ON public.order_feedbacks USING btree (order_id);
CREATE INDEX idx_feedbacks_rating ON public.order_feedbacks USING btree (user_id, rating);
CREATE INDEX idx_feedbacks_user_id ON public.order_feedbacks USING btree (user_id);
CREATE INDEX idx_order_items_menu_id ON public.order_items USING btree (menu_id);
CREATE INDEX idx_order_items_order_id ON public.order_items USING btree (order_id);
CREATE INDEX idx_orders_shop_id ON public.orders USING btree (shop_id);
CREATE INDEX idx_orders_status ON public.orders USING btree (status);
CREATE INDEX idx_orders_user_created ON public.orders USING btree (user_id, created_at DESC);
CREATE INDEX idx_orders_user_id ON public.orders USING btree (user_id);
CREATE INDEX idx_shops_category ON public.shops USING btree (category);
CREATE INDEX idx_shops_is_open ON public.shops USING btree (is_open) WHERE (is_open = true);
CREATE INDEX idx_shops_name_trgm ON public.shops USING gin (name gin_trgm_ops);
CREATE INDEX idx_memories_confidence ON public.user_memories USING btree (user_id, confidence DESC);
CREATE INDEX idx_memories_type ON public.user_memories USING btree (memory_type);
CREATE INDEX idx_memories_updated ON public.user_memories USING btree (updated_at DESC);
CREATE INDEX idx_memories_user_agent ON public.user_memories USING btree (user_id, agent_id);
CREATE INDEX idx_memories_user_id ON public.user_memories USING btree (user_id);
CREATE INDEX idx_taste_user_id ON public.user_taste_profiles USING btree (user_id);
CREATE INDEX idx_users_phone ON public.users USING btree (phone);
CREATE INDEX idx_users_telegram_id ON public.users USING btree (telegram_id) WHERE (telegram_id IS NOT NULL);
CREATE INDEX idx_users_whatsapp_id ON public.users USING btree (whatsapp_id) WHERE (whatsapp_id IS NOT NULL);

-- ─── Check Constraints ───
ALTER TABLE menus ADD CONSTRAINT menus_price_check CHECK ((price >= (0)::numeric));
ALTER TABLE order_feedbacks ADD CONSTRAINT order_feedbacks_rating_check CHECK (((rating >= 1) AND (rating <= 5)));
ALTER TABLE order_items ADD CONSTRAINT order_items_quantity_check CHECK ((quantity > 0));
ALTER TABLE order_items ADD CONSTRAINT order_items_unit_price_check CHECK ((unit_price >= (0)::numeric));
ALTER TABLE orders ADD CONSTRAINT orders_total_price_check CHECK ((total_price >= (0)::numeric));
ALTER TABLE shops ADD CONSTRAINT shops_rating_check CHECK (((rating >= (0)::numeric) AND (rating <= (5)::numeric)));
ALTER TABLE user_memories ADD CONSTRAINT user_memories_confidence_check CHECK (((confidence >= (0)::numeric) AND (confidence <= (1)::numeric)));
ALTER TABLE user_taste_profiles ADD CONSTRAINT user_taste_profiles_spice_level_check CHECK (((spice_level >= 0) AND (spice_level <= 5)));
ALTER TABLE user_taste_profiles ADD CONSTRAINT user_taste_profiles_sweetness_level_check CHECK (((sweetness_level >= 0) AND (sweetness_level <= 5)));

3. Generate associated test data

Use QoderWork to batch-generate associated test data with a natural language prompt. Open QoderWork and enter a prompt similar to the following:

I need a data insertion script for my PostgreSQL database. The connection details are as follows: Endpoint: pgm-XXX.rds.aliyuncs.com, Database: supabase_db, Username: XXX, Password: XXX.
Please check my current table schema and generate 100,000 interrelated records. Ensure that all data for users, orders, shops, and menus is correctly linked.

1. Start agent automatic modeling

1. Sign in to the knowledge graph workbench with the Dashboard username supabase and your password (see section 3 of Step 1).

2. In the left navigation pane, under the ONTOLOGY group, click Type Modeling.

3. In the Type Definition section, click Agent Automatic Modeling to start the automatic ontology modeling workflow.

2. Create an ontology dataset

On the Automatic Ontology Modeling page, a three-stage workflow appears at the top: Connection Configuration → Preview & Refine → Finish. First, create a dataset for the ontology definition.

1. In the dataset drop-down list in the upper-right corner of the page, click Create Dataset.

2. Complete the dataset information as described in the following table.

   Parameter	Description
   Name	Required. A name for the dataset. We recommend using a name that reflects the business scenario, such as food_delivery_ontology.
   Description	Optional. A brief description of the dataset to aid future maintenance.
   RAG type	The drop-down list supports three types: GraphRAG, Ontology, and Skills. For this scenario, select Ontology.
   Storage type	Set to Local Storage and cannot be changed. Ontology and Skills datasets only support local storage.

3. Click Create Dataset. Once created, the dataset is automatically selected and activated, and its status is displayed as active.

3. Configure connection and trigger modeling

1. In the Connection Configuration stage, select public for the schema and enter the business logic: "This is a food delivery ordering system." This description guides the Large Language Model (LLM) in abstracting entity semantics. The more precise the description, the more closely the generated ontology will align with your business.

2. After you confirm the configuration, click Start Analysis to enter the Preview & Refine stage. The LLM then scans table structures and foreign key relationships to infer ObjectType, LinkType, and ActionType.

4. Preview and refine ontology

1. When modeling is complete, the inferred results appear on four tabs: ObjectType, LinkType, ActionType, and Mapping. Each ObjectType card shows the primary key (PK), the number of properties, and the creation time.

2. In the Recommendation Center section, review the refinement suggestions. You can accept or ignore each suggestion based on your business requirements. You can also manually edit entity names, properties, and relationship types to better align the ontology with your business semantics.

3. Once you confirm the ontology structure is correct, click Register to Dataset and then Confirm Registration to enter the Finish stage.

5. Register and view knowledge graph

1. In the Finish stage, the system automatically extracts data from your RDS PostgreSQL business database based on the ontology definition. It then builds entity nodes and relationship edges and writes them to the knowledge graph. The duration of the initial synchronization depends on the data volume.

2. After the registration is complete, go to the ONTOLOGY group in the left navigation pane and click Ontology Graph to view a visualization of your knowledge graph. You can click any node to view its specific instance data and verify the ontology extraction.

3. In Instance Management, you can view the total number of instances for each ObjectType to verify that the data synchronization is complete.

1. Click "Generate Skill" to open the dialog box

On the Finish page of the Automatic Ontology Modeling workflow, click Generate Skill in the action bar at the bottom. The Generate Agent Skill from Modeling dialog box opens. The subtitle of the dialog box displays the name of the current dataset, for example, Automatically generate a complete Agent Skill package based on the ontology model of the current dataset (food_delivery_ontology).

2. Configure the Agent Skill

Configure the parameters in the dialog box as described in the table below.

3. Start LLM inference

1. After you configure the parameters, click Agent Generate in the lower-right corner of the dialog box. A loading message Agent is generating SKILL.md (LLM inference in progress)... appears, along with the prompt The LLM is understanding the domain semantics and generating the Skill document. Please wait....

2. Wait for the LLM inference to complete. This typically takes several minutes and depends on the size of the ontology and the number of ObjectTypes. The system then automatically generates the SKILL.md file and its associated Skill package files.

3. If you did not select Auto-publish to Skills, you can review the content of the SKILL.md file on the preview page after generation. Once you confirm that the content is correct, you can manually install the Skill to the Skills dataset.

4. Install the Skill

After the Skill is generated, install it on your local AI programming client so that an AI agent can load and call it.

1. In the SKILLHUB area of the left-side navigation pane, click Skills. On the newly created Skill card, such as food-delivery-agent, click Install.

2. In the Install Skill dialog box, select the tab corresponding to your local client: Claude, Cursor, Gemini, General, or Qoder. The dialog box displays the Target Directory for the selected client (for example, the default for Qoder is ~/.qoder/skills/<skill-name>) and a complete installation command.

3. Click Copy in the upper-right corner of the command area, and then paste and run the command in your local terminal. The command uses curl to download a ZIP package from the SKILLHUB artifact repository and extracts it to the target directory. If the terminal reports no errors, the installation is successful. Return to the dialog box and click Close.

4. Reload or restart the Skill list in your local Qoder client. The newly installed Skill appears, and you can proceed to Step 5 to verify that it works correctly.

1. Select a skill and ask a question

1. Open the QoderWork client and select an installed Skill, such as food-delivery-agent, from the Skill list.

2. In the chat window, ask a question in natural language. For example:

   Can you look up my store: Li XX's Chinese Restaurant?

3. Based on the ontology, the Skill queries the underlying RDS PostgreSQL data through the knowledge graph and returns a structured analysis report.

2. Demo: Analysis report

The following is a sample of the complete analysis report the Skill returned after executing the preceding query on the sample database.