ApsaraDB RDS:AI (rds_ai)

, e text rerank

text rerank,

Pré-requisitos

• Verifique se sua instância do RDS for PostgreSQL atende aos requisitos de versão na tabela a seguir:

  Versão principal	Versão secundária
  PostgreSQL 16	20241230 ou posterior
  PostgreSQL 14, PostgreSQL 15 e PostgreSQL 17	20250430 ou posterior
  PostgreSQL 18	20251130 ou posterior

  Para atualizar a versão secundária do mecanismo, consulte Atualize a versão secundária do mecanismo.

• Sua instância do RDS for PostgreSQL deve ter uma conta privilegiada. Para mais informações, consulte Crie uma conta.

• O Alibaba Cloud Model Studio fornece o modelo utilizado neste documento. Ative o service e obtenha uma chave de API antes de prosseguir. Para mais informações, consulte Obtenha uma chave de API.

Configuração de rede

Por padrão, uma instância do RDS for PostgreSQL não acessa redes externas. Para permitir que a instância acesse modelos externos, configure um NAT gateway para sua VPC. Para mais informações sobre NAT gateways, consulte Use o recurso SNAT de um NAT gateway da Internet para acessar a Internet.

Criar e remover extensões

• Instale uma extensão na página Plug-ins.

  1. Acesse a página Instances, selecione uma região no topo e clique em ID da instância desejada.

  2. No painel de navegação à esquerda, clique em Plug-ins.

  3. Na aba Extension Marketplace, localize a extensão rds_ai e clique em Install.

  4. Na caixa de diálogo, selecione o banco de dados e a conta de destino e clique em Install.

  (Opcional) Na página Extension Management, desinstale extensões pela aba Installed Extensions.

• Gerencie extensões com comandos SQL

  Crie uma extensão

  CREATE EXTENSION IF NOT EXISTS rds_ai CASCADE;

  Nota

  • Somente uma conta privilegiada pode executar este comando. Para criar uma conta privilegiada, consulte Crie uma conta.

  • A criação da extensão rds_ai também instala as extensões pgvector e pgsql-http.

  • Para visualizar todas as extensões instaladas, execute o comando SELECT * FROM pg_extension;.

  Remover uma extensão

  DROP EXTENSION rds_ai;

Modelos padrão

A extensão rds_ai suporta os modelos padrão listados abaixo. Você também pode crie modelos personalizados.

Os modelos padrão na extensão rds_ai oferecem as seguintes capacidades:

• Perguntas e respostas baseadas em LLM

• Conversão de texto em vetor

• Recuperação dos N vetores mais similares

• Perguntas e respostas baseadas em RAG

Configurações básicas

1. Para chamar um modelo de linguagem grande usando o rds_ai, configure primeiro a chave de API.

   -- Set the API key for the target model.
   SELECT rds_ai.update_model('qwen-plus', 'token', 'sk-****'); 
   
   -- Set the API key for all models in rds_ai.model_list.
   SELECT rds_ai.update_model(model_name,'token','sk-****') FROM rds_ai.model_list;

