ApsaraDB RDS:AI (rds_ai)

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Une instance ApsaraDB RDS for PostgreSQL répondant aux exigences de version suivantes. Pour effectuer une mise à niveau, consultez Mettre à niveau une version mineure du moteur.

  Version majeure	Version mineure minimale du moteur
  PostgreSQL 16	20241230
  PostgreSQL 14, 15, 17	20250430
  PostgreSQL 18	20251130

• Un compte privilégié pour votre instance. Pour en créer un, consultez Créer un compte.

• Un abonnement actif à Alibaba Cloud Model Studio avec une clé API. Pour en obtenir une, consultez Obtenir une clé API.

Configuration réseau

Par défaut, une instance RDS for PostgreSQL ne peut pas accéder aux réseaux externes. Pour activer l'accès aux modèles externes, vous devez configurer une passerelle NAT pour le VPC de l'instance. Pour plus d'informations sur les passerelles NAT, consultez Utiliser la fonctionnalité SNAT d'une passerelle NAT Internet pour accéder à Internet.

Installer l'extension

Option 1 : Installer depuis la console

1. Accédez à la page Instances RDS, sélectionnez une région et cliquez sur l'ID de l'instance cible.

2. Dans le volet de navigation de gauche, cliquez sur Plug-ins.

3. Sur la page Plugin Marketplace, cliquez sur Install à côté de rds_ai.

4. Sélectionnez la base de données et le compte cibles, puis cliquez sur Install.

Pour désinstaller, accédez à l'onglet Installed Plugins sur la page Manage Plugins.

Option 2 : Installer avec SQL

Exécutez la commande suivante en tant que compte privilégié :

CREATE EXTENSION IF NOT EXISTS rds_ai CASCADE;

L'installation de rds_ai installe également les extensions pgvector et pgsql-http.

Pour vérifier l'installation :

SELECT * FROM pg_extension;

Pour supprimer l'extension :

DROP EXTENSION rds_ai;

Modèles par défaut

rds_ai est fourni avec les modèles par défaut suivants :

Pour modifier le modèle d'invite par défaut, ajoutez rds_ai à la Running Value du paramètre shared_preload_libraries, puis définissez le modèle. Pour les instructions de mise à jour des paramètres, consultez Définir les paramètres de l'instance. Par exemple, définissez la Running Value sur 'pg_stat_statements,auto_explain,rds_ai', puis exécutez :

SET rds_ai.default_prompt_model TO 'qwen-max';

Configurer l'extension

Avant d'appeler un modèle, définissez la clé API et les URL des modèles.

Étape 1 : Définir la clé API

-- Set the API key for a specific model
SELECT rds_ai.update_model('qwen-plus', 'token', 'sk-****');

-- Set the same API key for all models
SELECT rds_ai.update_model(model_name, 'token', 'sk-****')
FROM rds_ai.model_list;

Étape 2 : Définir les URL des modèles