2. Execute os comandos a seguir para configurar a URL de cada modelo padrão.

   --qwen-plus model
   SELECT rds_ai.update_model('qwen-plus', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation'); 
   
   --qwen-max model
   SELECT rds_ai.update_model('qwen-max', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation'); 
   
   --qwen-turbo model
   SELECT rds_ai.update_model('qwen-turbo', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation'); 
   
   --text-embedding-v3 model
   SELECT rds_ai.update_model('text-embedding-v3', 'uri', 'https://dashscope-intl.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding'); 

3. A extensão rds_ai utiliza a extensão pgsql-http para chamar modelos remotamente. Configure os seguintes ajustes de timeout para interromper requisições longas.

   Nota

   Essas configurações de timeout são válidas apenas para a sessão atual e devem ser reconfiguradas a cada nova conexão.

   -- Set the request timeout period in milliseconds.
   SET http.timeout_msec TO 200000;
   
   SELECT http.http_set_curlopt('CURLOPT_TIMEOUT', '200000');
   
   -- Set the connection timeout period.
   SELECT http.http_set_curlopt('CURLOPT_CONNECTTIMEOUT_MS', '200000');

Perguntas e respostas baseadas em LLM

Por padrão, a extensão rds_ai usa o modelo Qwen text generation para perguntas e respostas baseadas em LLM.

1. (Opcional) Defina o modelo padrão para perguntas e respostas baseadas em LLM. Caso não defina esse parâmetro, o sistema utilizará o modelo qwen-plus por padrão.

   Nota

   Para alterar um modelo padrão, adicione rds_ai ao Running Value do parâmetro de instância shared_preload_libraries. Para mais informações sobre como configurar parâmetros, consulte Defina parâmetros de instância. Por exemplo, altere o Running Value para 'pg_stat_statements,auto_explain,rds_ai'.

   SET rds_ai.default_prompt_model TO 'qwen-max';

2. Utilize rds_ai.prompt para chamar o modelo de linguagem grande padrão para perguntas e respostas. Exemplo:

   SELECT rds_ai.prompt('Give me a recipe for a dish made with carrots, potatoes, and eggplants.');

   Chamada completa da API:

   SELECT rds_ai.prompt(
     model_name=>'qwen-plus', -- The model name.
     content=>'Give me a recipe for a dish made with carrots, potatoes, and eggplants.',  -- The question.
     args=>'{"top_p": 0.7}'::jsonb -- The parameters for calling the large language model.
   );

Conversão de texto em vetor

Por padrão, a extensão rds_ai utiliza o modelo text-embedding-v3 para conversão de texto em vetor.

• A saída padrão é um vetor denso.

  SELECT rds_ai.embed(
      'On the wind-swept plain, gibbons cry; the islet is clear, the sand is white, birds wheel back. Leaves fall without end; the Yangtze rolls on, never ceasing.' -- The text to convert to a vector.
  );

• Especifique a saída como um vetor esparso.

  -- Convert text to a sparse vector, which has 250002 dimensions by default.
  SELECT rds_ai.embed(
      content=>'On the wind-swept plain, gibbons cry; the islet is clear, the sand is white, birds wheel back. Leaves fall without end; the Yangtze rolls on, never ceasing.',
      args=>'{"output_type": "sparse"}'::jsonb -- The parameter list.
  );

Armazene os vetores resultantes em uma tabela de destino.

1. Crie a tabela test_embed.

   CREATE TABLE test_embed(a text, b vector(1024), c sparsevec(250002));

2. Insira o texto que deseja converter.

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

3. Use rds_ai.embed para chamar o modelo text-embedding-v3 e gravar os resultados na tabela test_embed.

   • Grave um vetor denso.

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

   • Grave um vetor esparso.

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

Recuperação dos N vetores mais similares

Por padrão, a extensão rds_ai utiliza o modelo text-embedding-v3 para recuperação de vetores similares. Exemplo:

1. Crie uma tabela de teste.

   -- Create a test table named test_rag.
   CREATE TABLE test_rag (
       id SERIAL PRIMARY KEY,
       chunk TEXT
   );
   
   -- Add an embedding column to store the vector converted from the chunk.
   ALTER TABLE test_rag ADD COLUMN embedding VECTOR(1024);
   
   -- Populate the embedding column.
   UPDATE test_rag SET embedding=rds_ai.embed(chunk)::vector;

2. Crie um índice de vetor.

   Nota

   Ao criar um índice de vetor, utilize a classe de operador vector_cosine_ops.

   -- Create an HNSW index.
   CREATE INDEX ON test_rag USING hnsw (embedding vector_cosine_ops);
   -- Create an IVFFlat index.
   CREATE INDEX ON test_rag USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

3. Use rds_ai.retrieve, que chama o modelo text-embedding-v3, para realizar a recuperação de vetores na tabela de teste.

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

   Chamada completa da API:

   SELECT * FROM rds_ai.retrieve
   (
     embed_model=>'text-embedding-v3', -- The embedding model to use.
     question=>'Why is PostgreSQL considered the most advanced open source database',
     source_schema=>'public', -- The schema of the table for the similarity search.
     source_table=>'test_rag', -- The table for the similarity search.
     chunk_col=>'chunk', -- The column that contains text chunks.
     vector_col=>'embedding', -- The column that contains vectors.
     -- The following are optional parameters.
     topn=>10, -- The number of top results to return.
     embed_args=>'{}'::jsonb, -- The parameters for the embedding model.
     distance_type=>'cosine' -- The distance algorithm. Valid values: L1, L2, cosine, and inner product.
   );

Perguntas e respostas baseadas em RAG

Por padrão, a extensão rds_ai utiliza o modelo text-embedding-v3 e o modelo Qwen text generation para perguntas e respostas baseadas em RAG.

-- Embedding model: text-embedding-v3. Text generation model: specified by the rds_ai.default_prompt_model parameter.
SELECT * FROM rds_ai.rag
('Why is PostgreSQL considered the most advanced open source database', 
'public', 'test_rag', 'chunk', 'embedding');

Chamada completa da API:

SELECT * FROM rds_ai.rag
(
  embed_model=>'text-embedding-v3', -- The embedding model to use.
  prompt_model=>'qwen-plus', -- The prompt model to use.
  question=>'Why is PostgreSQL considered the most advanced open source database',
  source_schema=>'public', -- The schema of the table for the similarity search.
  source_table=>'test_rag', -- The table for the similarity search.
  chunk_col=>'chunk', -- The column that contains text chunks.
  vector_col=>'embedding', -- The column that contains vectors.
  -- The following are optional parameters.
  topn=>10,
  embed_args=>'{}'::jsonb,  -- The parameters for the embedding model.
  prompt_args=>'{}'::jsonb, -- The parameters for the prompt model.
  distance_type=>'L2' -- The distance algorithm. Valid values: L1, L2, cosine, and inner product.
);

Modelos personalizados

Adicione um modelo personalizado usando a tabela de metadados rds_ai.model_list. A tabela a seguir descreve os campos em rds_ai.model_list.

Adicionar um modelo personalizado

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

Usar um modelo personalizado

• Utilize a função rds_ai.raw_invoke_model para enviar uma requisição baseada na configuração do modelo. A função preenche o modelo de requisição com um ARRAY e retorna a resposta HTTP completa.

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

• Utilize a função rds_ai.invoke_model para enviar uma requisição baseada na configuração do modelo e extrair campos específicos da resposta usando a configuração json_path.

  SELECT * FROM
  rds_ai.invoke_model('qwen-plus', ARRAY['who are you']);

Exclua um modelo personalizado

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

Adicionar um modelo PAI-RAG

Recomendamos implantar o PAI-EAS e sua instância do RDS for PostgreSQL na mesma VPC. Ao configurar o modelo na extensão rds_ai, use o endpoint VPC do service PAI. Isso mantém toda a comunicação dentro da sua VPC, aumentando a segurança.

1. Implante um service RAG no PAI-EAS. Para mais informações, consulte Implante um chatbot RAG baseado em LLM usando PAI-EAS e RDS for PostgreSQL.

2. Obtenha as informações de invocação do service RAG.

   1. Clique em nome do service RAG para abrir a página Service Details.

   2. Na seção Basic Information, clique em View Invocation Information.

   3. Na caixa de diálogo Invocation Information, obtenha o endpoint e o token do service.

3. Adicione o modelo PAI-RAG.

   SELECT rds_ai.add_model(
       'pai-rag',      -- Model name
       'POST',         -- Request method
       ARRAY[('Authorization','%s')]::http.http_header[],  -- Request header,
       'http://rds-pai-rag-demo.****.cn-hangzhou.pai-eas.aliyuncs.com/service/query',  -- Request URL
       'application/json',  -- Content type
       '{
           "question": "%s"
       }',  -- Request body
       'SELECT (%L::jsonb->''answer'')::text'  -- Parse path
   );

   Nota

   • Substitua a URL do modelo pelo endpoint real do seu service e anexe /service/query.

   • Para mais informações sobre como invocar modelos PAI-RAG, consulte Chame modelos PAI usando uma API.

4. Configure o token para o modelo PAI-RAG.

   SELECT rds_ai.update_model('pai-rag', 'token','MTFkYjMwZjgzYzA1YmE2N2YyNWMxM2NkNDVjMjEzNjYxMDAzMzE5****');

Verifique o novo modelo PAI-RAG. Exemplo:

SELECT rds_ai.invoke_model('pai-rag', ARRAY['Which parameters are related to WAL log accumulation?']);

Adicionar um modelo Function Compute RAG

1. Implante uma aplicação AgentCraft no Function Compute. Para mais informações, consulte Implante o AgentCraft na nuvem.

2. Crie um agente e configure seu client access.

   Por exemplo, conforme descrito em Conecte um agente a um chatbot do DingTalk, obtenha e salve o endpoint e o token do service ao configurar o client access.

3. Adicione o modelo Function Compute RAG.

   SELECT rds_ai.add_model(
       'fc-rag',      -- Model name
       'POST',         -- Request method
       ARRAY[('Authorization','Bearer %s')]::http.http_header[],  -- Request header,
       'https://agentcrckend-de-obnhjsknam.cn-hangzhou.fcapp.run/v1/chat/completions',  -- Request URL
       'application/json',  -- Content type
       '{ 
           "messages":[ { "role": "user", "content": "%s" } ], 
           "stream": false, 
           "max_tokens": 1024 
        }', 
       'SELECT (%L::jsonb->''choices''->0->''message''->>''content'')::text'  -- Parse path
   );

   Nota

   Substitua a URL do modelo pela URL real e anexe /completions.

4. Configure o token para o modelo Function Compute RAG.

   SELECT rds_ai.update_model('fc-rag', 'token','8UiGAziWgYGPxM3qR5sAChBfDJRt****');

Verifique o novo modelo Function Compute RAG. Exemplo:

SELECT rds_ai.invoke_model('fc-rag', ARRAY['Which parameters are related to WAL log accumulation?']);

Funções

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

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

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

rds_ai.prompt(
    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 'L2'
) 
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.del_model (model_name text) 
RETURNS void

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