-- Prompt models (qwen-plus, qwen-max, qwen-turbo share the same endpoint)
SELECT rds_ai.update_model('qwen-plus', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation');
SELECT rds_ai.update_model('qwen-max', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation');
SELECT rds_ai.update_model('qwen-turbo', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation');

-- Embedding model
SELECT rds_ai.update_model('text-embedding-v3', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding');

Étape 3 : (Facultatif) Configurer les délais d'expiration des requêtes

rds_ai utilise l'extension pgsql-http pour effectuer des appels distants. Définissez des délais d'expiration pour interrompre les requêtes de longue durée.

Ces paramètres s'appliquent uniquement à la session en cours. Réinitialisez-les pour chaque nouvelle connexion.

-- Request timeout (milliseconds)
SET http.timeout_msec TO 200000;
SELECT http.http_set_curlopt('CURLOPT_TIMEOUT', '200000');

-- Connection timeout (milliseconds)
SELECT http.http_set_curlopt('CURLOPT_CONNECTTIMEOUT_MS', '200000');

Questions-réponses par LLM

Utilisez rds_ai.prompt pour envoyer une question à un modèle de génération de texte Qwen et obtenir une réponse. Le modèle par défaut est qwen-plus.

Appel simple :

SELECT rds_ai.prompt('Give me a recipe using carrots, potatoes, and eggplants.');

Appel complet avec paramètres explicites :

SELECT rds_ai.prompt(
  model_name => 'qwen-plus',                                 -- model name
  content    => 'Give me a recipe using carrots, potatoes, and eggplants.',  -- prompt text
  args       => '{"top_p": 0.7}'::jsonb                      -- model parameters
);

Conversion texte vers vecteur

Utilisez rds_ai.embed pour convertir du texte en vecteur à l'aide du modèle text-embedding-v3. La sortie est un vecteur dense de 1024 dimensions par défaut. Pour demander un vecteur creux, passez {"output_type": "sparse"} ; la sortie comportera alors 250 002 dimensions.

Vecteur dense (par défaut) :

SELECT rds_ai.embed(
  'A strong wind blows from a high sky, and monkeys cry sadly.'
);

Vecteur creux :

SELECT rds_ai.embed(
  content => 'A strong wind blows from a high sky, and monkeys cry sadly.',
  args    => '{"output_type": "sparse"}'::jsonb
);

Stocker les embeddings dans une table :

1. Créez la table :

   CREATE TABLE test_embed (
     a text,
     b vector(1024),         -- dense vector column
     c sparsevec(250002)     -- sparse vector column
   );

2. Insérez du texte :

   INSERT INTO test_embed (a) VALUES ('hello world');

3. Écrivez les embeddings :

   -- Write a dense vector
   UPDATE test_embed
   SET b = rds_ai.embed(a, '{"output_type": "dense"}'::jsonb)::vector;
   
   -- Write a sparse vector
   UPDATE test_embed
   SET c = rds_ai.embed(a, '{"output_type": "sparse"}'::jsonb)::sparsevec;

Récupération sémantique par vecteur

Utilisez rds_ai.retrieve pour trouver les N enregistrements les plus similaires à une requête. Cette fonction intègre la requête à l'aide de text-embedding-v3 et la compare aux vecteurs stockés en utilisant le type de distance que vous spécifiez.

Choisir un type de distance

Le type de distance par défaut pour rds_ai.retrieve est cosine.

Choisir un type d'index vectoriel

Sans index, PostgreSQL effectue un balayage séquentiel exact, précis mais lent pour les grands ensembles de données. Ajoutez un index vectoriel pour accélérer la recherche des plus proches voisins approximatifs (ANN).

Exemple : Configurer une table et exécuter la récupération

1. Créez une table et ajoutez une colonne d'embedding :

   CREATE TABLE test_rag (
     id    SERIAL PRIMARY KEY,
     chunk TEXT
   );
   
   ALTER TABLE test_rag ADD COLUMN embedding VECTOR(1024);
   UPDATE test_rag SET embedding = rds_ai.embed(chunk)::vector;

2. Créez un index vectoriel :

   Les deux types d'index nécessitent la classe d'opérateurs vector_cosine_ops.

   -- HNSW index (recommended for most workloads)
   CREATE INDEX ON test_rag USING hnsw (embedding vector_cosine_ops);
   
   -- IVFFlat index (for memory-constrained environments)
   CREATE INDEX ON test_rag USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

3. Exécutez une recherche de similarité :

   -- Simple call (uses defaults: text-embedding-v3, top 10, cosine distance)
   SELECT * FROM rds_ai.retrieve(
     'Why is PostgreSQL considered the most advanced open-source database?',
     'public', 'test_rag', 'chunk', 'embedding'
   );

   Appel complet avec paramètres explicites :

   SELECT * FROM rds_ai.retrieve(
     embed_model   => 'text-embedding-v3',
     question      => 'Why is PostgreSQL considered the most advanced open-source database?',
     source_schema => 'public',         -- schema of the source table
     source_table  => 'test_rag',       -- table to search
     chunk_col     => 'chunk',          -- text column
     vector_col    => 'embedding',      -- vector column
     topn          => 10,               -- number of results to return
     embed_args    => '{}'::jsonb,      -- extra parameters for the embedding model
     distance_type => 'cosine'          -- distance algorithm: L1, L2, cosine, or negative
   );

Questions-réponses RAG

rds_ai.rag combine la récupération vectorielle et la génération LLM en un seul appel. Il récupère les N fragments les plus pertinents de votre table et les transmet comme contexte au modèle d'invite.

Les modèles par défaut sont text-embedding-v3 pour l'embedding et qwen-plus pour la génération de texte.

Appel simple :

SELECT * FROM rds_ai.rag(
  'Why is PostgreSQL considered the most advanced open-source database?',
  'public', 'test_rag', 'chunk', 'embedding'
);

Appel complet avec paramètres explicites :

SELECT * FROM rds_ai.rag(
  embed_model   => 'text-embedding-v3',  -- embedding model
  prompt_model  => 'qwen-plus',          -- text generation model
  question      => 'Why is PostgreSQL considered the most advanced open-source database?',
  source_schema => 'public',             -- schema of the source table
  source_table  => 'test_rag',           -- table to search
  chunk_col     => 'chunk',              -- text column
  vector_col    => 'embedding',          -- vector column
  topn          => 10,                   -- number of chunks to retrieve
  embed_args    => '{}'::jsonb,          -- extra parameters for the embedding model
  prompt_args   => '{}'::jsonb,          -- extra parameters for the prompt model
  distance_type => 'L2'                  -- distance algorithm: L1, L2, cosine, or inner product
);

Modèles personnalisés

rds_ai stocke les configurations de modèle dans la table rds_ai.model_list. Ajoutez n'importe quel modèle compatible HTTP en insérant une ligne dans cette table.

SELECT rds_ai.add_model(
  'test-model',                                          -- model name
  'POST',                                                -- HTTP method
  ARRAY[('Authorization', 'Bearer %s')]::http.http_header[],  -- request header
  'https://****.com',                                    -- model URL
  'application/json',                                    -- content type
  '{"key":"%s"}',                                        -- request body template
  'SELECT %L'                                            -- JSON response parser
);

-- Returns the full HTTP response
SELECT * FROM rds_ai.raw_invoke_model('qwen-plus', ARRAY['who are you']);

-- Returns the parsed result from json_path
SELECT * FROM rds_ai.invoke_model('qwen-plus', ARRAY['who are you']);

SELECT rds_ai.del_model('test-model');

Référence API

rds_ai.prompt(
  model_name TEXT,
  content    TEXT,
  args       jsonb DEFAULT '{}'
) RETURNS text

rds_ai.embed(
  model_name TEXT,
  content    TEXT,
  args       jsonb DEFAULT '{}'
) RETURNS text

rds_ai.retrieve(
  model_name    TEXT,
  question      TEXT,
  source_schema TEXT,
  source_table  TEXT,
  chunk_col     TEXT,
  vector_col    TEXT,
  topn          INT DEFAULT 10,
  embed_args    jsonb DEFAULT '{}',
  distance_type TEXT DEFAULT 'cosine'
) RETURNS TABLE(chunk TEXT, distance float)

rds_ai.rag(
  embed_model   TEXT,
  prompt_model  TEXT,
  question      TEXT,
  source_schema TEXT,
  source_table  TEXT,
  chunk_col     TEXT,
  vector_col    TEXT,
  topn          INT DEFAULT 10,
  embed_args    jsonb DEFAULT '{}',
  prompt_args   jsonb DEFAULT '{}',
  distance_type TEXT DEFAULT 'L2'
) RETURNS text

rds_ai.show_models() RETURNS setof rds_ai.model_list

rds_ai.add_model(
  model_name       TEXT,
  request_type     TEXT,
  request_header   http.http_header[],
  uri              TEXT,
  content_type     TEXT,
  content_template TEXT,
  json_path        TEXT
) RETURNS TEXT

rds_ai.update_model(
  model_name  TEXT,
  config_name TEXT,
  value       TEXT
) RETURNS void

rds_ai.del_model(model_name text) RETURNS void

rds-ai.invoke_model(
  model_name  TEXT,
  params_list TEXT[]
) RETURNS http.http_response

rds-ai.raw_invoke_model(
  model_name  TEXT,
  params_list TEXT[]
) RETURNS http.http_response

Étapes suivantes

• Guide d'utilisation de pgvector — en savoir plus sur le stockage et la recherche vectoriels dans PostgreSQL

• Déployer un chatbot RAG basé sur un LLM à l'aide de PAI-EAS et d'ApsaraDB RDS for PostgreSQL — guide de déploiement complet d'un chatbot RAG