From 1f615cde2d3d76be349c2f20c30442ee8d4a6cf6 Mon Sep 17 00:00:00 2001 From: Jascha Date: Mon, 22 Dec 2025 18:09:09 +0100 Subject: [PATCH] feat: add BM25 text indexing support for hybrid search Add a `text_indexing` parameter to `create_vectorizer` that enables BM25 full-text search indexing via the pg_textsearch extension. This enables hybrid search (vector + BM25) on vectorized data. Features: - `ai.text_indexing_bm25(text_config, k1, b)` function with sane defaults - `ai.text_indexing_none()` to explicitly disable (default) - Auto-infers target column: chunk column if chunking enabled, source column if chunking disabled - Index created immediately when vectorizer is created - Fails with descriptive error if pg_textsearch extension not installed Example usage: ```sql SELECT ai.create_vectorizer( 'my_documents'::regclass, embedding => ai.embedding_openai('text-embedding-3-small', 768), text_indexing => ai.text_indexing_bm25() ); ``` --- projects/extension/Dockerfile | 8 + .../db/sql/idempotent/006-text-indexing.sql | 101 +++ ...{006-processing.sql => 007-processing.sql} | 0 .../{007-grant-to.sql => 008-grant-to.sql} | 0 .../{008-loading.sql => 009-loading.sql} | 0 .../{009-parsing.sql => 010-parsing.sql} | 0 ...10-destination.sql => 011-destination.sql} | 0 ...torizer-int.sql => 012-vectorizer-int.sql} | 204 +++++ ...torizer-api.sql => 013-vectorizer-api.sql} | 39 + ...r-tracking.sql => 014-worker-tracking.sql} | 0 ...c-catalog.sql => 015-semantic-catalog.sql} | 0 projects/pgai/pgai/data/ai.sql | 366 ++++++++- .../pgai/pgai/vectorizer/configuration.py | 32 + .../pgai/pgai/vectorizer/create_vectorizer.py | 6 + .../vectorizer/generate/config_generator.py | 21 +- .../pgai/pgai/vectorizer/generate/generate.py | 3 + .../text_indexing_creates_bm25_index.yaml | 709 ++++++++++++++++++ .../text_indexing_custom_parameters.yaml | 472 ++++++++++++ .../text_indexing_disabled_by_default.yaml | 473 ++++++++++++ ...text_indexing_enables_fulltext_search.yaml | 709 ++++++++++++++++++ ...ext_indexing_none_explicitly_disabled.yaml | 472 ++++++++++++ .../text_indexing_source_column.yaml | 472 ++++++++++++ .../vectorizer/cli/test_text_indexing.py | 340 +++++++++ 23 files changed, 4417 insertions(+), 10 deletions(-) create mode 100644 projects/pgai/db/sql/idempotent/006-text-indexing.sql rename projects/pgai/db/sql/idempotent/{006-processing.sql => 007-processing.sql} (100%) rename projects/pgai/db/sql/idempotent/{007-grant-to.sql => 008-grant-to.sql} (100%) rename projects/pgai/db/sql/idempotent/{008-loading.sql => 009-loading.sql} (100%) rename projects/pgai/db/sql/idempotent/{009-parsing.sql => 010-parsing.sql} (100%) rename projects/pgai/db/sql/idempotent/{010-destination.sql => 011-destination.sql} (100%) rename projects/pgai/db/sql/idempotent/{011-vectorizer-int.sql => 012-vectorizer-int.sql} (84%) rename projects/pgai/db/sql/idempotent/{012-vectorizer-api.sql => 013-vectorizer-api.sql} (94%) rename projects/pgai/db/sql/idempotent/{013-worker-tracking.sql => 014-worker-tracking.sql} (100%) rename projects/pgai/db/sql/idempotent/{014-semantic-catalog.sql => 015-semantic-catalog.sql} (100%) create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_creates_bm25_index.yaml create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_custom_parameters.yaml create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_disabled_by_default.yaml create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_enables_fulltext_search.yaml create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_none_explicitly_disabled.yaml create mode 100644 projects/pgai/tests/vectorizer/cassettes/text_indexing_source_column.yaml create mode 100644 projects/pgai/tests/vectorizer/cli/test_text_indexing.py diff --git a/projects/extension/Dockerfile b/projects/extension/Dockerfile index c94493b18..7841648cd 100644 --- a/projects/extension/Dockerfile +++ b/projects/extension/Dockerfile @@ -42,6 +42,14 @@ RUN set -e; \ dpkg -i pgvectorscale-postgresql-${PG_MAJOR}_${PGVECTORSCALE_VERSION}-Linux_"$TARGET_ARCH".deb; \ rm pgvectorscale-${PGVECTORSCALE_VERSION}-pg${PG_MAJOR}-"$TARGET_ARCH".zip pgvectorscale-postgresql-${PG_MAJOR}_${PGVECTORSCALE_VERSION}-Linux_"$TARGET_ARCH".deb +# install pg_textsearch +RUN set -e; \ + git clone --depth 1 https://github.com/timescale/pg_textsearch.git /tmp/pg_textsearch; \ + cd /tmp/pg_textsearch; \ + make; \ + make install; \ + rm -rf /tmp/pg_textsearch + ############################################################################### # image for use in testing the pgai library diff --git a/projects/pgai/db/sql/idempotent/006-text-indexing.sql b/projects/pgai/db/sql/idempotent/006-text-indexing.sql new file mode 100644 index 000000000..9beda2290 --- /dev/null +++ b/projects/pgai/db/sql/idempotent/006-text-indexing.sql @@ -0,0 +1,101 @@ + +------------------------------------------------------------------------------- +-- text_indexing_none +create or replace function ai.text_indexing_none() returns pg_catalog.jsonb +as $func$ + select jsonb_build_object + ( 'implementation', 'none' + , 'config_type', 'text_indexing' + ) +$func$ language sql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- text_indexing_bm25 +create or replace function ai.text_indexing_bm25 +( text_config pg_catalog.text default 'english' +, k1 pg_catalog.float8 default 1.2 +, b pg_catalog.float8 default 0.75 +) returns pg_catalog.jsonb +as $func$ + select json_strip_nulls(json_build_object + ( 'implementation', 'bm25' + , 'config_type', 'text_indexing' + , 'text_config', text_config + , 'k1', k1 + , 'b', b + )) +$func$ language sql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _validate_text_indexing_bm25 +create or replace function ai._validate_text_indexing_bm25(config pg_catalog.jsonb) returns void +as $func$ +declare + _text_config pg_catalog.text; + _k1 pg_catalog.float8; + _b pg_catalog.float8; +begin + -- Validate text_config is a valid regconfig (language configuration) + _text_config = config operator(pg_catalog.->>) 'text_config'; + if _text_config is not null then + begin + perform _text_config::pg_catalog.regconfig; + exception when others then + raise exception 'invalid text_config: %. Must be a valid text search configuration (e.g., ''english'', ''simple'', ''french'')', _text_config; + end; + end if; + + -- Validate k1 is positive + _k1 = (config operator(pg_catalog.->>) 'k1')::pg_catalog.float8; + if _k1 is not null and _k1 operator(pg_catalog.<=) 0 then + raise exception 'k1 must be a positive number, got: %', _k1; + end if; + + -- Validate b is between 0 and 1 + _b = (config operator(pg_catalog.->>) 'b')::pg_catalog.float8; + if _b is not null and (_b operator(pg_catalog.<) 0 or _b operator(pg_catalog.>) 1) then + raise exception 'b must be between 0 and 1, got: %', _b; + end if; +end +$func$ language plpgsql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _validate_text_indexing +create or replace function ai._validate_text_indexing(config pg_catalog.jsonb) returns void +as $func$ +declare + _config_type pg_catalog.text; + _implementation pg_catalog.text; +begin + if pg_catalog.jsonb_typeof(config) operator(pg_catalog.!=) 'object' then + raise exception 'text_indexing config is not a jsonb object'; + end if; + + _config_type = config operator(pg_catalog.->>) 'config_type'; + if _config_type is null or _config_type operator(pg_catalog.!=) 'text_indexing' then + raise exception 'invalid config_type for text_indexing config'; + end if; + _implementation = config operator(pg_catalog.->>) 'implementation'; + case _implementation + when 'none' then + -- ok + when 'bm25' then + perform ai._validate_text_indexing_bm25(config); + else + if _implementation is null then + raise exception 'text_indexing implementation not specified'; + else + raise exception 'invalid text_indexing implementation: "%"', _implementation; + end if; + end case; +end +$func$ language plpgsql immutable security invoker +set search_path to pg_catalog, pg_temp +; + diff --git a/projects/pgai/db/sql/idempotent/006-processing.sql b/projects/pgai/db/sql/idempotent/007-processing.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/006-processing.sql rename to projects/pgai/db/sql/idempotent/007-processing.sql diff --git a/projects/pgai/db/sql/idempotent/007-grant-to.sql b/projects/pgai/db/sql/idempotent/008-grant-to.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/007-grant-to.sql rename to projects/pgai/db/sql/idempotent/008-grant-to.sql diff --git a/projects/pgai/db/sql/idempotent/008-loading.sql b/projects/pgai/db/sql/idempotent/009-loading.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/008-loading.sql rename to projects/pgai/db/sql/idempotent/009-loading.sql diff --git a/projects/pgai/db/sql/idempotent/009-parsing.sql b/projects/pgai/db/sql/idempotent/010-parsing.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/009-parsing.sql rename to projects/pgai/db/sql/idempotent/010-parsing.sql diff --git a/projects/pgai/db/sql/idempotent/010-destination.sql b/projects/pgai/db/sql/idempotent/011-destination.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/010-destination.sql rename to projects/pgai/db/sql/idempotent/011-destination.sql diff --git a/projects/pgai/db/sql/idempotent/011-vectorizer-int.sql b/projects/pgai/db/sql/idempotent/012-vectorizer-int.sql similarity index 84% rename from projects/pgai/db/sql/idempotent/011-vectorizer-int.sql rename to projects/pgai/db/sql/idempotent/012-vectorizer-int.sql index c4b79c016..8642ff8b6 100644 --- a/projects/pgai/db/sql/idempotent/011-vectorizer-int.sql +++ b/projects/pgai/db/sql/idempotent/012-vectorizer-int.sql @@ -1077,6 +1077,173 @@ language plpgsql volatile security invoker set search_path to pg_catalog, pg_temp ; +------------------------------------------------------------------------------- +-- _vectorizer_text_index_exists +create or replace function ai._vectorizer_text_index_exists +( target_schema pg_catalog.name +, target_table pg_catalog.name +, column_name pg_catalog.name +) returns pg_catalog.bool as +$func$ +declare + _found pg_catalog.bool; +begin + -- look for a BM25 index on the target table for the specified column + select pg_catalog.count(*) filter + ( where pg_catalog.pg_get_indexdef(i.indexrelid) ilike '% using bm25 %' + ) > 0 into _found + from pg_catalog.pg_class k + inner join pg_catalog.pg_namespace n on (k.relnamespace operator(pg_catalog.=) n.oid) + inner join pg_index i on (k.oid operator(pg_catalog.=) i.indrelid) + inner join pg_catalog.pg_attribute a + on (k.oid operator(pg_catalog.=) a.attrelid + and a.attname operator(pg_catalog.=) column_name + and a.attnum operator(pg_catalog.=) i.indkey[0] + ) + where n.nspname operator(pg_catalog.=) target_schema + and k.relname operator(pg_catalog.=) target_table + ; + return coalesce(_found, false); +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _vectorizer_should_create_text_index +create or replace function ai._vectorizer_should_create_text_index(vectorizer ai.vectorizer) returns boolean +as $func$ +declare + _text_indexing pg_catalog.jsonb; + _implementation pg_catalog.text; + _schema_name pg_catalog.name; + _table_name pg_catalog.name; + _column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; +begin + -- grab the text_indexing config + _text_indexing = pg_catalog.jsonb_extract_path(vectorizer.config, 'text_indexing'); + if _text_indexing is null then + return false; + end if; + + -- grab the implementation + _implementation = pg_catalog.jsonb_extract_path_text(_text_indexing, 'implementation'); + -- if implementation is missing or none, exit + if _implementation is null or _implementation = 'none' then + return false; + end if; + + -- determine the target schema, table, and column based on destination and chunking config + _destination_impl = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'implementation'; + _chunking_impl = vectorizer.config operator(pg_catalog.->) 'chunking' operator(pg_catalog.->>) 'implementation'; + + -- if destination=column OR chunking=none, index the source column + -- otherwise, index the chunk column in the destination table + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _schema_name = vectorizer.source_schema; + _table_name = vectorizer.source_table; + _column_name = vectorizer.config operator(pg_catalog.->) 'loading' operator(pg_catalog.->>) 'column_name'; + else + _schema_name = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_schema'; + _table_name = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_table'; + _column_name = 'chunk'; + end if; + + -- see if the index already exists + if ai._vectorizer_text_index_exists(_schema_name, _table_name, _column_name) then + return false; + end if; + + return true; +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _vectorizer_create_text_index +create or replace function ai._vectorizer_create_text_index +( target_schema pg_catalog.name +, target_table pg_catalog.name +, column_name pg_catalog.name +, text_indexing pg_catalog.jsonb +) returns void as +$func$ +declare + _key1 pg_catalog.int4 = 1982010643; -- different key from vector index + _key2 pg_catalog.int4; + _text_config pg_catalog.text; + _k1 pg_catalog.float8; + _b pg_catalog.float8; + _index_name pg_catalog.name; + _with_parts pg_catalog.text[]; + _sql pg_catalog.text; +begin + -- check if pg_textsearch extension is installed + if not exists ( + select 1 from pg_catalog.pg_extension + where extname operator(pg_catalog.=) 'pg_textsearch' + ) then + raise exception 'pg_textsearch extension is not installed. Install it with: CREATE EXTENSION pg_textsearch;'; + end if; + + -- use the target table's oid as the second key for the advisory lock + select k.oid::pg_catalog.int4 into strict _key2 + from pg_catalog.pg_class k + inner join pg_catalog.pg_namespace n on (k.relnamespace operator(pg_catalog.=) n.oid) + where k.relname operator(pg_catalog.=) target_table + and n.nspname operator(pg_catalog.=) target_schema + ; + + -- try to grab a transaction-level advisory lock specific to the target table + if not pg_catalog.pg_try_advisory_xact_lock(_key1, _key2) then + raise warning 'another process is already building a text index on %.%', target_schema, target_table; + return; + end if; + + -- double-check that the index doesn't exist now that we're holding the advisory lock + if ai._vectorizer_text_index_exists(target_schema, target_table, column_name) then + raise notice 'the text index on %.%.% already exists', target_schema, target_table, column_name; + return; + end if; + + -- extract configuration parameters + _text_config = coalesce(pg_catalog.jsonb_extract_path_text(text_indexing, 'text_config'), 'english'); + _k1 = (pg_catalog.jsonb_extract_path_text(text_indexing, 'k1'))::pg_catalog.float8; + _b = (pg_catalog.jsonb_extract_path_text(text_indexing, 'b'))::pg_catalog.float8; + + -- build the WITH clause parts + _with_parts = array[pg_catalog.format('text_config=%L', _text_config)]; + if _k1 is not null then + _with_parts = pg_catalog.array_append(_with_parts, pg_catalog.format('k1=%s', _k1)); + end if; + if _b is not null then + _with_parts = pg_catalog.array_append(_with_parts, pg_catalog.format('b=%s', _b)); + end if; + + -- generate index name + _index_name = pg_catalog.format('%s_%s_bm25_idx', target_table, column_name); + + -- create the BM25 index + select pg_catalog.format + ( $sql$create index %I on %I.%I using bm25 (%I) with (%s)$sql$ + , _index_name + , target_schema, target_table + , column_name + , pg_catalog.array_to_string(_with_parts, ', ') + ) into strict _sql; + + execute _sql; +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + ------------------------------------------------------------------------------- -- _vectorizer_schedule_job @@ -1164,6 +1331,12 @@ declare _found pg_catalog.bool; _count pg_catalog.int8; _should_create_vector_index pg_catalog.bool; + _should_create_text_index pg_catalog.bool; + _text_schema_name pg_catalog.name; + _text_table_name pg_catalog.name; + _text_column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; begin set local search_path = pg_catalog, pg_temp; if config is null then @@ -1209,6 +1382,37 @@ begin commit; set local search_path = pg_catalog, pg_temp; + -- check and create text index if configured + _should_create_text_index = ai._vectorizer_should_create_text_index(_vec); + if _should_create_text_index then + commit; + set local search_path = pg_catalog, pg_temp; + + -- determine the target schema, table, and column for text index + _destination_impl = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'implementation'; + _chunking_impl = _vec.config operator(pg_catalog.->) 'chunking' operator(pg_catalog.->>) 'implementation'; + + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _text_schema_name = _vec.source_schema; + _text_table_name = _vec.source_table; + _text_column_name = _vec.config operator(pg_catalog.->) 'loading' operator(pg_catalog.->>) 'column_name'; + else + _text_schema_name = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_schema'; + _text_table_name = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_table'; + _text_column_name = 'chunk'; + end if; + + perform ai._vectorizer_create_text_index + ( _text_schema_name + , _text_table_name + , _text_column_name + , pg_catalog.jsonb_extract_path(_vec.config, 'text_indexing') + ); + end if; + + commit; + set local search_path = pg_catalog, pg_temp; + -- if there is at least one item in the queue, we need to execute the vectorizer select pg_catalog.format ( $sql$ diff --git a/projects/pgai/db/sql/idempotent/012-vectorizer-api.sql b/projects/pgai/db/sql/idempotent/013-vectorizer-api.sql similarity index 94% rename from projects/pgai/db/sql/idempotent/012-vectorizer-api.sql rename to projects/pgai/db/sql/idempotent/013-vectorizer-api.sql index 74dc45068..0b420cf70 100644 --- a/projects/pgai/db/sql/idempotent/012-vectorizer-api.sql +++ b/projects/pgai/db/sql/idempotent/013-vectorizer-api.sql @@ -9,6 +9,7 @@ create or replace function ai.create_vectorizer , embedding pg_catalog.jsonb default null , chunking pg_catalog.jsonb default ai.chunking_recursive_character_text_splitter() , indexing pg_catalog.jsonb default ai.indexing_default() +, text_indexing pg_catalog.jsonb default ai.text_indexing_none() , formatting pg_catalog.jsonb default ai.formatting_python_template() , scheduling pg_catalog.jsonb default ai.scheduling_default() , processing pg_catalog.jsonb default ai.processing_default() @@ -129,6 +130,9 @@ begin -- validate the indexing config perform ai._validate_indexing(indexing); + -- validate the text_indexing config + perform ai._validate_text_indexing(text_indexing); + -- validate the formatting config perform ai._validate_formatting(formatting, _source_schema, _source_table); @@ -272,6 +276,7 @@ begin , 'embedding', embedding , 'chunking', chunking , 'indexing', indexing + , 'text_indexing', text_indexing , 'formatting', formatting , 'scheduling', scheduling , 'processing', processing @@ -306,6 +311,40 @@ begin ; execute _sql; end if; + + -- create text index if configured + if text_indexing operator(pg_catalog.->>) 'implementation' operator(pg_catalog.!=) 'none' then + declare + _text_schema_name pg_catalog.name; + _text_table_name pg_catalog.name; + _text_column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; + begin + _destination_impl = destination operator(pg_catalog.->>) 'implementation'; + _chunking_impl = chunking operator(pg_catalog.->>) 'implementation'; + + -- if destination=column OR chunking=none, index the source column + -- otherwise, index the chunk column in the destination table + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _text_schema_name = _source_schema; + _text_table_name = _source_table; + _text_column_name = loading operator(pg_catalog.->>) 'column_name'; + else + _text_schema_name = destination operator(pg_catalog.->>) 'target_schema'; + _text_table_name = destination operator(pg_catalog.->>) 'target_table'; + _text_column_name = 'chunk'; + end if; + + perform ai._vectorizer_create_text_index + ( _text_schema_name + , _text_table_name + , _text_column_name + , text_indexing + ); + end; + end if; + return _vectorizer_id; end $func$ language plpgsql volatile security invoker diff --git a/projects/pgai/db/sql/idempotent/013-worker-tracking.sql b/projects/pgai/db/sql/idempotent/014-worker-tracking.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/013-worker-tracking.sql rename to projects/pgai/db/sql/idempotent/014-worker-tracking.sql diff --git a/projects/pgai/db/sql/idempotent/014-semantic-catalog.sql b/projects/pgai/db/sql/idempotent/015-semantic-catalog.sql similarity index 100% rename from projects/pgai/db/sql/idempotent/014-semantic-catalog.sql rename to projects/pgai/db/sql/idempotent/015-semantic-catalog.sql diff --git a/projects/pgai/pgai/data/ai.sql b/projects/pgai/pgai/data/ai.sql index 2ec67ed9b..d06d5c253 100644 --- a/projects/pgai/pgai/data/ai.sql +++ b/projects/pgai/pgai/data/ai.sql @@ -1810,7 +1810,112 @@ set search_path to pg_catalog, pg_temp -------------------------------------------------------------------------------- --- 006-processing.sql +-- 006-text-indexing.sql + +------------------------------------------------------------------------------- +-- text_indexing_none +create or replace function ai.text_indexing_none() returns pg_catalog.jsonb +as $func$ + select jsonb_build_object + ( 'implementation', 'none' + , 'config_type', 'text_indexing' + ) +$func$ language sql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- text_indexing_bm25 +create or replace function ai.text_indexing_bm25 +( text_config pg_catalog.text default 'english' +, k1 pg_catalog.float8 default 1.2 +, b pg_catalog.float8 default 0.75 +) returns pg_catalog.jsonb +as $func$ + select json_strip_nulls(json_build_object + ( 'implementation', 'bm25' + , 'config_type', 'text_indexing' + , 'text_config', text_config + , 'k1', k1 + , 'b', b + )) +$func$ language sql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _validate_text_indexing_bm25 +create or replace function ai._validate_text_indexing_bm25(config pg_catalog.jsonb) returns void +as $func$ +declare + _text_config pg_catalog.text; + _k1 pg_catalog.float8; + _b pg_catalog.float8; +begin + -- Validate text_config is a valid regconfig (language configuration) + _text_config = config operator(pg_catalog.->>) 'text_config'; + if _text_config is not null then + begin + perform _text_config::pg_catalog.regconfig; + exception when others then + raise exception 'invalid text_config: %. Must be a valid text search configuration (e.g., ''english'', ''simple'', ''french'')', _text_config; + end; + end if; + + -- Validate k1 is positive + _k1 = (config operator(pg_catalog.->>) 'k1')::pg_catalog.float8; + if _k1 is not null and _k1 operator(pg_catalog.<=) 0 then + raise exception 'k1 must be a positive number, got: %', _k1; + end if; + + -- Validate b is between 0 and 1 + _b = (config operator(pg_catalog.->>) 'b')::pg_catalog.float8; + if _b is not null and (_b operator(pg_catalog.<) 0 or _b operator(pg_catalog.>) 1) then + raise exception 'b must be between 0 and 1, got: %', _b; + end if; +end +$func$ language plpgsql immutable security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _validate_text_indexing +create or replace function ai._validate_text_indexing(config pg_catalog.jsonb) returns void +as $func$ +declare + _config_type pg_catalog.text; + _implementation pg_catalog.text; +begin + if pg_catalog.jsonb_typeof(config) operator(pg_catalog.!=) 'object' then + raise exception 'text_indexing config is not a jsonb object'; + end if; + + _config_type = config operator(pg_catalog.->>) 'config_type'; + if _config_type is null or _config_type operator(pg_catalog.!=) 'text_indexing' then + raise exception 'invalid config_type for text_indexing config'; + end if; + _implementation = config operator(pg_catalog.->>) 'implementation'; + case _implementation + when 'none' then + -- ok + when 'bm25' then + perform ai._validate_text_indexing_bm25(config); + else + if _implementation is null then + raise exception 'text_indexing implementation not specified'; + else + raise exception 'invalid text_indexing implementation: "%"', _implementation; + end if; + end case; +end +$func$ language plpgsql immutable security invoker +set search_path to pg_catalog, pg_temp +; + + + +-------------------------------------------------------------------------------- +-- 007-processing.sql ------------------------------------------------------------------------------- -- processing_default @@ -1888,7 +1993,7 @@ set search_path to pg_catalog, pg_temp -------------------------------------------------------------------------------- --- 007-grant-to.sql +-- 008-grant-to.sql ------------------------------------------------------------------------------- -- grant_to create or replace function ai.grant_to(variadic grantees pg_catalog.name[]) returns pg_catalog.name[] @@ -1914,7 +2019,7 @@ set search_path to pg_catalog, pg_temp -------------------------------------------------------------------------------- --- 008-loading.sql +-- 009-loading.sql ------------------------------------------------------------------------------- -- loading_column create or replace function ai.loading_column @@ -2022,7 +2127,7 @@ set search_path to pg_catalog, pg_temp -------------------------------------------------------------------------------- --- 009-parsing.sql +-- 010-parsing.sql ------------------------------------------------------------------------------- -- parsing_auto create or replace function ai.parsing_auto() returns pg_catalog.jsonb @@ -2134,7 +2239,7 @@ set search_path to pg_catalog, pg_temp; -------------------------------------------------------------------------------- --- 010-destination.sql +-- 011-destination.sql ------------------------------------------------------------------------------- -- destination_table create or replace function ai.destination_table @@ -2277,7 +2382,7 @@ set search_path to pg_catalog, pg_temp ; -------------------------------------------------------------------------------- --- 011-vectorizer-int.sql +-- 012-vectorizer-int.sql ------------------------------------------------------------------------------- -- _vectorizer_source_pk @@ -3357,6 +3462,173 @@ language plpgsql volatile security invoker set search_path to pg_catalog, pg_temp ; +------------------------------------------------------------------------------- +-- _vectorizer_text_index_exists +create or replace function ai._vectorizer_text_index_exists +( target_schema pg_catalog.name +, target_table pg_catalog.name +, column_name pg_catalog.name +) returns pg_catalog.bool as +$func$ +declare + _found pg_catalog.bool; +begin + -- look for a BM25 index on the target table for the specified column + select pg_catalog.count(*) filter + ( where pg_catalog.pg_get_indexdef(i.indexrelid) ilike '% using bm25 %' + ) > 0 into _found + from pg_catalog.pg_class k + inner join pg_catalog.pg_namespace n on (k.relnamespace operator(pg_catalog.=) n.oid) + inner join pg_index i on (k.oid operator(pg_catalog.=) i.indrelid) + inner join pg_catalog.pg_attribute a + on (k.oid operator(pg_catalog.=) a.attrelid + and a.attname operator(pg_catalog.=) column_name + and a.attnum operator(pg_catalog.=) i.indkey[0] + ) + where n.nspname operator(pg_catalog.=) target_schema + and k.relname operator(pg_catalog.=) target_table + ; + return coalesce(_found, false); +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _vectorizer_should_create_text_index +create or replace function ai._vectorizer_should_create_text_index(vectorizer ai.vectorizer) returns boolean +as $func$ +declare + _text_indexing pg_catalog.jsonb; + _implementation pg_catalog.text; + _schema_name pg_catalog.name; + _table_name pg_catalog.name; + _column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; +begin + -- grab the text_indexing config + _text_indexing = pg_catalog.jsonb_extract_path(vectorizer.config, 'text_indexing'); + if _text_indexing is null then + return false; + end if; + + -- grab the implementation + _implementation = pg_catalog.jsonb_extract_path_text(_text_indexing, 'implementation'); + -- if implementation is missing or none, exit + if _implementation is null or _implementation = 'none' then + return false; + end if; + + -- determine the target schema, table, and column based on destination and chunking config + _destination_impl = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'implementation'; + _chunking_impl = vectorizer.config operator(pg_catalog.->) 'chunking' operator(pg_catalog.->>) 'implementation'; + + -- if destination=column OR chunking=none, index the source column + -- otherwise, index the chunk column in the destination table + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _schema_name = vectorizer.source_schema; + _table_name = vectorizer.source_table; + _column_name = vectorizer.config operator(pg_catalog.->) 'loading' operator(pg_catalog.->>) 'column_name'; + else + _schema_name = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_schema'; + _table_name = vectorizer.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_table'; + _column_name = 'chunk'; + end if; + + -- see if the index already exists + if ai._vectorizer_text_index_exists(_schema_name, _table_name, _column_name) then + return false; + end if; + + return true; +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + +------------------------------------------------------------------------------- +-- _vectorizer_create_text_index +create or replace function ai._vectorizer_create_text_index +( target_schema pg_catalog.name +, target_table pg_catalog.name +, column_name pg_catalog.name +, text_indexing pg_catalog.jsonb +) returns void as +$func$ +declare + _key1 pg_catalog.int4 = 1982010643; -- different key from vector index + _key2 pg_catalog.int4; + _text_config pg_catalog.text; + _k1 pg_catalog.float8; + _b pg_catalog.float8; + _index_name pg_catalog.name; + _with_parts pg_catalog.text[]; + _sql pg_catalog.text; +begin + -- check if pg_textsearch extension is installed + if not exists ( + select 1 from pg_catalog.pg_extension + where extname operator(pg_catalog.=) 'pg_textsearch' + ) then + raise exception 'pg_textsearch extension is not installed. Install it with: CREATE EXTENSION pg_textsearch;'; + end if; + + -- use the target table's oid as the second key for the advisory lock + select k.oid::pg_catalog.int4 into strict _key2 + from pg_catalog.pg_class k + inner join pg_catalog.pg_namespace n on (k.relnamespace operator(pg_catalog.=) n.oid) + where k.relname operator(pg_catalog.=) target_table + and n.nspname operator(pg_catalog.=) target_schema + ; + + -- try to grab a transaction-level advisory lock specific to the target table + if not pg_catalog.pg_try_advisory_xact_lock(_key1, _key2) then + raise warning 'another process is already building a text index on %.%', target_schema, target_table; + return; + end if; + + -- double-check that the index doesn't exist now that we're holding the advisory lock + if ai._vectorizer_text_index_exists(target_schema, target_table, column_name) then + raise notice 'the text index on %.%.% already exists', target_schema, target_table, column_name; + return; + end if; + + -- extract configuration parameters + _text_config = coalesce(pg_catalog.jsonb_extract_path_text(text_indexing, 'text_config'), 'english'); + _k1 = (pg_catalog.jsonb_extract_path_text(text_indexing, 'k1'))::pg_catalog.float8; + _b = (pg_catalog.jsonb_extract_path_text(text_indexing, 'b'))::pg_catalog.float8; + + -- build the WITH clause parts + _with_parts = array[pg_catalog.format('text_config=%L', _text_config)]; + if _k1 is not null then + _with_parts = pg_catalog.array_append(_with_parts, pg_catalog.format('k1=%s', _k1)); + end if; + if _b is not null then + _with_parts = pg_catalog.array_append(_with_parts, pg_catalog.format('b=%s', _b)); + end if; + + -- generate index name + _index_name = pg_catalog.format('%s_%s_bm25_idx', target_table, column_name); + + -- create the BM25 index + select pg_catalog.format + ( $sql$create index %I on %I.%I using bm25 (%I) with (%s)$sql$ + , _index_name + , target_schema, target_table + , column_name + , pg_catalog.array_to_string(_with_parts, ', ') + ) into strict _sql; + + execute _sql; +end +$func$ +language plpgsql volatile security invoker +set search_path to pg_catalog, pg_temp +; + ------------------------------------------------------------------------------- -- _vectorizer_schedule_job @@ -3444,6 +3716,12 @@ declare _found pg_catalog.bool; _count pg_catalog.int8; _should_create_vector_index pg_catalog.bool; + _should_create_text_index pg_catalog.bool; + _text_schema_name pg_catalog.name; + _text_table_name pg_catalog.name; + _text_column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; begin set local search_path = pg_catalog, pg_temp; if config is null then @@ -3489,6 +3767,37 @@ begin commit; set local search_path = pg_catalog, pg_temp; + -- check and create text index if configured + _should_create_text_index = ai._vectorizer_should_create_text_index(_vec); + if _should_create_text_index then + commit; + set local search_path = pg_catalog, pg_temp; + + -- determine the target schema, table, and column for text index + _destination_impl = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'implementation'; + _chunking_impl = _vec.config operator(pg_catalog.->) 'chunking' operator(pg_catalog.->>) 'implementation'; + + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _text_schema_name = _vec.source_schema; + _text_table_name = _vec.source_table; + _text_column_name = _vec.config operator(pg_catalog.->) 'loading' operator(pg_catalog.->>) 'column_name'; + else + _text_schema_name = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_schema'; + _text_table_name = _vec.config operator(pg_catalog.->) 'destination' operator(pg_catalog.->>) 'target_table'; + _text_column_name = 'chunk'; + end if; + + perform ai._vectorizer_create_text_index + ( _text_schema_name + , _text_table_name + , _text_column_name + , pg_catalog.jsonb_extract_path(_vec.config, 'text_indexing') + ); + end if; + + commit; + set local search_path = pg_catalog, pg_temp; + -- if there is at least one item in the queue, we need to execute the vectorizer select pg_catalog.format ( $sql$ @@ -3549,7 +3858,7 @@ set search_path to pg_catalog, pg_temp ; -------------------------------------------------------------------------------- --- 012-vectorizer-api.sql +-- 013-vectorizer-api.sql ------------------------------------------------------------------------------- -- create_vectorizer create or replace function ai.create_vectorizer @@ -3561,6 +3870,7 @@ create or replace function ai.create_vectorizer , embedding pg_catalog.jsonb default null , chunking pg_catalog.jsonb default ai.chunking_recursive_character_text_splitter() , indexing pg_catalog.jsonb default ai.indexing_default() +, text_indexing pg_catalog.jsonb default ai.text_indexing_none() , formatting pg_catalog.jsonb default ai.formatting_python_template() , scheduling pg_catalog.jsonb default ai.scheduling_default() , processing pg_catalog.jsonb default ai.processing_default() @@ -3681,6 +3991,9 @@ begin -- validate the indexing config perform ai._validate_indexing(indexing); + -- validate the text_indexing config + perform ai._validate_text_indexing(text_indexing); + -- validate the formatting config perform ai._validate_formatting(formatting, _source_schema, _source_table); @@ -3824,6 +4137,7 @@ begin , 'embedding', embedding , 'chunking', chunking , 'indexing', indexing + , 'text_indexing', text_indexing , 'formatting', formatting , 'scheduling', scheduling , 'processing', processing @@ -3858,6 +4172,40 @@ begin ; execute _sql; end if; + + -- create text index if configured + if text_indexing operator(pg_catalog.->>) 'implementation' operator(pg_catalog.!=) 'none' then + declare + _text_schema_name pg_catalog.name; + _text_table_name pg_catalog.name; + _text_column_name pg_catalog.name; + _destination_impl pg_catalog.text; + _chunking_impl pg_catalog.text; + begin + _destination_impl = destination operator(pg_catalog.->>) 'implementation'; + _chunking_impl = chunking operator(pg_catalog.->>) 'implementation'; + + -- if destination=column OR chunking=none, index the source column + -- otherwise, index the chunk column in the destination table + if _destination_impl operator(pg_catalog.=) 'column' or _chunking_impl operator(pg_catalog.=) 'none' then + _text_schema_name = _source_schema; + _text_table_name = _source_table; + _text_column_name = loading operator(pg_catalog.->>) 'column_name'; + else + _text_schema_name = destination operator(pg_catalog.->>) 'target_schema'; + _text_table_name = destination operator(pg_catalog.->>) 'target_table'; + _text_column_name = 'chunk'; + end if; + + perform ai._vectorizer_create_text_index + ( _text_schema_name + , _text_table_name + , _text_column_name + , text_indexing + ); + end; + end if; + return _vectorizer_id; end $func$ language plpgsql volatile security invoker @@ -4377,7 +4725,7 @@ set search_path to pg_catalog, pg_temp -------------------------------------------------------------------------------- --- 013-worker-tracking.sql +-- 014-worker-tracking.sql CREATE OR REPLACE FUNCTION ai._worker_start(version text, expected_heartbeat_interval interval) RETURNS uuid AS $$ DECLARE worker_id uuid; @@ -4428,7 +4776,7 @@ $$ LANGUAGE plpgsql security invoker set search_path to pg_catalog, pg_temp; -------------------------------------------------------------------------------- --- 014-semantic-catalog.sql +-- 015-semantic-catalog.sql ------------------------------------------------------------------------------- -- embedding_sentence_transformers diff --git a/projects/pgai/pgai/vectorizer/configuration.py b/projects/pgai/pgai/vectorizer/configuration.py index 15fd06d10..2acde2c62 100644 --- a/projects/pgai/pgai/vectorizer/configuration.py +++ b/projects/pgai/pgai/vectorizer/configuration.py @@ -140,6 +140,17 @@ class EmbeddingOpenaiConfig(SQLArgumentMixin): base_url: str | None = None +@dataclass +class EmbeddingSentenceTransformersConfig(SQLArgumentMixin): + """Configuration for ai.embedding_sentence_transformers function.""" + + arg_type: ClassVar[str] = "embedding" + function_name: ClassVar[str] = "ai.embedding_sentence_transformers" + + model: str | None = None + dimensions: int | None = None + + @dataclass class EmbeddingVoyageaiConfig(SQLArgumentMixin): """Configuration for ai.embedding_voyageai function.""" @@ -230,6 +241,7 @@ class LoadingUriConfig(SQLArgumentMixin): column_name: str retries: int | None = None + aws_role_arn: str | None = None @dataclass @@ -302,3 +314,23 @@ class SchedulingTimescaledbConfig(SQLArgumentMixin): initial_start: datetime | None = None fixed_schedule: bool | None = None timezone: str | None = None + + +@dataclass +class TextIndexingBm25Config(SQLArgumentMixin): + """Configuration for ai.text_indexing_bm25 function.""" + + arg_type: ClassVar[str] = "text_indexing" + function_name: ClassVar[str] = "ai.text_indexing_bm25" + + text_config: str | None = None + k1: float | None = None + b: float | None = None + + +@dataclass +class TextIndexingNoneConfig(SQLArgumentMixin): + """Configuration for ai.text_indexing_none function.""" + + arg_type: ClassVar[str] = "text_indexing" + function_name: ClassVar[str] = "ai.text_indexing_none" diff --git a/projects/pgai/pgai/vectorizer/create_vectorizer.py b/projects/pgai/pgai/vectorizer/create_vectorizer.py index 272253098..4c8d8b606 100644 --- a/projects/pgai/pgai/vectorizer/create_vectorizer.py +++ b/projects/pgai/pgai/vectorizer/create_vectorizer.py @@ -14,6 +14,7 @@ EmbeddingLitellmConfig, EmbeddingOllamaConfig, EmbeddingOpenaiConfig, + EmbeddingSentenceTransformersConfig, EmbeddingVoyageaiConfig, FormattingPythonTemplateConfig, IndexingDefaultConfig, @@ -31,6 +32,8 @@ SchedulingNoneConfig, SchedulingTimescaledbConfig, SQLArgumentMixin, + TextIndexingBm25Config, + TextIndexingNoneConfig, ) @@ -53,6 +56,7 @@ class CreateVectorizer: EmbeddingLitellmConfig | EmbeddingOllamaConfig | EmbeddingOpenaiConfig + | EmbeddingSentenceTransformersConfig | EmbeddingVoyageaiConfig | None ) = None @@ -69,6 +73,7 @@ class CreateVectorizer: | IndexingNoneConfig | None ) = None + text_indexing: TextIndexingBm25Config | TextIndexingNoneConfig | None = None formatting: FormattingPythonTemplateConfig | None = None scheduling: ( SchedulingDefaultConfig @@ -81,6 +86,7 @@ class CreateVectorizer: queue_table: str | None = None grant_to: Any | None = None enqueue_existing: bool | None = None + if_not_exists: bool | None = None def to_sql(self) -> str: """Convert parameters to SQL function call""" diff --git a/projects/pgai/pgai/vectorizer/generate/config_generator.py b/projects/pgai/pgai/vectorizer/generate/config_generator.py index f6a36e4d2..e6077201e 100644 --- a/projects/pgai/pgai/vectorizer/generate/config_generator.py +++ b/projects/pgai/pgai/vectorizer/generate/config_generator.py @@ -52,7 +52,7 @@ def to_sql_argument(self) -> str: @dataclass class {{ function.name|replace('ai.', '')|replace('_', ' ')|title|replace(' ', '') }}Config(SQLArgumentMixin): """Configuration for {{ function.name }} function.""" - arg_type: ClassVar[str] = "{{ function.name|split('.')|last|split('_')|first }}" + arg_type: ClassVar[str] = "{{ function.name|get_arg_type }}" function_name: ClassVar[str] = "{{ function.name }}" {% for param in function.parameters %} @@ -123,6 +123,24 @@ def generate_vectorizer_params( output_file.write_text(output) +def _get_arg_type(function_name: str) -> str: + """Extract arg_type from function name (e.g., 'text_indexing_bm25' -> 'text_indexing'). + + Maps function names to their corresponding create_vectorizer parameter names. + """ + # Known arg_type prefixes that span multiple words + name = function_name.split(".")[-1] # Remove 'ai.' prefix + + # Check for known multi-word prefixes + multi_word_prefixes = ["text_indexing"] + for prefix in multi_word_prefixes: + if name.startswith(prefix + "_"): + return prefix + + # Default: use the first word + return name.split("_")[0] + + def generate_config_classes( functions: list[PostgresFunction], output_file: Path ) -> None: @@ -131,6 +149,7 @@ def generate_config_classes( # Add custom filters env.filters["split"] = lambda x, sep: x.split(sep) # type: ignore + env.filters["get_arg_type"] = _get_arg_type template = env.from_string(TEMPLATE) output = template.render(functions=functions) diff --git a/projects/pgai/pgai/vectorizer/generate/generate.py b/projects/pgai/pgai/vectorizer/generate/generate.py index 76fde2049..68777cda8 100644 --- a/projects/pgai/pgai/vectorizer/generate/generate.py +++ b/projects/pgai/pgai/vectorizer/generate/generate.py @@ -24,6 +24,7 @@ "embedding_ollama", "embedding_voyageai", "embedding_litellm", + "embedding_sentence_transformers", "chunking_character_text_splitter", "chunking_recursive_character_text_splitter", "chunking_none", @@ -32,6 +33,8 @@ "indexing_hnsw", "indexing_default", "indexing_none", + "text_indexing_none", + "text_indexing_bm25", "scheduling_default", "scheduling_none", "scheduling_timescaledb", diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_creates_bm25_index.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_creates_bm25_index.yaml new file mode 100644 index 000000000..360b8bf38 --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_creates_bm25_index.yaml @@ -0,0 +1,709 @@ +interactions: +- request: + body: '{"input":["post_1"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DIAWREQ1qwdAETLM7X/IMu3VVDtbn24efVLV2k5iZAUI/quV/QsI/9BmRo6BQ7PmEYWRoKCXjW3I + e2Z5kx5qoalGfQvptrc5Qq+xqcMEGLEPbfOTb1n9xmS9blvKAxhgOKlaVoYgv+x33eO265QokjX/ + q/++PB7PX7/44esv359vj+dP3//5/vzw8ng8v/r8/fPn2+OTl8fj8fjv3z+8+1e//vmLr7/66vtf + vn0kbvi9/6L+D59vD/z09278JO3/83g8Hq/4CHTS7ftw5cC41jX+c0CrO3Y/cIjkZpDPt/O2mhWy + UU+k/UK8GfQHpaoALV7BNhHNK0TMCPs1AYA6VEk/wN1WiY98wOtNvfRrxEdAUCtXSM1UaK0PEAJ5 + /Q2v+jrvAxRaUQ15p+sOgrhul4sOmM1aSgaKejbmOQpsaloxO6M7nH6CcthdlHMgOF5nX2oP8uoH + JFZwPCbN1qx52YDjhiFRT9/OSax7735zTu2qdXCpqopeiqvDndvdLratTuVMrqwDbtuzVoBcO5sp + h4hTq327W49PMpXvuPbPQ3i3ERaih6zLVcLp3RmLv4JdZDzEVjU3QiEqxqYUQzeW7ccB4bCP87KW + opWQQ0h4BVqHaHuUNiRDWhYC+mV7RtlIVl154hAQ7I1y4mXWuIaYdZfyMJsYTCfKq6BrY8vuYc+d + LKWqPiCD9nlpoy9672rQ92NycQJY0EMl31YYbpQxcHE3UPpFRtHhZLAkCw+GbC+q7AtvImmHyRNC + VVhMakj2JbUA4eybu5GrPD7YSrszkmG7UKXZYxLwdYGMSnfnxg9pyVVgIhTseEeWFT1FazHC2J3U + 44g4dUDzRRxwBYohchp1tj3I1E6uVANda8mNXwMAeq/Q+hFjKs4DtXf+JfZK0CLe50RfghYy2roP + 0hCTmCmAPexgteirON6T8f2W3qxqGNd9V1kseq+qANTFjidQnF46HUv0tcY+mkI2MSvZal+6nR0b + Fx974ghzN5pKJ+ypusNbzZuxDhHV3qo4h0BlpTXEI0tImIYlNa66IUAkR0Q6SjSnxu8u08P2CcXn + DE4c4Kzl0gVY4ErYsT1c1bzIXXMNX3lFGDEDCEg9vC3kRwB7p9wZzdjodiAVYbd28sao5yjhkK6y + Ol/Q4gJ6IRaR0sa30oB5mZjtGFFjPIw4yMxuNdbWmnN4OyM92EVEZHMof4hlB3d4yEBD155FMnTb + CCCDCySC0x47WJAsdhn2CbS2GIIesbpLVhbZGVCuBPB2mZ1MENC8uy0opHZk7RkQVsfuICCpk/Pt + AILsHi0jUHVJEPdbLXa6NmSFt0FI0bNBoIQBOePKBxaSSq/gYXDKj/EkdeElBro4UIWKjavdvVPJ + IbRn4zMP4110Me+22DWcxSAIEWVbCMBaZyjARE0yGOWVKkDrPdqDVWjsd0YFMPqmZjCD0w2Uarav + uqA7R6PIcFU65SIaoK+9CFOX7Zh50UBLFSNN1EmoxrR+wcU6CjBpZ/MeUm7BCgdQdVfGv7qJoZ47 + dNdUxE1uJgXfXZPMLQApJjh9tRhNieQF534ADnpKBwxqCiJe1IfGWupi4wqbgd6W+TECp6JduW9h + /hGRMpW1QJK8qvY8ZT5ayI1zw2Y8+rLuj6PdsiYbttXHnlRgNBJYia0HKRTNOTtXzHpXzmhmSOhB + DHKgYJACOxxa1VKIcC2n1HDoetPabYG5tqQdT05lOA6KcqsVTcpdO3sgetb5uYS7IXEPOaUtWpqr + H15LNTVQk2KS1QF5gmWwpRW0fU25lLhb1BVYOkLHGmunYca8UhccD1hFDYQJri2/BTU4k4oSGnSJ + aLA3Lk5NrlmkDyFXulGLS24OvqQlZMQGPhmU1ExjxLYuYfitui3Yye0scD5g1ySSmuhhLg3oVuMy + eACMbV8fk2ZrVhXuWMncEYLeGyyT5TjFzW8KI96AkUc6aUwoWBmkDX/oqXJjECOaIofmPYRZONn4 + Bh3iHCKaQeZss80usXXhgZwYnsOCmspy/RBcafdlR8ELhW/c3LTZX0heqiH6AnJmyqHFJICOe0Yd + L7PB9o6ZjSJvbKmvS58VtJPgHFPj0eTL4CJO1B9itSj7Euxic2eG6j6C2bKEi4n3iHQLzCNAXcrA + 0MCJQEI+o6p2e5yCOkxSJOxMzw2TXhCr0uotzIpiD1KbEx22NaQ4bhWoeaz2lNotVNvFMBWWCYvO + rHmdDkq41IsjXA766JfN8shWMsJdGFTueI42T8scQCgMDDVLEXb3Tj37AbAgLpWD5E2MXW7JK6RG + YbrkRgRbXjdgVp0KuGAfrR797YWcxcIKNVQuK9WWnXgWp6n1irzb4o8gx6xQJ4eAHfXa50xRQXMB + 1YGhwSCyk7hsB2PW8kxOjVsQCGYVUgXysMygP1lQQ7VlXEeId9BwHJW6ii8piU7qCd1z4eeg4ZL5 + omJaDhrIFm92C4BzMIcd295GARlTxgjK+PhId7M0xeusXAV9t0eiaWol/0aWihR7nmEjuyP1TvI6 + quhDQFXRw4d6NnGhgyimex10GIA2R1zK+d8QbnwzKtAXWPxa5jYqLBJYzbb3auNBIWyli6Glciar + mba4lBQs5babWlS7W6UdRQkkxByCq/as/iFdUDQpi86iaiIyex8vbGZcyk35Wa8p+CFw7Wl/Qkg5 + GPhOefECIo05ep4hVwN1NV6443wMTZ60FOsAhx1oIGaS0OmpDR7ISx8R9gmG7eMe7mzTZRZ3Lia9 + mDtCuYKXinp0Z9YbBBeyiCKCvdsbtyqz3N4KDWsdzxQ4zh2hYaGb2pw/cusc+y2alJOr3hNS3kbL + 9qSeTShOkXzkujfEI9HHYgPuI6bYnHeY6210y4Qz5XxJPELCRsAN4+gdeJTT5jRN0TzOIjnEOlz+ + xNpe7/8LLI6uRGZbuo1V5J0xmt2NNe83IqPjdkvkLhStG1fd5oWoyE0uSGKmWcyXOYGrVlItMnuO + 252xpdCzW6YwDkV6WMUFAq0gBCLvbZV3pz5kaQfHfcJXA6zfiqqL1eFq6NRnqhJ2rAOGTAP1IWTa + PLjbYpHhDlzoUlU5BHUqvLe9bx3L0HLWqnbZJtnFLRfWaGf76nXWsLG405MEYRm2GBb6OzY866iC + EInAcHbddcUUlSWml9Js7DYIYqanZvT8QzXV9hKLtVnvARDXNbkx5NWtm+sCm3SQfN8KDuA4hTQ1 + GLHQqhOXww+E1G0AEFNm5ariaiwlZHykecqDWLZ7arVQinrzIG2blDaPDERTcd5WELgJvT0UIVFm + OAPuNlLlB+sWPbAmFHshuhFU9trUoglwZhfI3cn4HmvDa7Kau6uT9RRqB4qX0lihMfY6zQvS5HUq + irA5NSjDtcWU46VxbvcuqWqNZiw2NqUAxKtWSsPeNQVGHmQ6uaXn3ITLspcr4JfYp17lYm0dS/Sj + Y+QjbG3dlCyGSPw5BmjP7Rl7Bo5STI090M5mUGK147nl5ljV1Ew/g9I0LaRjw2uDapSbne3s5T4k + t3jEdGrwxve59YlwIKKa9nZpIU7H5I8mbgHO6GNcsGr7QtekMQjcvL0uFehmHf0jZ+p2XbCqGoKs + brA1DE6sQ4OUFL0erGl3WuRSzJrONoLs9GJ7mGWUcWPt+NIqSNQ1+I/5o8XzToTpGWUrYdUKvFhF + TiJF7y6zP54QtV5nfupK9gQzEDdOMdega+YKnnLJ9s3eZ+AmbqLvsY5THdqS9yl25lYHQETlM5lN + F7JRyj+8BxIPd/0OcaibBehEjl+aoUOUUcyPMajC1f+FSizDxc0t53KQAkZH2yHZWvUCko6xDLIh + Yg+mznmWWvU93fSwjA8Bh9wu+gClbHRrPZUKHRim5ZvB8CJaq/Xrai3YcIJtEMtT8lzbjYddh6ki + 1TBTPC5JQxTi0ZXYfROpRrMBJkwHBf69yFQjFhroO6ZVA55TRuxExIhzCwiVvJ6+iT0STGSpI+2p + c2wVbrbCHewlRTaNTnPvWvk7uzWmdaX5IJwWh6E15VglYAnjYgPaKgPxIuaO57BJV4Cljqg/B+Jj + I5S5zYaDRdcQfPDE0Z0s05fVjhndy5vnAUDlb+xt4vJufYQI609QXBU9YtGswXp1NUnO0GNDfQkx + vihkFfJM5hmddtHst/71h2+0zLnW60fVjBqijceFHL8i+tIOtC5YYhkLFg7sFHh14POYLpSOhmeA + owrVD710XbG91OR1suUll1mOAFylh3c4oe5IwaEFSHNoS9fq+84qqk7yZD2SjBpeh+jbArnK69aF + bhUDIrYSedL869BErNCkvAOfgFygsGavgjA0s9J+HGNyunL0Dq5nXhmyxjdQBmXkGm2SqlwsOnbU + hSCHTJJ+Ka+z8I5YCYm71FylqDghlCBv2rwOChbOzcMSfSdiUbTOjll9eobJdch/tLPpubDSc4GZ + Eg8M0jd8Ip1OiOfVRToTKmDGviXn+ZVxYSD0IiZp914Ay45tOErskGQG1eZMntbD4LRzrf78R8S1 + WNtclJSXAYnShJ6V99jFtGh2nmGu+gpx2E0MZs83jmFgVoMNAOq4AsG46UoGha0T4jU5y2H/AVkp + bQQIzZnQaCxD+ssgheuAFjYlQ6vzslZpcYO2efDR436qrmpMZZ0cqgeVNRFwsJd2QdpEQ9vzEojV + YJvRRESRCikXCmjdCufUMcarVm0y6hl2LfjERFJC0O2BA4L6FrW3gcS9oebmJhqAXPAQjxR0sBa6 + DLPCmCA63pKZ4BnvGgTJw5zPQS2agYon0BfVVKn67Ww2NQXIjoTOinSIPCnJPh4XKzwtqbBeOy17 + tAnpyTXQbH7k1fhI6+/4IjqkZXJ7HWJNISvRDjKoUrpjxZ0EeHZXVTEKIV50mJ0pM/dFjBgSrCa4 + ABadXNTS55pv7Gl2c6OhF1lMJz/bG6jUZrILoGpNdZKdJ7Nt+5Kb69BT6hCt0yF0caOJQso4iLra + ddsKoKnYIwZZ5Qw6aLW+gwNSrWxbTJbaa96Y0xQVQbZoujExmYQa6h61zitdBGJa6XIo2pigIxml + 7QoYW/v1yaWhHYI9pL2ttrPixBXJYuiYXhqtdIWytRzeRPdWEysgx7VF1n1jn6aPYWf3Bh+GV+vl + rSeGm93hKd0IVTji1SDJqJEeW00vExkRvGA19WyW+PEYyVwHrSLVp2aPH4BOgklltxpOGaB9Xm9L + AtoiZYxu2rFSWBOvLFARYe8KmtiWZhYVjgvZq2La8h0mBlCNpoIrjNXttJwYcQm5MV/ulGFGjKkS + q4DerXIep7eBue3JmXo4W2ebX9ojKsirC3FFL1qrMBSJusjvEaZEdbsJjVKDw+4sxA4y21AgQobo + mgE7oujaYA2MIPaya33cgac3M2KwS+U4eYfGZaDlCpXW7G6ZPVYaEq+MqJih68anI/QEhvipBFnd + Xg5pL1W1ostpVrUTHQZCgxg3lhZuRyhIiG2MaXRGZHMH5wbB4a6Lty7npBGD78U09C13DsXQHfp4 + goqdJrUcHIvTePedDBQq0bhSNRUKNCHgIttkVKWNTWV5QlbeQTV65cbaMCB8a5/jwzJ1V4kcxiYq + IpaJm+LFObOn+UIZmMxiyyutzmjLmdkmWn5a2ABQ6AB1meQkAUi6dVjZKRkdBqo75SqsGWU3y1rF + RZ2u65qpektcXSHjzlHct+qbfDpoT++bAiqjJ3x3EFRiJ71YvBW3O9iNY8USFbpO/30fnd3kMHAZ + TRcUoTYr8TmsVJpMQxMEt3gi+YiqHez3lVi4s1ebkINZsbxvAonuWWjBbHUyzrbcFuuzQSB3cLe1 + pIAshaLKPeQqkaTZMz8QBiQVqV5en5LC0IKnlMsZ5jovroiBF1a4vtlrXD2/puhcuXZEhlFpSUjQ + beAtpPGFdkFyTnuEXhwqVuca3U3y6R0old2/tkDaqa05I5hhAUgaxwzHoKnYKXmrWC6Y6Vzpkdyx + vUuMhVyYGg05GzRSsG/IZryHh8gMz5hdVW2VNVdhbGyfOHvcjePm0h1jqTiZVJ/38MSnJiuH+cxX + gPGc1C1MkBn2zNM707UlDjNzIRiUrlHe9Hat+/o4ELX3GDmg5Hsz8YyCde7zILPbNVPo6VCNFJXm + tipmcon2wCuTrmd+FxwhfsltIGOmkRqGvcVszHeBUcJJxokVslvQbBnTH34WE05m72QEtu3mhVQP + JlnfAeq25N+hwuqoWJ/YFrlNyROp9RDLXk4jrI0Fm8beehQ72EA55m6eiLAs5csReLa3xSu2J8sa + MDQsN795B+ZOWRS5PFOldCjd9vSl7cZ6+tRri1prqC5QRNe8AwYvV4tjQO9XayylAVcrYd+x+XBy + ZsEOs8PhQnuzaA/IXRzFm7muJHpL6pgNA+N2y/nIRNjzwrKmhxu0Zwom6sx6jlqP8eTocZiXdYgM + sO9qlYhbjdxBWUqziQ1acnrStz0oiPPZdktM5IPiMbztvimofG2RSdGB6JzJNCRPL/2WPNfC4MLo + qzuKB+ReSXeRbtX0KpL7AM00WV0BYbB6uTkwxWThI2+P5RHtSyelnaAQPcUcfFbDSApUR6UJe+T0 + ROnR5oKMRqO5UJC0IGUZEui/MWpyJGIiFBVoFjcD1i2k5LsK69Alyx7rrY40xsnX9gHakW6EpufS + pLhiccNtHKIdVuXWlMRt1U3ktHezeiR22vSopjocxUdUu7dru5aVGXcnzBPRZqMdklZfs02xQ8Fx + jN1nTVfwiOcUu/Kee1x9FpQVlnLw8Z8CIPlt13ytwxhuIvWWCF/GtjI73K0oqfa0sg4ZTzAvjFWF + KwhYLe1UWqsloahTxViFJVu0uj96r6Jvt4Y3RSx3V2OsntFUwRZ7nVhpU7Vh5QupTpaTccZQTfMI + y1dwDruCI341qJyloGBMCOmNiu875uzS6usAWC9U3pF1bHMOqDfJWyAi4wvaulCfSd3O3PHwFSJP + U10zQQ9UHWvGxxmpi2d8Jg5xUbu1yJ4WlJzrnGKtk9UX1qHtWSQU8exVCecnKlBc4dEsbc9QJUq2 + Lx3GuZr2QVkd8rGTXVXTKww5wqWAQ7hW73oAmWbLv8pH3rB2BgWrXAKWkBlikbFeFENHHaF9dzxu + llXFM0K/T3MCRGRJa1fMbrWspesorQ6cvJspbsyMNc6ikKHL6iWKAmJbU2Satyg5Dbpb4kKOIeFf + f3g4SAZA9056duIpF832Cj6R5/yPPU1ZqwU1EF2/8WQL+Lrl3KEYVxjcRjyncXdG3Ja5KSyseR8X + /XMaaXty6aIaLkHyA76q56xQ9FYNI37NXhXXluApvdtwDMnalWnfPRTXxbUVWRiwta4LX9+6AtX/ + 4Vd85MHSX+f+4NGT4zloZt5W0ORxOzg+J8inbpzn67B4Ji/fBVSmYVk7VHIaiNZgzOCE4kN/A6+y + CdnIUmpiFv/fbmFqd1ce3dPuMG0QMeWiap3KuTzxBrrdy52zbREu05qLm2BnNcUguVAEvzFerKtx + zMgOf3OhUthEbcwOObBIxm6Wtrf0SjtgazLFNr2TaMS64YRjLtibLYCxpR4XsTfscXEUQAsGsvan + gLCXLpB7Fd0EX+5trV+cmIadTQulZJUqvKluAwWMGTZOmdTm6SHH0lkSeyRzJif0xAvbRjfT69wp + u618auMjQUBCo+tfa+xN5d4qjduoZLZt7I4NFm0NseAG/6PDFrYnYvRizXEuNp+ue3izdO5kWum+ + cEER2Mz+E4Nl+SGerabhMqva0d/i3I9WV7nF/AtyGBMSzImk0TyDE3m4b49R8L9yr6aYoqcDlbIx + O8ElarTZXQeOGYJKCjsqwBLb52K2g92xYQQac3esr2Fnb7jwS2JV6e0QFuXGVgGwjG8WKewo+Hf4 + qq6Ulklci9ItjofZ5bXc8NWwItcBdSW1E3I1E9SkdueVZk9c5i1xN0kOeMbhdiLxrokLV8FObVoR + Y26SNfEgOOVZqYYnK8FVutaXyB1s99QeoudAW5beGGaucjKwRwIFcVfMu7LWhHQn1uL3CnUhSUrO + q2e6zoRzxWnbYZvZTLCA0bu4VXI03JF8Fg2qsk0qZdy21SW1Tb4JGm8bMeO+46ydAJ5dT1XNZ6tm + mS1Pg+hYYOqDEHR0ikChZeT8NwUWpSxps25RBPwtwy0qOJQUkGiveWj7solaNLeCi8ywDSBYIvhP + HdFaj+XvHgbXme5tM0TDPno5mWMfsKc86VtsNpNUpqABWT3bvXQT5kZPsIgYjllaxVGQx7J2Z8dt + TMTj5D1WyU6qRuc4tIEuhfDHI/hODM/0QgEf33jPlm/qc8Uv+ylEWtPOrnU9Ihqy9hWmmIxFeGBW + 42aIyRIqBXwKsAdmlAUxt/3EoLeRnnjCntqtvqDV7SdBpyk6dwjcCoeT8eIU/Tm5cntOU9M+LW3R + ojnYD4LV/dcr3G/tcapzNtKx/SHkqpqTLalfruKfFvh+2yjC8PsPP45DoRdSdbvdjO8Noo3zWDyc + pbzmzO8gewdiQAzTJbKC3Jm7UllBAIsnwWi5u9AyU2EqobJ3xsqmcDprPTI8mlBkpYvbHdI3YBNB + 0n1Vn9ZJ0YzIe5a7SuU2s3HlhTsXS7NBoy+tuj2kx/N4Ldy8cHhaXnaltvyzril5lBeE2ehLxenL + 48MT8ppr7DVS2aF98DhPWd936P+LyK1tcNUxR3dQqmjr2ktIPAFOBU/rCCAueM2Oruhl30E8DKM5 + bywG2S6X+T/O1XH6NlbCrGkmW6mDcNIAL/p7UnM2ftVclCV8YTsS087FwyMs7qAPOtojr3i2x0hZ + gDESvEfookHHkXQTznVB/8JZP5LsEhQ4aqCMwTyC52tYjkbHF9XHGuAsNz0fV7o6jijczW6/tlDb + Nu5ka4MG7EzxOZoorwO218v1J63po+KW3eU0R01mH8/1MhENreDOetuiN83X79Dv+vLeKWBtJUXm + 4w7t3S1cDBvcuHgP5z1SQhO0wdHyiHheDAY47+DKn+WTo7L51sGXtZZbVArIitPnje6kdnwsih/u + dYXuzubkLEtz7AMPydbN4qLprdC/AGai1B2cpOwl/BAg9ebsYwimA/L9Ojhc9I+dsO6FT8H00zKr + P5ggXZ/OSCy7dZ/hlNpKRnSTAKTt0OE3VRRA4jlyvlg8nWwUMUoP2g2OTJq8Jy7zi2+N2dtJ790u + aQf0yHOrRaSNsEXYtL2wPYu8dKVzGMRYuSkygRaSw0mZdxxTFV12VMqLQ4XDyuOelvs+vBtxR31W + mlNOVdSA7O7zHn3mnqqRziQZjAQUFCLYjIfyk7NiF9AbeoIjO64OHyGu1PaT+qT6zl54fBxrngs0 + NbDk2WrvqooFGEHZmCQIYVHSOTN6Je6J5LHH0uIcB1C8w7J6J7db6O9kGsoa7yh+oJacmSOpSipj + l5q5NP7sqR2fzkMie2kbeElauQni7RM6phUk6L0N/ADHtryv5NKyaIdxE6guVkYBf1n3OsYlhdNM + LOBjg2f8IXsohEQYvW1sxHoHw28UZpohH5ESchlit+2I611TT/fMyRemIvA2cCO6TzsdCmm2zFgK + ciB+FgDn9HnttribIJSaToKkG3IuhRC6AC+co3Pz0j4fHyo/2KO2cBRLx2nooSdaPAlJLFDTpS+N + WpoG31nBEJ9Eg9lj1GCIUIVRS8w9mdSeo8HBODsqgw4U3OMKqeZ0wHmC4i1YrdkGbrlttc1g3HMB + cxlnaRmhrCHWYFKxN2hMW3hFjlKvCx2k5QltHkjyKQDMZpV2VL56GIvmVuU0qxbtutd9kNQT6Js+ + Z/PspPhIrnOXuBYkZAai7dEWKl7RsTprsmoNwXJOxweUB6+w1FMwPQkYtB2P4PW2/MKK4/mDNDbO + ilRfnw8ZWdII5lL+BJKDTxBe2RsF+Js7y3fyjafPvvmn/395PD77rRL+y8+/fvX1T8+3x/P963+9 + v/56CP/u9fOvPn8F9PoP/fYJv/z3Pz//9uvn2y+e8J+fv/3x68+/vf/1/dcfv/7lz+fbo03/5fP9 + 1/fPf7r0sy+Px/9f/v9iAAM= + headers: + CF-RAY: + - 9b1f9deed85a124d-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 12:28:05 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '53' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5958fbf6cd-vplbk + x-envoy-upstream-service-time: + - '333' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_4faadfadb3a444f99bd544f956ddd3c6 + status: + code: 200 + message: OK +- request: + body: '{"input":["post_2"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + cookie: + - __cf_bm=wq_HPeY5mJfbHED0yNdvSlRVFCqco70J_VhxVBbYzLA-1766406485-1.0.1.1-lCp6V4zT.5pc0goYufBfcYoLIqmA8Ch.Goo5dm7dSnzQM6gzMyXoRMuO8t_qyHdarkvgmD80Xnv.yyJglXv9tu5y.nkQMHvCY4c9Oi3MZy4; + _cfuvid=uCMia_CnuHX2H7BcxN7KG5QasPh5s8Dn34QLD0u3L4E-1766406485543-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DJgUxIjUpB4AjdDhc97+x5hVvo1KRW+mHn0aZfdokfuAoL5f1r+cCzEJDlx67rctoRFbKOOYQ37P + uXK9i/qhdxtNjVxXy022bGNRhQgQYmKyaZFKUdVIybf2sQYDDMN+qstG/e/vTq1KgSThVGZkNfdF + mf0NA4yxZUnkv/Xft8fj+cvn33/1xfvz4+P543d/vD8/eXs8nl9+9v7Z8+Pj07fH4/H47/fL3d// + 1U+ff/Xll9/9/M1HYsNP/Bf1v/b8+MC//sTGD6X9/4/H4/HCB/AGC+iTlcvgu0U9Qccg8BMoHQb1 + u+aGf/8H+ABh3Hd7idyltAAKDtAn9xQ91JAfQB3c5Az/AFuN5q6EaszSzKxsiJoa/T5mKl2UcoKn + Qk8WNkhFp4jdrruox50C7DXmV5e7NLYgwtt5zLNEy/inQl/IXjgHYp2psSNoudhCTgHHsXv/P4dW + mF09kdGyLydGcrpbtxOuvrmqFSNQkMvEltGuAI1S94VZ7XSrdkozqkpWvMazTjs8wQ2YSA9Lxilo + DuGqBoairC+BjMVuRlZfj2+dwHmvNCuU6BvBv1ESYuPmn7IabfcDT6GcbcA9oVnliGbELNkqM2bb + HEXAFea0m4krMz8nEVCO3cMdei9ETgFds9VHBrrpPlM+CR6764jcA0s01WRV6zcwuu2+jNM4VhV8 + 86jWPGrIqJ6u+QPMhDY8Q3f33SOxywDS3SnEJdH+/5jL2aXsFU42Mzj0rkMAH4oVkg9tbm4vVdd1 + 0Thoj5j2R08JCWhUN3NMCCcQ1q75zbBrseIECdO2jz2JM6fzEqZmnExzwuImN1Koaq8lx3m8M7nj + DyQqw9ixHaq8xno80o3Jt2QbB54xa8el9A4HwXdRaxa+hbgBdQYfEBnaiyTUrTdp3bHYVoGx51RO + v1YqrsMCcYtTKZj6iFNCRFAGvAFkcoOotcqVMMApcHVmnOCUdFcorsjDzcVAIhnIptw7RwHjSlco + wQzElto0bodsh4XQVpfChF3CnRMhz9QyNCEpmw6PJCws4yREr3vDk8aeTMmGy8Nmv71xUkNhWzgG + ney4YMwDqS8XR1EoLhinKrqcq1VMOSUQbKEum9ErVcArNhkwFzG0Nn2ZADI1EGIiSE/vadFxNLCl + 2g5DrEpP7gGrt8BC4zq5illIlprRsOH5XNQiv3j0EdnwkuoTtpiuKShGEVlM3AMGjjryXI2xtZaw + nctVk42b2x4T/r248VnCnlllM+Qak1QEcdOrBgPCvLqr2cOeD1ZcMiqfBMvd6YaCccY1s5/05oSz + IqTBqx9kE5rct8XcBPRGgMlqBzBZL2u1gCAH7FEsaybpCDIruPWCmFtuN2CXZFoEUqOMuQDtKzFt + 4B5vqkYxbvPq9ICsOymjcu96eCtyuiZLIbc6g+MYutqeEPkSsEppWexKW86JEN4dlasALIuY9OOI + 3kmUTEq3WmehoapYeJ5SGAjBdHuztXDLk8tCe5zubjuu3XIDDNOedhr7ETF1MgNT916g8SnAl5pr + a04hKS6mZFX9JvLM9sRD7s+nX/jQnVxZUpvJ88uWjAK9M4NMHMKk/KBgID0LcjDrWMKcIAtY4fTV + bThCF31qSylsDzrMTyFi3c3tIIFSYDOTRz7WS0q2mgkzhFv4egGP3lPJP8Ae9ICG2wYXSzRzjPvg + 496Da5DnslpZyI8Gm0LVTgGhE9Sxe0UgsbtOB4yxWRUXU33YZKvaaNjGUJ0dXY+LbZ6hRm0nYbu0 + ihpECbQRXVqZeg91VJOistxxN9YMV6v0cSWy0wBDwVgxLgKjIVfa44q+EapPJdiKsOxpIgbDQQ/H + dxJoRG0c8DnC4l2iXo+Y2/tNr8xLEVyK7RxkRF2TdhlPreH7HTWvzYrLEuq02N7DLE8KO5XV7TrN + U0a1N5vTGQbhdiq9HMPEO5ZBkdlgGxoozqXYCsiRKJMdYDq71OHQZPfnFV01NAVrRdHldV/tBddX + JRdUTTdFiCXL4QJxIY7sUbdd3rLVdVDhQuz4Ko3MAUB9R3AitboqbyMFCgIe4vZ6GZ1TwE4re+It + ejUwMu5LXW7s9RDXU2aKAhpqCaknMAFnPd6Pc8dbSl1VmWfw3fnIX8QDZkoaItJbtCGm0zeZxNai + UxJdoO6k9xDwZFq3wE+a2ItvOl5W7/5R46ov9zRLExxTEzjJygF6smFaHIyZs1kiqrpBWBC8V85U + pywLr13DTjrISHD5kZE+2JFkrawYPK69StPlFh3TUIhLpUQhEkh6V4yAF+rYHs5pW3JPjljAqsBM + sWsLX+9WmAu511KUKhpu482l6FUID2toYsqiEIWpXqYZtxLzQaHcp0YQMYuzUGHLrjYHEJ+wmapi + FpCkbqICiOnUHcP1qgiZt9zD4Og4HLtZVbxi1TMbEDEGSgcODpfxbOXKvqDENFZX4hEgRx025k9i + MQcsC7rOHZAYZJ25bwpu9wrdQvadugnFRt+y2slTp4w8IwuZUmVszukBid2xyElDMR4B9w7XQ9ZV + 6xRb9iXdargZ9FThRN+G1G1GyZDm4jqsbV+vOAGgzhIiMxWXXf54EhALAw4TtlNxIoJUMpfzdnQc + 1VM5ig2EZXmhi5s+LRlQMzKe5vRoFqrZMznrAKrbmJl0NMJ3ii6WAkG3oCUsciGqg9qQlbkhmpue + GFI6WVMTBRdJtFNIq3c2LDzqxsxBBd8YodVk7GDRRVOLWJJsEtK7Wt1xQl4kYh3IuU4GMli7vZuL + xyOCaCzqYi4XVd9OiMxoWpbYiHmrVs+INWwmF+WiCMGu2YG4rTI2B5Bpjmf9BjE5VidWE98MM2Vm + t1RNM8EQm7TYH8bhqW87o73nzpi+Ode0Kbzt1a3IyvjdBSzh0qfgulu6hAyzPTf2NugGUQun5uQI + usPbAYxFt0OmYneurx8+idptc+1uAwO62BKab2boqhyMwVRXcbpo9xrzsgPobh9i6jHAMXrs20LC + oaJ8gKXsWzuUY1emp+aoSXH7351FgfXAOg2wWTt0NlNmyz1g9GfZk5txQfUQ261up66O5Xz95T+B + njWWPWBycev6okGgKWW7eKm+KxsISJ8D2J9XJsfepR6bqXPYgnuuMHO3iW8zZYWEKi5NTFBPqaF2 + K9W/nATOjYs7HyjvTJ1DNpr4XXt5HoLRZWoUJLUAqsdMqIPZbuiqKR+CtJsFS1UVKb2nmp6uXd1Y + Ln6Kd+7uXtnsnG2cD74i32Q2o1WL9XxgR50aksvVtRPq0HAVSxSk9nD773AW74Xp7JHpdRIOBcbT + OhKCXkRxzgWNXCpl1m66wy5XNZEFNCMLoY7vfbMOUNPxdh1U9TWHrW67kMfZXc5ecAHWajolYv9A + qCQebHgS3FlknvCYjQgMNma7N0tQ3AHc1JUMt3pCqEQRGVN0inHlAdb21M1gM7S3uzWWWl6xsMhE + yS9YtlmmA4ZSidYksbqvyx9heeso7g+RNvLQ7fUMC6dwyWTsDQj2azFE8jhodna8Espy4GZPd+oo + 1KNisr8gE4qO5vFLcpme6+jWblVGvAyaasD6+o7LQOiZUJLscBd6WbhItlhM4o4DV90WciyajPHU + JhqB3dBKR+hrIqHBKnosnexphf7WrMW6EWBuNJamijk+DW3gel2pAI/Qur3127W4V/bsDT3hqWbz + PioRw0bpdaDVvAtEKbmMVOSzdj9p1DwyxDQhKht5u7bQNia2WUfPoqxFB3ZZkJUACpXgnUutmsdA + upD3HSFxvUOCMro22NtNscBlBWhr4477CZ5N59rJyx46ywd5z81FuBsTPLgccMVr12NwzKnNFTJX + FCBdZ5k5sQp3KRZeXoV1kbfqyKdkFG00WlStmB/kndo6eRjXXBKO2LwriiJ6SHA8kNMoYyFEaG/L + OxK6q5ynV8Z/m20DytM9a7hzZZpyimzf2tydm1xbkFVmGcvenIYJ0eieyuCpzrCFmBtM2P/B5PTC + 4JIlbu0cxEwEoldbV5O0lnNGbW9D3oRC4Y9728vZMzisjymuXKHikt5QH93+7Ip2jdXdpMdGhaIx + /2CVZbQMyKD1dgEca99WYupw5E8gLebD8OzQ4hFiqi+HyqEceVIA1LC8yA0a6SvgeQASWilXztSq + fHZ1rapjb+bivrNo37V1O9SghI0cNMXWXAyO++GARyxmhSGyRj+I3evANi3Y5g1bM7NKEsK5PAAN + EnOjA4FxSTdPX9Az8cSSzChkllwkq3CMlWARvC1urqzIZZixm94RMVySHe69tnB0KOIWdVX+4Gdc + SWcv16BSlcCXA8kyM9xiGe65TWJf86rHOgjHofRmZYzAWHKKiVreseDYFq3WHjFqXWX4IvQY2c9L + 07lHMu2F8ljtsa+5gh41/lLmCmpYt6mJD2jOxoYB1DXT01haKgeydgdVVZYdpvKWEWCQ0A147B6H + bi0HIrbaQyV58zazbv5qncOH3fQ1haGz7JNalRfGSjvqMormPp4C+kLPebCzSp8SrG6flTTbQhfF + Zrfg4EyIXg7Mz3Vv2SG6QVyvyvWAXbW1uAM5rQaChqG6pwzBLKZ78qfof2LterLsGUXu6uUdpXbU + AnquRS+r2prMm1CciZNGgJS5mle+1W2fzelNmOHzexYxtZ4zx7cQPRpoxVZ3a08YpOrmngzJhStW + 4JmacaJkDehzpG45j8QPEuXylkoEzd25EkLRkq8+mKemJU8iR1HkgYpDj/qsKw3pwmtaFaJYd+pY + Ohx9ybvk4IbLuottbFb86BhxuDWokZZIugx1qVxmwjLkbgLtpMG+XQ/Rb7kWNDhtXl9u8h7enh57 + LA+tViCl6LuHDs4PoWCnXkQHYu8oyJDbnUmZFIxv54NeGX93EihQEW7bPS+523PcAwFRx2v1UBgJ + VUWqdkJfMTMg2R13GG3sSFK5fb+F7bn1+MNik97WEY02Iblrt+0nAS9b6+WBGq/KBSwmHAmog49v + wTdStdkDUs4secFU3VN9Qa9VtjqEiVmTcw9hlIEnGnJYLgPpiP0sGTPoRm3FHrHojAKNcz1jZWzn + pouuI+kQwrJtCVsNXr/pfTzj3aJC78WhEbaayvTY4mheJ9FEo7CKv/gqh1gMNpL9sjkyUwtTHfMi + PWNiJaFeA/GOMTWPS3lUsx5u8SQrehkiF2v5oxiM/CBohjcbCl4nNQl3B+WDwAVNH5+95JihelaO + EEusBcKLYGzQY4jeXFeMu8aVQRoguu1sMZ1Xazm3w12Qz8lFhOMCb68NtXucY6PzxqgtMqqj1oJJ + qA42WJW6JkY6Tp7TYmUKRILP1xdBoeaGRy3cMO2Fj1OahdIXLmy5GOouWzsr6h7iLr392mur7FEU + VlHyfT/BGHUsXCo1wWuKdhQdxb87eBOaHJeVzWV79rhOnSMyfgjP23MTjFxVo36Vo6duF57cmey6 + pAdw/HXt3VoSm5OQwqYIxJV4KISmgCXZH3syMnvoBx140uvMuyPWoj3xVdTtTZ9xJB2G4+FAGmTX + NRony77UR7d9s+7SIG73psfy7gz9osP0JSmK6hSjkVfiYOW4a2SBBkFi1sZVa4DQFaHSbVndxq4B + JJBa8G7YT6UOwFvPlePOcuM21k80hmcuJy8dLs8XPoO4stZzc1ewuOj5vY28ocOshuT8vDevynVz + BJruicBZClZXWMDJyRzflG9gLwYmkxCDEotbRWE0Pe6FtKHw6zuaUk1kaYpH/d9RDN9xzc8gzDQU + pK/CmXCS4rq4K6s6AW1P4N+W5iqu5aZjytYKlRMcIt4eytHML6FXnqqXV4pB9/a09q6JLUjNxdYw + nCWRZnFaCVoevbr/IhFTRmkLAlG1c5b8W6nOztai8Dot5b78vWXYQj8Q28qRp+GyneOvT8FNbBia + ORJvItNw2n9OY49CX2GU119sTQu32k9mg4X+DdWOcEUDP8pQreleK+1inqhjWmGSGpx2ch6lW5Cx + svA8OMe4U0eS+tHVlgUnc4GuOwKHIdU3bC8w04Lqkh1czcCnp5YSR3cw2uV05d31WBaS4TmagyG3 + qONOIa3pHa4Ec7OjumLllrVRz0bOJ4eoylyWpMzMRGJjT2Fy3hlQj1uCex8G35iFQdX1ctqMlWEC + Qtw1r8Bz2BHT2ty0GScdPdc7Oz3v/45z677HcreBzJcAFyj7GUr2+fCBotZpj5wLy7/wCndLl2YG + lLd7ezeySxPtsITiqowH7vI/i6VcqO1zxRgsTwgRBZLuPUi0aOnHMOR13xYtU7RBT1xK2hhyhmtA + R4OQgfWBWFtX18ZX3DmqCAmqKRwBkU3PDXFLcu5UUkOlTkTL9qxyiqJdqtksvpLC40sdd6B587Yl + nIubs+MZiHtDeiZMPD1S8FzTmcOfo3fpFvD4ca8qmnd0pTqYFHdbU7bpIufYIVg16BDN9aGqEHvl + bmCXyvXKQZKiz1t2cNDyGahFRK12V9aaxNCCj7s6A71u+DvZd7tdt3Ywxtae+icr6PP7GIxtChgx + U05d3FyupJAzHRrpUjAz4dHkmPXIlrGJMeSNpEIA0zODEm0HcwhzhQOadIdCm0qmJAx8avEo6OXA + Zqv4ZEU0jN+qb5tUZAtUUH1Y+7RHldfWjVmgjZc+VrWC49RsMdfoqEY0syffQcC1rAcnR2LqxwFE + 0RhyswUiYA4WVtmW60wQ9jJlj1K4M4cag9wVHb4wiEnZOEIa6zUZm6TEyBcYhtN927/sjmFzbxuv + thRSwK6PsRtVDsSt7OOFZnxGQ6aobNyonNQsXG2QoLlOebxbDD1BBy0rBwrPxdfB9jj65KU9Gjtd + 7ImXtYJJe0As4jayG4wt3A7FJvD7KbMjQ1hfLA8rdooaEZNG5HrPGLIGrgvOXCLbksGxM+BuIW6I + cSB7UtuHLvgYbTuU3fm6Q6lybvAHxtWo6sz1os15MFibvfG2khpX56nlUb21Q5B1aJFw6qQrPyCi + AhpLRWCfCNqnM1O7Bk8EsGbT3nccZOqHLiyeIbtMmngdosKeyJQL5Fpoq4gH4eg4LxEoUq0Pu18j + bCOQECfMOyNPo2h88dr1uYA4XFf3pD1qup2UbMFpiPkD56js0bzGBaRshwUZvLnxHsGngKkkuy/V + g1gQPp7sOd0L7NFDQZ4evDliUdFPfhOgA7s7BemjvCnHgw+MTtMNZhP18EqLk7Q1mFMGaZzwqddm + 7NvCoueNr25yOuQPPj5D967IBoY5GYthShSNnuWM0s3GjB1rjWxPjmRRa/XgFfPZawEtK7JpUdqL + YUM7VnO7dRhWV7uNQytX/rynLuqfeK9YcKdTlYLtae6RWsYga8bpEGNv++7T45u0n8bbdlwZVIo3 + EFDMcLOywA4jnMLMKT6+7PU/Kf1iMIIqzYmdqXBdOsyGrbfvFIgrF2PCmDvi+qHVpLIVmtkdg4tw + lRvCwyWXx4CnvDEvP83RVepGJmSLzTeUltq38o66lMvmzf1wSVGnackQZIQasKIoXto3l+4nSAy2 + u91UV2rNp9UUe2QQ22mjJasYG8JtWbdru9T2QYX8ccwQmuKJAYX42q1e1sIrTqLdNS9GbXdbPvrU + 9GYbbpSaF9FxkBtwXQ14dp8Ik7XtEtIpCOSlcUV3R8p0G/fS2MrMlNwuRm2VJXU6RznM2QI7bNN0 + y7MxQEyVIXwmPJ4LqyjIRAYVAfNC4XaiOyoC4xbXnhZ0vPa3GKvQaxt8udOR3InOFFOLHsd8Kw6z + FVbogLJ0LNMgdzB1bha+enFAeFMzQJmuNvAs6ZLPKMnFwcSQqWOnVM7ypjdRGaO0LDo81dK52WVp + xYUYHeW364epucPALsz1y8PW7prjEgqiPKLWHiYQWyvwJCHoWw84zGDzDu6zLrTX5FvSu0dizWrH + pgOovqLOBFnCFVcJUXe4CI6FuiDdrNx0oPd2lBnnLJfYoXONdcaSyeVtrlhDpVDOlY76W3fZYTuI + iOMjsy/L2oNpRUCqaeFZ8D7a65Fe4FC7Pa6gpv8CkfHWiVpKjKTvWCgglZbdy4ZkyDEDLvffAaDS + KmqgRtdTyOb01obTL/f4ZTOTR/kXwhlOOGDZbqd5XwIiPVa2Wh0mjFO1eXOQw6kplbw+0sR7ocMg + 1nEOhYxR9fSCOYFsXxkg76lmuduHyokeyzS74nXEIbPCK5O4WjYku7qbiznPIgKLdzs1h/bchaNv + h7LaOh4R6K4UFmJvCtlqBw9mTJYXqL3jOrZ57KpWwdJ7JP1y9EVED6WqSqCaPvIP7qw60I08lU0s + e7AUpOSqF9ynFHmr2GUjpykGb9fT2NPpz6+FaMMYqtuMAGtzo16YVx3WXj1e/l8WOSNGrV1tiQKH + snSX7RZyz9UMXtg5gucBVNele3znOHUVlF40elJFtGnJxTgDXIpietnXwXbuHXU/zwIkvamaAEm0 + L5BNuWgkfxQGtBdXrNU+PDvObZUapfDaMhKeA3LY0698zof8/OvzKnvqVvfo+v0Yuq1id67DavFk + B6I77R7cAlc2F31VSevu7khqPz9b9qJFrOUqCyDbzAV67bkNQrdH8KKevk5jQvWdTKGX4+W274RX + B6PVfAXLmU7OEUhN7l+jhRR0XKpXLEfwzQhvoBVyzZ3F7Lu52L4y3JOMYtTuLgjsNeZKuPwapJgx + He455dS9WaGpI0HE5FpVLbU2p4GOevjULETJ+5/tUVgqPHt9+1jyE6gsgTwTLtTkYsrGtQb4CGoE + To9bw7XS5DuabUpNfp9RQ/vfsTDi6dEs35F51ja5hWGL5JWTJqyaUZ90xVEdP9G4g31X5VYYsU4O + 6iQ3y51yHvpmp+gnVlPC9EIMewgfQ1yup7TqAMZ18RoThr4xUrgjolXDiL9QOrk67v3rcF/uOcnq + 5LQ+j/P7Otp2HIYdQjukZwes1HVgSnUV8T9UKGwZwp6xVipk33CncXsJae3aYaOeUBSWG1dshNX1 + sqsht4O6gQHNDi8H7OM19lzex87MtFxr2OejIZxT5lAM1sjLB8BF3gQZzrENtGN0mDHrqZM2tLhl + 4W3wlM6vtGgTuRagcLPl45nUI3sHW712VFM7rJw4c/7SuO11YDWZXYeCeBg80/kUaa7KWZZZoaOO + NR8W687YoPHORkoV+cHStlIQgTM1XcKiEdNg0Ewm2L74FSXyT4O5A6xq2vTE25hSYK/0C6qFPK+r + 6tDm1E0LsntWW1SXJwHCzs67iFlxNm++U5JoelOxlbIH08nMgtUdsqtEJEjnQN605FWINTndRex1 + GxCI5E0a0cJQqcH862CuWaMVir72LihYVp5OAz9MG3O/KKtZT4tjx+67KN9xPVxHnb21Ep50ESTf + 31Q9EM8mg4pCLHQuqZFWfo1NhM6dtRvweJlAQO2qLvhCM7elPc87hS2/q1QmhRtFfFw2FPXLVr5S + YtKi/7i416NAtAQ/Bsdo4tUkOlq6mfSozNzB1XUJm9+p6bksROJtIMulq6Y1VvCNKdF0SGrNfwdY + nKm3TF/OmNOOql0aGj2TFoFCEyGD0rhOSPYz0PeDZpKTySTstDMktVXkzB0y9u19B2q9WCyqsnou + auaYXXkq7Kcx4kgDM7yZKSuEVC3YLs+JjpGcxTHsOny8VxTee3AA0ZhkYk01mV2MpI0rz3KtYMyu + d92a520dl21bLH3ZW4w8M20T0zuzyzsobc8MjbU7BJua3GOieWLI+yYL9k3sO0+O5oo673gLm8cF + DdIjnYEtdPzCKX5L2Tdjta/TcJDVFTLfATohD+O03Iqx3ZnedT+T2xxNdcetn9bp0+vQcRTJ6Dpe + w9RmWGkUCU7MIxR7x536iSa1+QHzanPwv7dPZM0Ppj9/4Fv/f3s8/vyHIfyHn3758qsfnx8fz/ev + /vX++gsP/tXrsy8/ewF6/UN/QML3/v2Pz7756vnxb0f4989ff//lp1/f//r+yw9f/fzH8+NjSf7s + 8/2X989+/NG3vz0e/3/7/5sBAw== + headers: + CF-RAY: + - 9b1f9df70c4c124d-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 12:28:05 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '32' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5958fbf6cd-p79zk + x-envoy-upstream-service-time: + - '51' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_5534f502b60c4b7e96db1d01b8a9e750 + status: + code: 200 + message: OK +- request: + body: '{"input":["post_3"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + cookie: + - __cf_bm=wq_HPeY5mJfbHED0yNdvSlRVFCqco70J_VhxVBbYzLA-1766406485-1.0.1.1-lCp6V4zT.5pc0goYufBfcYoLIqmA8Ch.Goo5dm7dSnzQM6gzMyXoRMuO8t_qyHdarkvgmD80Xnv.yyJglXv9tu5y.nkQMHvCY4c9Oi3MZy4; + _cfuvid=uCMia_CnuHX2H7BcxN7KG5QasPh5s8Dn34QLD0u3L4E-1766406485543-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DCAWREQ1qwdAETLMbcVYUj5Gba2+pBqmB6LsPR1yHgj+/39an4Dxz6Zg0/v6E8EaVnCCE0vI+V45 + qdtJg/oVqiOnOnKqLce3lpmplwkwYsNsslpY01/hIEQnw9a0llFWan+bb+x4MIY+JTH/q/++PB7P + Xz7//qsvPp7vj+eP3/3x8fzk5fF4fvnZx2fP98enL4/H4/Hfz98/+5u/+unzr7788rufv3lJTPie + /6L+F57vD/zq90x8v9r//3g8Hq94A5sDuz8ZGUH1aNb1cUBHeIovGCKqtpgPvztF99qfE97AqV3o + x4CN9GLWoGgWtoeYmKIjBsFw0rPjANoX7A0c0O1tL4IQONLFgNCxy2t/sG93px5zWKUVgkjSbi3L + iKW7VmDw+trTURW2a4SId9ezHeRozI8Qw66z5GP2btesQVDXWp5hEFCwwyG43lzZHKiywEcmpKcg + LyHPvMx2VcdVwhOMwxY0CFcrrKPJDc+IkKtmWXyQmJn1zn9X8YB/iFGBWkHCPA+ne8gBBladxuuo + LA6x4WmVbp7HwENyzOKQuoHDDLj3JhqmaCeDVZCGxfykVPeWzfkE7iE3hrqqm6MADUqliwGi+vZu + Q6vMxfRDSCsqf0M3rex0dB0HazzBGy2WcKGLhTCcO2alI2AjcPBYKYuMYNOedn5id9atMcoB41Fu + GX33UaVlawL3aiuinsAqZlHQ1mgynSn2ZTdmY1NZwvay1o9YLOwmLT9gRVYK/xzxBl4w0QfIzGHM + iHY6dSdDe66mwRinK5k17oOBvkeq1QtOfJSRB0T31YGdoG4TUhx3QR0ggsXOBm4WpmL+JSoi5Mx+ + Xlh26TIPwx2Q8W1SPCIaQEzf3X5UuV7ho+0DJg7tNBUjnGKsVE2sWu8pkVKluoo4ONyqe6d0OX2f + lmw27ZpbPXDAmuKgBdh1Zttb9vYVRdSe4WpmAEl19foBdquDVTDUdVMpwHk3ds778tyWmqhgp2Cy + oJFyuKnsg5Cqd0o/aAephBKEeEq9PL1yBayb2pIcjqXtAoZQ3kA7BiWWxoqiGCZ3WGI/Y+FISutV + 06jLqDbqGmHIdO368gNuDlu6wmhoCrVOPEQbiBs4yDFvPBwq7gThUkzZtSqHFgtMs94pMcZAru7O + ayAujYLDRfJ+XqQ32x9Yp1IzA2iEM5SDqLFWDYwpJYl8N10Awh7QxS5pQBWnwQPDuA+W4IjqMFzj + 9rmufRauZZZAuIYt2RgADzqxJIW8uqqfkBUCiYIy6PQ5HlGlXQUGB3GupEc+Ge/FGLF3J5LjSSiK + zlHXrcUN7U4CZYAJrwSDoHGdjj7HHYyNGC/n6mzpKV/7DcfWHGrkbQAY0KqYxOY8grGI2bacl9tK + +YPAVXSrYLca2vuRSewBdevFQLtQIRAkt4NtBjP4Iq/ApFyBuPdMecP3C+F8zqYUi4oWCHj5ajwJ + CbtKBzWIDMm5+ba2bpGAxpTsaEvExo49LILOblmSew7jDS5XqujtLhYwDL3irTN9aZYB216XW4Tz + 0r7JoE4wZgVJgT6qLRQXAkC276oR4UjdHSs7zIgnID6jMy2itgGhVasEIp6ddox7Akr9ioVrIIZw + qQbmxVgH7HB+WZ2fmrSyRhJiCN46aaIea67cDTfkentc5pTFYCuww8LKMYDVrbirQFfvJc/eEzPg + cmIkb3Oaka22jqb3dx7Fsmt4u4+n6L6rKiLsam6LMYbQrjrDs8jtpZvDKbWVU1FV56w1Xw6N26yn + 4txxG7sRWpz43czcdTjhF6IDmSqpJGoIlm0dcf5+F5o919l0/wBdM0mBH8RM6zBrXNEWEpFcVgsW + vMD3QZnQDVKD7i4ek5M970fuYw8amqTfNNUqutyYwxKvGqBZYTMgAAntQwXmgGu7OTlf2AQFbKD7 + YhoutleZ7coMoRMT+trUwxBhdQ9HnKeL2I2hqyJ2QZCqOJogVwR4sy3pHD+DMkqwm8caUi/YCTm6 + YSyVz9LSHHezTsswR+vg9wi8HID1CiRMz/k4QVftXA9EUYWSrQY5W9dZ9OKA/Urmo2sibqbrMIUY + 7l3ZYtIZnf2KstmczHOzhCfRMyX7odvqbbJxg9ljDgh8MTpMINvpWMhqDCE8lIYnPn5P4UK6x7eu + dlAP1E7uiiaUmdtUDam5cTwxTPXpYuQ9+5PENOGVc/QlzBkziFzSGNYZyqpMG9ijBdKhcDeIZuTR + tTOiNAHYDAXI5CMR4t0L0AkCLDdJc7MzZcOQwfKIY2kg4W5Y8Qic6m6MaWPTmRaJU1yKAVZ6rxp/ + Bl2yhRqQzN1i4BhmNET2gVLr9pok+tgl0IoziANMXc0Qm0fAo4yiXRLRiAbPrQJUOjyi5dpQuMUy + 1NDA3uItBi9KQ8SDMqzEjGj13WyoRo/rzQF45KNlQE9ZtfRDuKsvqYXW0LDpYHZI31nneKBWnEiJ + HdHhxHa/A+zNrI1gLtrJl4gHtGK9gNdNaD9bPoauBg/etBehZwTES68oY8Yx4hbJqna6l8jvU8MW + U/VTixqRdRW8/AhSULkDCkgk2W2QAFGLiBHFGJHVDl3ZNfE3hT9Op9thb2qOcw1ycSiwjeuDWPnE + O2QJd0YdnXudWlSFrRRkH4jaVvKbpUWVc+xS7uhAyhmVs0g/mxQPcdvr+PHDzJTz2+2yOwcHI5dp + tgUVhlIDLxEMqLK9I9YChgO4cjvETml4nSqNxslM83CosIBZLRjsajN4BoZ14BMHYwAQXYGqtWyX + ZB6AYaIkySPQpQmzHEhFV3OoWid0byKHGHS1KS6kr7iS6SgU3AQs5AjMIezquKFTA1OYKrUgbzee + JnEQJlqe+gQz1bdXlDZZE+vdSzu+zQy/3ehBGx5yd8Z3f2cR46fztVqh+CBbtGuUX3HrYQa73BTL + CFm73ewlkYqBcegh1uDqTkxWqeijj4Di1VwiXmSFtHmCNn3U24PiuE1LNU0oqzVgy9k0KRSacELI + UJ5FewQpXJSGraQMjkJ0OyItEN1aXCld7LobS2b7XJGAaYd2193wL1ffU4V9OiPV0lcBDR/CWqwu + SWo92xnUCdErCebuqL48ewWooNtZ4lmjWKPfPKLOk9WJBkpceielGB0UN6Cw+4oeAyHUab+cA43S + YgeKgN0GTdEFWpu79cACmOPI5DT8XBDccmPCQ2J83m1xWjV5kNIBGUk1OfqmqKVKrLalys4xD8Hz + Xp8dFdfPCfUkg0xuHtcKvmOVq5z8bO1DD9H0sQuMp/sWVfgaDmMHtzG2kETdGSTLPh1k7DZTKO3G + 2PSNO1o2MGU7i7U1DpTPNjUeAvRsn4L4CsvSoQ9sFSGtC7u45xELbsWjBORGsDkcmJnKBoWMhgkN + pLLnZxhCWkDoQHN6Brajo1UihHk7d2XePPNsZkvewhYKam6kFGAIcUzqih/4uhXFUVjeRJ9MGp7v + Z9pExn7Aqqnr4og7VRzMeNm7obIcbQc4FK71XUGOu9GV+Ry3B1we0l7b7kzt4MDO3LLSCLGqW7iT + m9M0elG7G+jLC3jdysW55FDjejThmjsVOiF0NClVMtV11Xw2qEGSnBgyp96dMgw0dpgIpdq/FOLR + 83oyM6lmneYS1LJ7bTVQT+jqNEGlajAzWBqDiGG/PXK7DVWUm7wTse6y2wSy3Okos7KqsU9QE9t2 + 2pQ3WNRjIJRWRT0Y19cVLvs22+FYeJ30/TC6bUWaG90s4LSqmjJYDUiU73XkG9xYQkRjPXW5e3NX + E9EeYic3RAkgCkt5XojqdWwxVJ2zdVHbk0lpFwk+XttbUAVEQRuaXvKgPJgbA0ADr0ql6I3C7uNA + PG/magAUGAzXczkNWTMBRd50FQJa7VljgUpcuCttfcxGFHmoF+8WNZ/ULFhUg6VsDs0E+sRq7+pT + CKnGdcXNWl1KIaAONWnj+dVAGwJW9faOAmu6tEhrp7pOebZuEniiBw1WzFRv2qYeTjw9DL1K99KD + UM3es71VNIjeCXe3fYfgmYK9eCG5jUNoIinlG7LXZFiagEimL7aBvqmkoOUNzX45iKpyf067mowp + tVs1HW1A1kTOBQqUa4QPkhJieSmpnCGc3PKWgq6uCmIRfMLWwq3T6FB+Q7KC66nWbbbzMJSSUNrR + 91yj00GI2r4JML1MCLk0A5AqPej6Z1HCaBvdFX3ruTG76C2LnhlKShqMa2ro+UqQKcOizh3MQyMY + B9553Slchts7Zxq8bo7jrdvXkLC9PSu7EAZPA8WiKhTeEU8bsPY2U7c7E8SG5MK9FB18PPqI+qZu + DtFMbTZxgeCoAO3QxZiBYDWbMT1e5VrcDOa4amIiu8qgJ6T3TGfjNMOiCUFx6Wo42INsl78hCMwf + O9lVcc2L1Tff1BsgMwt9Y/DIL6D508IpedttJhnKQWTkusqxSHYwRtEdJOdqZO5OaYO+wYuQ3pDm + 1YwLsvqCzoBlhkrzkXI9aGMipbv133N8bBuELl1wwxfsrOXkyo44WzQlr22O0dAhUW/TLO9O3IB7 + w+qCW/B+Kfa2Mee3lXIeFo8ua1sPNNqaoUWYPM0a/4EHMaOK5VF72xE7Y0qZ2UzC2rpuwAimD+Ne + CJy0vI6t7sVY7UCxeu1BKQJIqHjYo2dTIYyMW5vfopZVTCzT4QuZgmzyxre4WTpQW0zdJnH8Dwy2 + e4s2g7aWQz8gdZSeF8hQNWQkW2MA3ONuOg7CoJW+rW5usKDOsm8lRWHwaPYhpLV100XKE5VYXBDl + XOXXF7V5m9kV62vumoPq3KhXHHzYIuHDrGjzBxu5XpRsitGN+wehgqOb475PJE3LGrmqUVDAnl+l + 19u4thmQMgxLTcLfBD5oXpJDpLaVznJ0t9svCBVhLp1E49Qwn4XMrDvGQozjw+xZrDFJCNIudA5+ + zxyiUhDwlNQXYu4cDTPyezLu11JPzQSRt0sS7RGwWO62i9xxSuHQZY5ak+5atYhljgmCiwhKjtmF + 3G+U3H4GKh6rHXPOyOkmNhKD08tqHVBgQDcIwBkb8muLCvWLQIdFmipvOyGgS4YJViGRY68RiNXC + 9VZsDGbjCgpM3eA5bpRFSQ6G3LOn3nF0LO6+7SFVrfn/Xk3NAnRVo8x+TX6A1BxYqyTQKcXJEaoR + Eqw9ud93TYYddN32SWp3dNEuyu977o+cA6FVfVd8ttyEW0ioz+1zyFjRU6BN2JUYxCqPeNoTCrY5 + /zvc5BJqXzMoXRewCYrJ/c8klsy4YPgIYD13etRE5CyJsREv8hnr2zVnOk2CvJrd7p6d1ALSZFVC + Ohiz0AKSGX14LGNX2/+QNp7LB3rbDp69dzKlL0jv7JQwrTrbINL38L90OViyb1bvc/0vWTr31DRL + V/HXSsup8Fge60Y8gweYU6qiaXelpYZP/QexrFsbWFUl23rcOPTYYbu7wEw4zpq9HU1vIzMpOYZu + jeTchngP215MBMCgGcsg+oKPGsGUYqwuHYWB3LSqmZzZyWuUuD/IWlyvBag4ZGI1K9AsQEFxKU9F + 439A7vFMUO+RusYpz1FSkT0plgm2lJpw2S8mQl3MqFJsHJ1ezq3nLh0O5Itkqrm5GLvSFBatuDPl + VSjcahrBOULgedKkgG5PH/Byy/nB210iuyND7FcnBJkTmLjxIXXQHeZu84Nc96TVepbBEGPSsjFh + rqWXwpls3Vlkvr5nWsZIcJR5pBiNnEzOqzW0z7al2k7lhi0ZFm03i2he6h0wLtSSKfKGH7PZ5Ldi + Tdl3iK3ARYl7jMpRTDOOXXNoCzugMF2r0kliZMkS/ICCLupAYrE1Kp0b+DayNvHlXjYjgXPG6lxZ + Liw7Ke8dbpVAltwTFhRVq7BN/T4mg+UiPXshbsloo6mwDIYWRJW76qGQuFk3/+z1efLyGVSFIt+P + zacVN6J6o9okZ+KqlHvO6+LrnCQGOrWVzBzxKpAVg8hkprpjrxvt50RNWdDqVejiWoWKXdC9PfVv + XWbuhlM1C74kNFcBY2iHVVJGvoF1rEUt0YCs3NbYHDqNdQflmrrdgE3jCru2bBZJFFK0e9k2q73D + PdkL+Fy8Rtqji9juSlacYNR2iSZ7Dn84x6W0teTvVLFtuqGW5rmAxd1Klti9xrTUVbhDKboL8TUR + EwrxTgtWLqvTLbyHHUVsUHMd4EW1LlXlwu5IV4LZ2MKhJ3acaNuXV1zTk9R1iJQQppclZJneuupA + OrvBzXcA3Lug3iXlmGaBpRPJMPoTiSkFT/et6yzeC9BQCacBRWJRnD4AyeUIcwjQXszcSHOrqUMY + mTl16wqLEU/Xt9fNbIEbagLFSPpLLVTP8biI49cZ8fOQh8sxb9ZCqsAsnTSrlsFrWqkCkKaq2gxU + 4jB5MbyajRzPtIJl2ULvpCsEafjnznZNuHYyWJEi7I4YSncoR+R6gWx+DEVKZmdTPtjbK9Lm8pa3 + o/Qn6pGLS/jxUBsAuB0CN47QJsru6Rntm1M5GV9fAUM/yypTUTG0Vd4aLmbGmZFVlR7I8twFRPBs + qmySvxAqgrlJIv+OGPeqJjxE8TKbYBHSt03OvxWuFzoBKTXk4TVRksDc0ZxuwBd5Oz3f/5QAeK6q + vg4E+yrEL2hPlSJIux1cdL2xtV3SuZu5HXsfn+eKroU1Z3S67Hp2VEBsuBSc1WI5SynGInoHKZPD + +qIe/VYB/C6MpL46I0KcdqfdoNUtTy7FM742pnAGaRYt6iSt0EyL7NfbewsKlrEK9vUkiqbt1ZGX + wKlQQszbdVdBPn17ww2eE7VjEp2ruJhRDMZsPcmIp1aRN9a7V+KeNdP6Q4W4ktx+AFM3h4V9O2c4 + buybhrfMXk/LGitBus2iV6KtswY7WDNhVXWKXgvJ3nGHn4PqrWT6nTv7uWb7asS/V/mUH9YAGFc9 + M/llwNsWj11Q5GxReHfbnpkaCrexsP5FahTGb2MKkHLTJvgh/EC7yeCOtGq/ZNmgm4qyWHIshTxb + mzOF7fNL1tX2+kCaAWgmcVVYR99EktywMhDrYQNDiqA+5sFf9gCXt1SVIOQFLShu35gciHvQQZvP + FtA1X+z5rZcnO7JyT9dbK/pHHQ97p4zFWPdJt8x0N6Ckf2pKQ+yi8oHgdqrZ54EgXcUEvY7eTkMU + uTi+tYzdOCsKKPXwZoS3ffbufOfS7psJMScKHXum7udWAOvYHrr7RNJclyJxT42icHEqxtO8DYhO + LV11FSMe687iIRQs7lYdT8YrDbVDqIvAL4kuT3bFq0pQ9jrrfmKyZs8SwzldXucodk+evVHMcQW8 + zmVsQCFw3hzI+jAt1FU1uDOE6aQYBEEPLUBMrHCtK8vhjQ7YKNrbLDvY8mostVcwB7YtINNtiehD + 84pHXe9LV9zRqDLYjLBIprq/iLh7FVEojO4NqS+ZQHgk3HbrQsVLLPTyMNMFaiIqbhrSIQOwrHTZ + Oq3SyKzbwHG64aUGO1h2uCMpl8nkirz1s34NWA2E2urVlbxJ3D680lyiKWL0nOwxIa6nrqcuR70S + BEKH1iUIs1z2USkkDVe/0VN9g6W6ZEXO+MlPfqBvr4qskDZtY912t6gP58nuiNzVRAMiqcx+X805 + k27qjEAIsxTBF0GajxaG5h2Z8Hs6+CCkqwPFjUFYqXXcgt4tGGBrtJyxr1ebjZeqSTCnvo7BJl2G + kb5M4G5F3WAnhHHHx4oPI7utCBlqrJlNL+hYyC/ul+fDmQSOXekSrmZnpCoFR/YzsVr6oxGrLlB0 + r0JYAFmrQln4AM9xooX+NoUMvK2MeJk+QWdCnLWEsvRKiYWYQz2jZNLtfaAH2saD5i1SD9tFIqGB + qGpmcN7EQsGSA0nPtS76qMgXVxjSsA/Lh5t0tjYVQqjgbCAC69Qhe0H2ZSNmCw+tJD+1ksviLpqc + iNoMpB2wxX+BdAsbXblAYOENojV9Ja4PMeyqZBgPUZOdoC3+vd0zZKtijctqjYz3DOF2r4ItEGg1 + 1d55ed4SwXx/7pBnyGHNrfviQIm2FGVl2RUrhBfDdqeintHqkmlsSinMzlEsEZRMp4aYPKO/FUER + 37Qbe2cRCcI/SNnu/Qi6wlmdGF66JMY8jYIYMQRmdhhXVq0ej+jVR1GNXEBw1zDUUJyS8B5Ol7ag + RffWU+rUQ95efZpcxiYG1mV8N4V2r9E5K4/ZmIEroeiYzA49d0FIk/sxjZqL5Fd7miJ1g96yL9ui + KyTT4hPC0pL1ZfLDQ8IaOxG31bkZ/xQaum13Z33hsPHSvdFUhShwonnpzbtGmnpoPePVNRcA7QEM + uDRmW3UYu7/MfmQRKrTJ6cKLA4jS2GJJNyPW4S7PpdD1eouZtVDrDrI3wMtu9wGLD3BSManHnndq + JVJUsW6KjDlJPT7alS3RZ/20qSrUOQ3KyO6X7CuJyXtOjYGb7YraaqwFr7pA43/S4UKZOd7ZsPZL + bADNtkCuDhFm3mqys5wpe7bFK5P10dLpsWsbQT+0ByrvkfZL4hkb2hudwLd7B0Rs3cDuaWK+qlId + l2S1fdYFrspIiLZK3jFSLBVioecz0BtWckYJCGLMvc8OoatQQvYA7D1SHnJWbCSPKoeJAiiUuqpP + HOnTMsH6M9CfzlfjibDGeTqwD+HdAL0aP9BudGw82Yonq+EzjiHTlS3rGVEdm/BPm0G1mWPD3G2o + XGVHxjjXf/nyco/c7v7NxxxlSV3q0eiEuFIqNcwJ1rGt+8OEEhtb06K9ujYE2kFkGajnC1OKMeMp + SM30ZiCIPrH7hwi7O3KbB9xwjnIhc5IzLY9mmoAnWbxpOJDb3ns51WexCjzF3FFs3qeqIwwK8O3g + K96wrGZm7igMmEZXenSSyQxmlVc6EV2rjxC6ABTRSiP4A+htBDkuundpNjEUS4mLCRuEKrjxT925 + 2h1edKXNOohq903fnucM7eN3NZMjnieL6vvvtja0LeIiY4hBQFc4E53P4C1uUJBkbYhB5mfg3WOW + Fkd8nsuKlreTs9lxq7c25HUH7WOONcv+RnmbM0oTU/H+k6e47MhO0VYVAO/DkODjtHhcVyuAFKif + uFKf5LbubevvEEZ4yZ51V4rCM7TabIXsQpw9s49jsgsv7hDM9V35doz4rs9MHUJKNcqsnZfwuuRC + fRAAA0MwDc0aSXJPoFduNCbdl0IQymq9Emj64g5P2Q7LnWp8X23aRy95aIvE3Foj05lzrUfgqbsZ + QsiZVYfn+o58XmLG4YcbyFYKpXUsa5ziTsJW3DJtVYr2bldY6tnc1nn0uGLEfilcKAfhPd/0TK0D + l+0SO7nbBsQg0EiWeQWH0uMaifV0ryKXZXfpbyExG1VFNdgNEa9odDiKYHbjoFi5XR3KzZaHGcWQ + gkUdbxZ+IKdR1eA6i5vqOvqcs2dlDgUaRLKgqQZY6kj2cd1a8Frt5OczgEp6bAhuQEQ5iq44BZ4S + S3G2dAQw/d47tgdj1OzDMTVaJzpecKLi2+ZBb0w4FrqRckINWpTljgzeDoKtC+84XQOSi8MyhsrI + qRYX7rVFjC9EBS/YjLmEpsVqzqRhnKMJq6yVrdjQeXvoXXd0XXscHp4plkwa5J68tjoUG1bHqxnJ + 3WRFpECXhYuXqOZ2vEJIFdpzydUdhlUGNT1uMj1j2BFxEwBCFgeZysIetWdngLN2u9YgpSKdUYs3 + B/Y0Q54UCMfom6Qqw1HwXoc1y+zWcCnSO6jro8DW4nPILXelwBuU6mBq3euci+I9WyP8WHLSkTia + iDJ5oXCaFJA7vEEfx/lVS6fqpKk1iO0jVHJuX/bo+kCluklVSFe2UVR6Eggt+9pBVlMaBEEhiPec + 2+Qqycs4WydGW0NJ5ClHno0cddEFTGhhtfdvuLkHxOUHsMTPs13snBQAYZdy/7K0Cl/1ynGFrOuR + KhLknbQbcQ76eK8ED7wwl/mJqouU1ctGqxun+kPDTsWzhYJIQwqt14RHO5Q5NkYjgnrQAS1GCepn + EBm/cXcqs0+Z/vy0r/z/5fH482+S8F9++uXLr358vj+eH1/96+P1V0L4d6+fffnZK6DXf+g3TvjG + v//x2TdfPd9/2YT//Pz1919++vXjrx+//PDVz3883x9e9s8+P375+OzHS1/98nj8/+X/LwM= + headers: + CF-RAY: + - 9b1f9df86f76124d-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 12:28:07 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '53' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-577f9fc864-hmt86 + x-envoy-upstream-service-time: + - '443' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e9602c3fe2f84011bda6cbed3c4c8543 + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_custom_parameters.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_custom_parameters.yaml new file mode 100644 index 000000000..b0ea634fa --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_custom_parameters.yaml @@ -0,0 +1,472 @@ +interactions: +- request: + body: '{"input":["post_1"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DPjrAECsWPt8f0ZtPR1oGjploz6DC8/Xz68JaamRYzuFMDgojxH8561CgiKr0qhc/ge17SzKrcSm + RYt6xuT82i5LAQaYffmvvr49z+uvb3/94bv/X+/P6/df/vv/9eHteV7ff/P/N6/358vb8zzP158P + d7/6wx/f/vD997/8+dMlteG9f1H/5ev9wV/f2/hU2v95nuf5iE9AJ92+DyuDca1r/D3Q6o7dF4xI + bgZ5PcnbalbJpp5I+0G8GfSLUlWAFlewTURzhYgZYR8JANShSvqAu60SL/kDrzd100fEJ0BQKytS + MxVa6wEhkNdvvOrr3A8otKIaeafrDkJct8tFA7NZS8mgqGdjnimwqWnF7EZ3OH2FcthdlDMIjtfZ + m8aDvPqBxAqOZ9JszZrXBhw3DEk9fTsnie69+3JO7ap1SKmqil7F1eHO7WkX21ZXOZMr68Bte9YK + yLWzmTIiTq329rQen2SV77j2zym82wgr0busy1Xh9O6Mxa9gFxmP2KrmRiiiYmxKGbqxbD/uEA77 + Oq+1FK2EjJDwCrSOaHuUNqQhLQsBfdmeUTbJqitPjIBgb5QTl1njGjLrLuVhmxhMJ8pV0LWxFfew + 505LqaoPyNA+L230oPeuBr2fycUJYKGHSt5RGG6UGbi4Gyh9kFF0OBmWZOHBkONFlX3lTZJ2mDwR + qsJiUiPZl9QCwtk3u8lVHh/snnZnpGG7UKXZOQl4u0LGTnfnxj/SkqvAVCjE8Y4s2/QUrWWEsTup + 54g4dUDzIA64AsWInEadbYdM7eRKNehaS258BAD0XqH1E2MqzgVr7/wWeyVoUfdLoi9Bi4y27kUa + YhIzC2AvO0Qt+ipO9mS8P9KbVY1x3XeVJaL3qgqgLnY8QXF66XSW6GuNczSFbDIr2Wpfpp0dG5eP + PXGEpRtNpRN7qu7wtufNWEdEtbcqzghUVlpDnFlCwrQs2eOqGwIiOSLSKdGcGr+nTA/bJ4rPGZwY + cNZyaQELXAk7joermle5G67hK6+EETOAQOrhbSGfAPZOuTPa2Oh2IJWwWzt5E9RzlDDSVVbnhV5c + QC9iESltcisNmG8Tsx0TNcbDiENmdquxjtacwzsZ6cEuEZHNofyIZQd3eGigoWvPkgzdNgJkcIFE + SNpjBwvJYpdh/wKtLYZgRqzukjuL7AyUKwHc3mYnEwSad7cFRWpH1p6BsDp2B4GkTs63AYLsHi3T + oOqSoPZHLXa6NrLC2yBU9GwQKDEgZ1z5YCGp9AoZBqf8BE9SC5cY6OKgChUbt3f3TiUjtGfjM4/x + LrqY91jsGs5qEERE2RYCWOsMBUzUJIPR7UpVoPUl2oNVaZx3RgUw/U3NYIbTDZRqsa+6oPs2GlWG + d6VTLtIAfe1FTF22Y+aigZZajDRVJ1GNaX3iYh0FWGtn8x4pt2CFAaruyvhdNzHquUN3TSVucjMp + 5O6aZO4CkGqC668Wo6lIXnD2AzjoKR0Y1BREXNSHxkbqYuM2NgO9W+bXCHxTdCr3LcyfESlT2RZI + La+qPb/JfGwht58bNuPsy7o/rnYrmmzYtj/2pILRSGAljh6kUGzO+cYVs95tZzQzJHoQgxxYMEiF + HQmtaikiXMspNQ5db1q7IzDXlmzHa6cyHIei3GpFU+eunT2InnX+3sLdkPgt5JS26FNz9SNrqaYG + 1qRYy+qAvGAZbGmFtq8pV4m7Ra1g6Qgda187DTPzSl1wvMMqaqBM8LHlt1CDM6moRoMuERvs7Ren + Jq9ZpD9CrnSjVktpDr6kFTJiA58CSmqmsWK7L2H4rXVb8I3czgLnCbsmkbSJ3s2lAT1qXAYvgInt + 62PSYs2qwp2VzB0hmL3BMlmJU9z8VhjxBowy0kljomBlkDb81FPlxqBGtI4cmneEWTjZ+IYOcQ6R + nkHm7LDNLrHrwoOcGJ7Dipq6lesjuNLuy44FL1S+SXPTZn+RvFRD9AuQM9NtaAkJoOM+Qx3vlg2O + d8xsVHkTS31d+qKgnQR3TI1Hk6/BRZyoP2K1KPsKdrG5M6O6j2C2IuFi4p2RboF5BWhKGRganAgk + 5DNVtdvjFOowSZGIMz03TGZBrErbb2EeUXwLUpsT3W1rSEncKlDzrPaU2i2q7WKYisiERWeueZ07 + UMJLvRzhctBHXzbLI7uTEe4ioHLHc2zzdJsDCIUdQ81Shd3nTj37ACyIS+WQvImxKy15hdQUpktu + JNjyuoFZdSrgwj5aPfrHCzkPFu6hhsq1Um3ZiRdxmnq80t5t8UfIMSvUyQjYUa99booKmgWqA0OD + IbKTuOwbGLMenrVT4xYEwaxCqiAPywz6X1lQQ3VkXEeI34GGc1TqKr5UEp3UFX3PhZ9DwyXzRYtp + uWigWLzZpwCcgzns2PE2CsiaMvagjI/P6TYAgCpDRDWpB0ARMsxtxViZP6O2TmdTTUNRPg8IVq38 + N0C4oc0MPzTN0icTRgMFDc2u4L+qfUk+Z9DrQcpGyva1KTZ46caqLSnnvv1nSwgYW5aEilpWseW1 + 58lE1kuCAJQ/NksTXiflKsz38UiApij5dyIqutjzDIHsROqdw6uooj/CVBU9fKhmExc6FsV0y0Gn + AWhzzEs5/4vBhW9GBfoKi1/Lts0VFglWTbb3SvFwIWyli6GkciarPW1xqVFsKbcNaq3a3arZuSiB + xDCn4Ko9Cz+kAkWMsukIVQOR0X20sJl2KV/Kn/U8gv8RuPbAHwxSNga6U958YSKNOXreQ64GQjVa + uGN/bJo8SRRrSA4TaCBm0qHTUxs8Ji99zLAvMGwf97CzTZdJ3LmY9KLvwOQKXgr1aGd2NxxcyGIW + IexdbBxVZrutCnVrHc8ucJw7QkNCN6WcP3PrHPsRTczJVe8BKavRtD2pZwOKUySfue4NcRz0vtgJ + 9xlTbM4by3Vp3bLBPeV8STyahI0kNxtH76RHOm120y6ax9lMbmIdLn8iba/1/yIXA5XQbGtufRV5 + ZxvN7s41bzcio/FzSeQuFKUbV2jzSlTkJg8oMQMWczEHeVVKqs3MmuM2MpYUerRlF8ahSA+zuECg + FYQAzr2s8m7XZ1nawee+4KsB5Lei6trqcNV08jNVCRvkgC7TifoUMm0etltikeEOVOhSVTkFdSq8 + t71tHcsQZ1aqdgmT5OKWgrW1s331OmnYEO74JMmwHrYYVvZXbHjkqIIQQWAou+5QsYvKEoOlOBur + BpmY6akePddU4yM2a7veEyCuazKwyatbL9cVtukged8BDuS4C2lqELGmVSemw/8gpG4BAI7MwVXh + altKSHzEecpEJNs9Wq0pRb19ELdNS5tGBrKpKG8rDNyA3g5FkygzngF1G0n5sXWLHlrTFHshu5Gp + 7LWtRQPg7C6gu5P47mvja5Kau9PJWoTajuJUigxtY6/TviBOXreiFjanJmV8bTFlvNTPbe2iqlY0 + 22JjIwVYvGpFGtauKTjyTKaTSz1rky7LPq6gX1CnPpOLtXUs2Y+GyLewtXVHsggR/J0DtOf2xJ6A + o4ipqIFyNgOJVY7n1psjVVNz/ARK07aQhoIXQdXLTWVbvd6HZIhnTKeCF+9T6xPpQItq2uVSQpzG + 5M8mbglO7LFdsGr3gtekOQi7eXstFfBmnf0jd+o2PZCqGpKsarA1Dk5bhwYtKXw9yGk7LXOpzZrO + LgLt9HJ7Nsso88bc8bVVJlHX8D/mU8N8B8L0iZKVsLQCLVbRk+iid5epjwtQ6232p6pkD5gxceOU + c810zVzRUyrZvtP7CtzEDfru63jUTVvyzmIytzoCAspncpquZLOUH45hiYe7fTdxqJsEtNDjl3bo + Jsoo9sc2qMLp/0QlynAYXHIuRynY6Ggbkh1VLyGpGMskm0XswdY5zVJL3+NNj8v4FHDI7bIPppSN + huZTKejgYVq+CYZ3orVava5WwjYn2IaxPDXPRTXudh2naqmGGfG4NA25EI+uxu4TpBrOBpwwDRb4 + tyJbDSQa03dM3xrQnDKwkyNGnEsgruT19CDySLCRdR1pT5sjq3BTCifYS0Q2jk5770L+zoa2aV3p + PBCn5WGIpeyrRCzZuNigtkogXmBuzEMmXSGWGlB/TsSjENLcpuDYomtIPmji6E2m6Uu284zu5Z1z + EFD5F2ubuL6bHyHD+gsUV2WP2DQ1WK2upsnZ9NjQXpoYXwRZiTzTeWLTrpp960/fvFEy58rXz6oZ + LUTE40bOX4G9lAOtBUtbxoLCgZwCTwdex3ahNBpeAY4qqB986Xoie6np62jLay6THAG8SovvcEDd + mYJxFyDtoSVdq/etKqtOMrOWKxk1vW6ibwvmKq1bF7tVBARKCT1p/jXciTigaXk3fALywIU1ewXC + rJmV9uc2JqeToye4nvlkkzW+oTJcRq5RkWTloujYoAuZHDJp+qm87sIbsJIl7lJn1UXFCakEetP2 + dbhg4dw+LNJ3MhZhdSZm9d1nGFyH/kc5m54HBz0HzJh4cJBe+In0OFk8rw7pDKjAGXtpzvMn/cJQ + 6AUmibE3QNkxwpFihyYzU23O9GktDk451+rf/yfiWqwyB0l5G7iiNKBnr/fIxbRsdpphTn01cdgN + BpPnG2MYM6vBAoAaV1gwblrJcGHrBLxGZznuP0NWSoXAQnMmNhrJkH6ZSeE6pIVMybir826t0uI6 + bfvgseN6qq40plInN9WDSk40ONjLuljaRGPb0xKIbPCY0SAitELMhSJaH4Vz64h45apNRz3Cri98 + 2kRSYtDlgQOD+iNqr4BgbFNzc4MGTC54wCOFHSygSzcrjslEx1vXTOwZ75oEyWHOz4EW7YGKJ9SX + q6lS9dfJbGoEyIaGTop0jDypyR7TtRWe1lRY507JHm1DulgDzc5Hrsajrd/xITpLy+RqncWaQjLR + BBmUlK5YcTcBmt1VKkZxEQ8bJmfK7H0tRgwNVgNcQIsOLuqrz7XfWNPs9kabXmRxnPRsb6hSmcku + gco11U123sxG+aKba+hJdchdp1Po4kaDQkoc5LradbsKRlOxI8ayyhl2UGp9Rwekd2UjmWy1c16f + 0xYVQrZsujiYnoQaaoz6nleaBHCseDm8tDFAR9coZVdAbK3XJ0tDE4I9pr1HbSfj4AllMXZMLY32 + 6orL1nI4CO+tNlaYHNeWWffiPk2nIWf3hh82r9bLoQeG292hKd1cVPERrwZNRs30yGp6ncgWwQuy + qWaz5I+3kcw1aCWpvtvs+A+mk2Ba2UcNRwaI3/Nt6QJt0TJimyZWCjnxxhIVgL0HaHJbnFkoHFey + P9wV055vMDEw1WgquLKxup2eIyMuIRfrZacMM9qYKrEKqN0q53F8G1jbmpypxsk62/zSFlFBXl3A + E75o7cKmSNRFfs8wJarbXWiUAg7bWYgdaLahQDQZomsFTETRtcEaGLHYy679cQJPb2bkwS6V4+QJ + jctEyxUq0e1qmT1WmiVeGVGxh64bn45QExjipxRkDXs5pbVU1YoupVnVSXQaCA1i3khauBOhICHG + HOPojMhmB+cG4cNdFx9dykkjBp/FNPQtO4di6IQ+nqBi0qSWgyNxGp++g4FCJepXqqbiAk0IuMhj + MqrS4lDZnpCVJ6hG79y2NgwI39zn+LAM3VUih76Jiohk4qZ4+ZzZ0/xCGpjMYskrrc7okTNzTER+ + WtgAuNAB6jLJIgFIenRI2SkZnQ1Ud8pVtmaUPSxrFZfrdF3XSuVb4u5qMu4cxf1RfZNPg/b0timg + EiOhu4OgEpP0YvFWu93BHhwHlqjQdfqv++icJqeBy2i6oGhqsxKfQ0qlyTQ4QXCLB5KPqNrAfj+I + hTtrtQk5mBTL+yYm0T0LLYitTubZI7fF+gwIZAf3tZIUkKW4qHIPuUpO0uyZH4ABSUWqp9enpBBa + 8JRyOcJc58UVMfDKCtc3e42b59eEwaVrR2SISktCgo6Jt5HGF+IB5ZzOCL44VKzWGt1N8ukJlMrp + X1sgTWprzgimWwCS5mOGY9BU5JS8VSwVzHSu9Ezu2N4FcyEXpqIjR4NGCvaxbEZ7eIjM7Bmzq6rN + suYubBvbJ86e78Zx82jH2CoWk+rzER741GRlmM98BBjNSd3GZDLDnnW6M11b8mFmLgSD0jVKm96u + dd8eB6J4j54DSr42E68os859nmRyu2YKPQ2qkaLSHLtiJpeIBh9Mup75BThC/JKvMRkzjdR42FvM + xnxXGCWcZJ5IIbsFzciYPvysTTiZs9MjsG13r0n1YJL1CVC3Jf8GFVZDxXphX+Q2JS+k1kMsezuN + sAYLNo29+Sh2sDHlmHt4WoRlKV/OwLO9LT6RPVnWgE3DcvObJzB3yqKWyzNVSjel256xlN1YL596 + b2FrDdXFFNE172CDl6vNEdD7zZpLacAVJewdmw9HZxbsMDkcLrQ3ivaA3M1RvJnrSjBaVMccGDZu + t5yPDIQ9LyxpenhAa6Zgos6o56j16E+OHmfzsg6Rwey7WiXiUiN3UJbSbHBAU05P+jaDgjifPW6J + iTwoHt3bHpuCyhebTIoOYHAG05A8vfRb0lwLk8tGX91RPEzulfQt1K1aXkVyD9CMk9UVEA9WLzcH + djFZ+MjbfXlE+9RJaSdciJ5iDj6qYSQFrKPShD1zeqL0iLVAo9FsLhQkEaRsQwL9C6MmRyIGQlGB + JnEzYN2alHxXYe26ZNkjvdWRxij52j5AE+lGaHouTcITiRtu5zjaYVW+2iVxW/UldNp7WD0TO216 + VFMdzuItqt3btV3Jyoy7k80T0WajDZJWXbNNsUPBccTpc6QreERzil15zz2ufhaUFZJy8PEvAZD8 + tlt+1mAMN5B6S4TvxrYy292tKKn2tJIOGU8wLYxVhSsIWJF2Mq3Vk6aoU8VYhSUbel0fvVfRl1vD + WyKSu6s5Vq9oV8EWe584aFO1IeULqU6Sk3HGUC1zhOUHOIdd4IjfDConKSgYk4X0RsX3iTm7tPo6 + AOYLlXdkHdusAfUmeQuLyPiCtibUZ1C3s3Y0fIXIU1TXTNBjqo4182NF6uIZn8mHuKg9WmhPC0rO + dU7Y62j1hXUoexYJRTR7VcL5gQoUV2g0S8ezqRIl25cG41xO+6CsBvnYYlfV9ImHHOFSwFm4Vu9+ + YDLNln+Vjrxh7XQKVrkAlqAZYpORXhRDRx6hfXc0bpZVxRWh36c5gUVkSWtXm91qWUvXUVodOGk3 + U9yYEWucRVmGLquXKAqIsafQNG9TUhp098SVHEPCn75pnEkGwPAOenbiKRXN9g4+kOf8jzVNWatl + aiC6fqPJFvB1yblDMa4wuEU8x3F3RtySuSksLLyPi/FZRtqePLqqhkuQ/ICu6jkrFL5Vw4g/slfF + 9UjwlN4xHSFZuzH9O0NxXVw7kIUBS+u68PVHV6D6P/3EWx4s/XXuD46R7M9BM3PZQZPmNnB8Fsin + 7pzna7d4Ji9fACrTsKwfKjmNidZgzOCI4kN/gVfJhGxkKTUxw/+XW5g63ZlH19oJ0wYRky6q9qmc + y4M34O1e7pxsi3CZ5lzcAlvVFIPkQRH8Yr5IV+OYkQ3+5kSlsIliznY5sEi23SztaPGVdsLWZIrH + 9E6igX1DCcc8kDdbAGNLPa7F3rDnxVkALRjI2l8Cwl66QO5VdBd8uctevzkxDVtNC6Vklyq8qe4D + BcQK66dMatP0kHNplcQeyZrJCT14YdnoZnqdO2XHzsc2PhKESWh04yuNvancS6VxBxXNto3dbYNF + W0NsuMF/DNjG9kLEKNYc5+LwafoObZbOnYwr3Q+uKAKb2X9ksCw/oG01Ddezqh39K+79iLrKPeZf + JocxIcGcSIru6ZzIw700o+B/5V5NWKLLgUrZnB3gEjXa6K4Dx3RBJYUNFWCK7XMxm2B3bBhhjbk7 + 1tdmZ2+48VNiVeltEBblxlYAWPo3ixQ2FPwbfFUPSsskrkXpEsfD6tJabvhqtiLXAXUltdPkaiao + Se3OS82euExb4h6SPuAZh9tpiXdNXLgKdmrTCsy5QdbEg8wpz0o1PFgJrtK1voTuYIen9hBdA21Z + +sVm5ionA3smUBB3Yd2VtSZLd2Jtfp9BXUiSkvOqma4z4Txw2nZYZjYTLNjoXdwu2RvuTF5Fg6rs + kEoZt7G7pLbJd0HjjRnT7zvO2gLw7HaqajpbNdtseRtEwwZTX4TAo1MEalpGzn+TYFHKklh1myLg + LxluUcFNSQGJ9pyHti8bqEVzK3ORGfaBCZYI/lNDtNZi+TvD4DrTvW+GKOyjt5M19h/YU570DYfN + IJUpaJisnu1RugtzoxdYRAzHbK3iKJPHsk5nxW1MxKPkPVbJFlWjcxxaQJdC+NEE3YnhmV4o4PEb + 92z5Jj9X/LJfQqQ17exW1yPQkbWvsIvJWIQHRjVuhhgtoVLAlwB7YEZZEHPjJzq9jfSghS21W35B + q9sXQacpOncK3AqHi/HqFP05eXJ/blPjPi1tUaI5OA/A6v7pCvejP5a6ZyOd2/8RclWtyUjqt6v4 + pwW+HwcFDL8//LgdCr2QqtrtZnwvEG2cx9A4SXnNmZ8gewdimBimS2RlcmfuSmUFAQwtsdFyd6Fl + pMJUQmnvjJVN4XQWI9I9mlAkpYv73aRvwC4ySfdVfZonRTMi7VnuLpXbzOLJO+5cLM4Gjb646vaS + Hs3jtXDzyuFtedmT2vJPuqbkUV4QZjGWjNOXx8MT8pZr7DVS2aB90DhPWd836P+LyC0OuOqaox2U + Klq69hISD4BTwVM6AogLWrOjJ3zZdxGPh9GcNxYz2S6X+b+dq+OMLXbCrGsGW6mLcNIAD+M9qDkb + v3IuyhK+sB3BslPx8AiLE/RBV3vkFc9oRsoCxEzQHqGLBg1X0g041wX9K2f9SLJHpsBRA2UezCN4 + v4bkaHR9UX2tgZ3lptfjQVfHEYW72f1nD8WxsZOtDQqwM8VndFFeB4zXy/Un0fWouGXfssxVk9nH + c70MoqED3FlvS/Sm+foN+l1d3jsFrKykyHyc0N49wsmwwY3DeyjvkRIa0AZ7yyPiaTEY4LyBK7/K + N0dl662BLystt6gUJitO3zc6Se34WhQ93OsK3c7m5ixJc+wDb5Ktm82F01uhfwHMoNQNTlL2EnoI + kHqz+hiC6YR8uw4Oh/GRE9a98BJMPy2z6oMJ0vVyRmLZV7cZTrGtZEaHBCDthwa/qaIAgnbkfDG0 + jjaKGKUG7QZHBk1ei8v84tMxezvovTsl5YAeeW61icQM24RN2wvbM+SlB53DIPrKLZEBtJAcDsq8 + 65iq6LKhUl5cKgwrjz0t9717N+KO+q40pZyqqGGyu89n9Mq9VSNdSTQYCShciGAzHspvzsIpwDf0 + ArfsuDp8NHGltp/Ue9V39sL941jzXKGpgSVtq72rKhYggrI+SRBCoqRzZtRK3AtJY4+lxTkPoHiH + ZfUObrfQ38E0lDXuKH6gkpyZK6lKKmOTmrk0/mypHS/nIZG9tAy8JK3cBfH2BR3TChL43gZ+MMe2 + fK7k0jL0Q78JVNdWRgF/mfc6xiWF0ww28L7BO/4seyiERDZ62ziI+Q6G30jMNEMekZLlMsRhm4jr + 3VOXa3PyC1MReExcRPfpoJtCmi0zpoIciK8C4Jy2V26LewiaUtNJkHhDzqUshC7AC2t0b1465v1D + 5QczagtXsTTchg490eZJSCKBmi59cdTSNHhnBUO8Fw1mzajBEKIKoxasPZrU3qPhg3F2VAYNKLjG + FVLNaYDzCMXbsKLbOm65bcVh0O+5gLmMs7iMUNYs1mBSsRdoTFt4IUep94UG0vKANi8keR8AZquK + OypfPRuL5lblOKsW7drrvkjqBfRNn7N5dlM8kuvcJS6ChMxANJq2UfGKxu7Myao9xJZzOj4gPXiF + pZqC6UngQdvxCF7vyy+suJ4fpLF+VqT6+n5IZEk9mFv5C0gOvkH4YG8U4Bd3ls/zG5f3v/nL/18e + j/d/VcL/+f7Hzz7/7vXd4/W3z//67fnnIfy358efffwE9PxDf33Ct3//9eMvP39994cn/O/Xn375 + 8fuffvvwtx+//fyHX1/fPfr0X19/+/G3j7979NWXx+P/l/9fDAM= + headers: + CF-RAY: + - 9b20d610add838d9-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:09 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '55' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-647vw + x-envoy-upstream-service-time: + - '109' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_681adfe3c5cc425daff4a9a0f4bb5390 + status: + code: 200 + message: OK +- request: + body: '{"input":["post_2"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + cookie: + - __cf_bm=4n.R8oTwIjEt8kCJ48y_OcrjK.Fd3XJ9pqZ3_XPo5wM-1766419269-1.0.1.1-D8zpUbhsCUj3tp9blZ1k3ZkWCDJxCvBDf80eNTBWkr6JWqAY.JCGEG.6W_yNBlKP7muETO.g7zwKY7VFuoVj4E43t0GPaMgHRek21LAa5sY; + _cfuvid=sdUnJMb91z8SquLvvPugMa.pw9OO6xmS1C4jE18eMOI-1766419269461-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DJgUxIjUpB4AjdDhc97+x5hVvo1KRW+mHn0aZfdokfuAoL5f1r+cCzEJDlx67rctoRFbKOOYQ37P + uXK9i/qhdxtNjVxXy022bGNRhQgQYmKyaZFKUdVIybf2sQYDDMN+qstG/e/vTq1KgSThVGZkNfdF + mf0NA4yxZUnkv/Xft8fj+cvn33/1xfvz4+P543d/vD8/eXs8nl9+9v7Z8+Pj07fH4/H47/fL3d// + 1U+ff/Xll9/9/M1HYsNP/Bf1v/b8+MC//sTGD6X9/4/H4/HCB/AGC+iTlcvgu0U9Qccg8BMoHQb1 + u+aGf/8H+ABh3Hd7idyltAAKDtAn9xQ91JAfQB3c5Az/AFuN5q6EaszSzKxsiJoa/T5mKl2UcoKn + Qk8WNkhFp4jdrruox50C7DXmV5e7NLYgwtt5zLNEy/inQl/IXjgHYp2psSNoudhCTgHHsXv/P4dW + mF09kdGyLydGcrpbtxOuvrmqFSNQkMvEltGuAI1S94VZ7XSrdkozqkpWvMazTjs8wQ2YSA9Lxilo + DuGqBoairC+BjMVuRlZfj2+dwHmvNCuU6BvBv1ESYuPmn7IabfcDT6GcbcA9oVnliGbELNkqM2bb + HEXAFea0m4krMz8nEVCO3cMdei9ETgFds9VHBrrpPlM+CR6764jcA0s01WRV6zcwuu2+jNM4VhV8 + 86jWPGrIqJ6u+QPMhDY8Q3f33SOxywDS3SnEJdH+/5jL2aXsFU42Mzj0rkMAH4oVkg9tbm4vVdd1 + 0Thoj5j2R08JCWhUN3NMCCcQ1q75zbBrseIECdO2jz2JM6fzEqZmnExzwuImN1Koaq8lx3m8M7nj + DyQqw9ixHaq8xno80o3Jt2QbB54xa8el9A4HwXdRaxa+hbgBdQYfEBnaiyTUrTdp3bHYVoGx51RO + v1YqrsMCcYtTKZj6iFNCRFAGvAFkcoOotcqVMMApcHVmnOCUdFcorsjDzcVAIhnIptw7RwHjSlco + wQzElto0bodsh4XQVpfChF3CnRMhz9QyNCEpmw6PJCws4yREr3vDk8aeTMmGy8Nmv71xUkNhWzgG + ney4YMwDqS8XR1EoLhinKrqcq1VMOSUQbKEum9ErVcArNhkwFzG0Nn2ZADI1EGIiSE/vadFxNLCl + 2g5DrEpP7gGrt8BC4zq5illIlprRsOH5XNQiv3j0EdnwkuoTtpiuKShGEVlM3AMGjjryXI2xtZaw + nctVk42b2x4T/r248VnCnlllM+Qak1QEcdOrBgPCvLqr2cOeD1ZcMiqfBMvd6YaCccY1s5/05oSz + IqTBqx9kE5rct8XcBPRGgMlqBzBZL2u1gCAH7FEsaybpCDIruPWCmFtuN2CXZFoEUqOMuQDtKzFt + 4B5vqkYxbvPq9ICsOymjcu96eCtyuiZLIbc6g+MYutqeEPkSsEppWexKW86JEN4dlasALIuY9OOI + 3kmUTEq3WmehoapYeJ5SGAjBdHuztXDLk8tCe5zubjuu3XIDDNOedhr7ETF1MgNT916g8SnAl5pr + a04hKS6mZFX9JvLM9sRD7s+nX/jQnVxZUpvJ88uWjAK9M4NMHMKk/KBgID0LcjDrWMKcIAtY4fTV + bThCF31qSylsDzrMTyFi3c3tIIFSYDOTRz7WS0q2mgkzhFv4egGP3lPJP8Ae9ICG2wYXSzRzjPvg + 496Da5DnslpZyI8Gm0LVTgGhE9Sxe0UgsbtOB4yxWRUXU33YZKvaaNjGUJ0dXY+LbZ6hRm0nYbu0 + ihpECbQRXVqZeg91VJOistxxN9YMV6v0cSWy0wBDwVgxLgKjIVfa44q+EapPJdiKsOxpIgbDQQ/H + dxJoRG0c8DnC4l2iXo+Y2/tNr8xLEVyK7RxkRF2TdhlPreH7HTWvzYrLEuq02N7DLE8KO5XV7TrN + U0a1N5vTGQbhdiq9HMPEO5ZBkdlgGxoozqXYCsiRKJMdYDq71OHQZPfnFV01NAVrRdHldV/tBddX + JRdUTTdFiCXL4QJxIY7sUbdd3rLVdVDhQuz4Ko3MAUB9R3AitboqbyMFCgIe4vZ6GZ1TwE4re+It + ejUwMu5LXW7s9RDXU2aKAhpqCaknMAFnPd6Pc8dbSl1VmWfw3fnIX8QDZkoaItJbtCGm0zeZxNai + UxJdoO6k9xDwZFq3wE+a2ItvOl5W7/5R46ov9zRLExxTEzjJygF6smFaHIyZs1kiqrpBWBC8V85U + pywLr13DTjrISHD5kZE+2JFkrawYPK69StPlFh3TUIhLpUQhEkh6V4yAF+rYHs5pW3JPjljAqsBM + sWsLX+9WmAu511KUKhpu482l6FUID2toYsqiEIWpXqYZtxLzQaHcp0YQMYuzUGHLrjYHEJ+wmapi + FpCkbqICiOnUHcP1qgiZt9zD4Og4HLtZVbxi1TMbEDEGSgcODpfxbOXKvqDENFZX4hEgRx025k9i + MQcsC7rOHZAYZJ25bwpu9wrdQvadugnFRt+y2slTp4w8IwuZUmVszukBid2xyElDMR4B9w7XQ9ZV + 6xRb9iXdargZ9FThRN+G1G1GyZDm4jqsbV+vOAGgzhIiMxWXXf54EhALAw4TtlNxIoJUMpfzdnQc + 1VM5ig2EZXmhi5s+LRlQMzKe5vRoFqrZMznrAKrbmJl0NMJ3ii6WAkG3oCUsciGqg9qQlbkhmpue + GFI6WVMTBRdJtFNIq3c2LDzqxsxBBd8YodVk7GDRRVOLWJJsEtK7Wt1xQl4kYh3IuU4GMli7vZuL + xyOCaCzqYi4XVd9OiMxoWpbYiHmrVs+INWwmF+WiCMGu2YG4rTI2B5Bpjmf9BjE5VidWE98MM2Vm + t1RNM8EQm7TYH8bhqW87o73nzpi+Ode0Kbzt1a3IyvjdBSzh0qfgulu6hAyzPTf2NugGUQun5uQI + usPbAYxFt0OmYneurx8+idptc+1uAwO62BKab2boqhyMwVRXcbpo9xrzsgPobh9i6jHAMXrs20LC + oaJ8gKXsWzuUY1emp+aoSXH7351FgfXAOg2wWTt0NlNmyz1g9GfZk5txQfUQ261up66O5Xz95T+B + njWWPWBycev6okGgKWW7eKm+KxsISJ8D2J9XJsfepR6bqXPYgnuuMHO3iW8zZYWEKi5NTFBPqaF2 + K9W/nATOjYs7HyjvTJ1DNpr4XXt5HoLRZWoUJLUAqsdMqIPZbuiqKR+CtJsFS1UVKb2nmp6uXd1Y + Ln6Kd+7uXtnsnG2cD74i32Q2o1WL9XxgR50aksvVtRPq0HAVSxSk9nD773AW74Xp7JHpdRIOBcbT + OhKCXkRxzgWNXCpl1m66wy5XNZEFNCMLoY7vfbMOUNPxdh1U9TWHrW67kMfZXc5ecAHWajolYv9A + qCQebHgS3FlknvCYjQgMNma7N0tQ3AHc1JUMt3pCqEQRGVN0inHlAdb21M1gM7S3uzWWWl6xsMhE + yS9YtlmmA4ZSidYksbqvyx9heeso7g+RNvLQ7fUMC6dwyWTsDQj2azFE8jhodna8Espy4GZPd+oo + 1KNisr8gE4qO5vFLcpme6+jWblVGvAyaasD6+o7LQOiZUJLscBd6WbhItlhM4o4DV90WciyajPHU + JhqB3dBKR+hrIqHBKnosnexphf7WrMW6EWBuNJamijk+DW3gel2pAI/Qur3127W4V/bsDT3hqWbz + PioRw0bpdaDVvAtEKbmMVOSzdj9p1DwyxDQhKht5u7bQNia2WUfPoqxFB3ZZkJUACpXgnUutmsdA + upD3HSFxvUOCMro22NtNscBlBWhr4477CZ5N59rJyx46ywd5z81FuBsTPLgccMVr12NwzKnNFTJX + FCBdZ5k5sQp3KRZeXoV1kbfqyKdkFG00WlStmB/kndo6eRjXXBKO2LwriiJ6SHA8kNMoYyFEaG/L + OxK6q5ynV8Z/m20DytM9a7hzZZpyimzf2tydm1xbkFVmGcvenIYJ0eieyuCpzrCFmBtM2P/B5PTC + 4JIlbu0cxEwEoldbV5O0lnNGbW9D3oRC4Y9728vZMzisjymuXKHikt5QH93+7Ip2jdXdpMdGhaIx + /2CVZbQMyKD1dgEca99WYupw5E8gLebD8OzQ4hFiqi+HyqEceVIA1LC8yA0a6SvgeQASWilXztSq + fHZ1rapjb+bivrNo37V1O9SghI0cNMXWXAyO++GARyxmhSGyRj+I3evANi3Y5g1bM7NKEsK5PAAN + EnOjA4FxSTdPX9Az8cSSzChkllwkq3CMlWARvC1urqzIZZixm94RMVySHe69tnB0KOIWdVX+4Gdc + SWcv16BSlcCXA8kyM9xiGe65TWJf86rHOgjHofRmZYzAWHKKiVreseDYFq3WHjFqXWX4IvQY2c9L + 07lHMu2F8ljtsa+5gh41/lLmCmpYt6mJD2jOxoYB1DXT01haKgeydgdVVZYdpvKWEWCQ0A147B6H + bi0HIrbaQyV58zazbv5qncOH3fQ1haGz7JNalRfGSjvqMormPp4C+kLPebCzSp8SrG6flTTbQhfF + Zrfg4EyIXg7Mz3Vv2SG6QVyvyvWAXbW1uAM5rQaChqG6pwzBLKZ78qfof2LterLsGUXu6uUdpXbU + AnquRS+r2prMm1CciZNGgJS5mle+1W2fzelNmOHzexYxtZ4zx7cQPRpoxVZ3a08YpOrmngzJhStW + 4JmacaJkDehzpG45j8QPEuXylkoEzd25EkLRkq8+mKemJU8iR1HkgYpDj/qsKw3pwmtaFaJYd+pY + Ohx9ybvk4IbLuottbFb86BhxuDWokZZIugx1qVxmwjLkbgLtpMG+XQ/Rb7kWNDhtXl9u8h7enh57 + LA+tViCl6LuHDs4PoWCnXkQHYu8oyJDbnUmZFIxv54NeGX93EihQEW7bPS+523PcAwFRx2v1UBgJ + VUWqdkJfMTMg2R13GG3sSFK5fb+F7bn1+MNik97WEY02Iblrt+0nAS9b6+WBGq/KBSwmHAmog49v + wTdStdkDUs4secFU3VN9Qa9VtjqEiVmTcw9hlIEnGnJYLgPpiP0sGTPoRm3FHrHojAKNcz1jZWzn + pouuI+kQwrJtCVsNXr/pfTzj3aJC78WhEbaayvTY4mheJ9FEo7CKv/gqh1gMNpL9sjkyUwtTHfMi + PWNiJaFeA/GOMTWPS3lUsx5u8SQrehkiF2v5oxiM/CBohjcbCl4nNQl3B+WDwAVNH5+95JihelaO + EEusBcKLYGzQY4jeXFeMu8aVQRoguu1sMZ1Xazm3w12Qz8lFhOMCb68NtXucY6PzxqgtMqqj1oJJ + qA42WJW6JkY6Tp7TYmUKRILP1xdBoeaGRy3cMO2Fj1OahdIXLmy5GOouWzsr6h7iLr392mur7FEU + VlHyfT/BGHUsXCo1wWuKdhQdxb87eBOaHJeVzWV79rhOnSMyfgjP23MTjFxVo36Vo6duF57cmey6 + pAdw/HXt3VoSm5OQwqYIxJV4KISmgCXZH3syMnvoBx140uvMuyPWoj3xVdTtTZ9xJB2G4+FAGmTX + NRony77UR7d9s+7SIG73psfy7gz9osP0JSmK6hSjkVfiYOW4a2SBBkFi1sZVa4DQFaHSbVndxq4B + JJBa8G7YT6UOwFvPlePOcuM21k80hmcuJy8dLs8XPoO4stZzc1ewuOj5vY28ocOshuT8vDevynVz + BJruicBZClZXWMDJyRzflG9gLwYmkxCDEotbRWE0Pe6FtKHw6zuaUk1kaYpH/d9RDN9xzc8gzDQU + pK/CmXCS4rq4K6s6AW1P4N+W5iqu5aZjytYKlRMcIt4eytHML6FXnqqXV4pB9/a09q6JLUjNxdYw + nCWRZnFaCVoevbr/IhFTRmkLAlG1c5b8W6nOztai8Dot5b78vWXYQj8Q28qRp+GyneOvT8FNbBia + ORJvItNw2n9OY49CX2GU119sTQu32k9mg4X+DdWOcEUDP8pQreleK+1inqhjWmGSGpx2ch6lW5Cx + svA8OMe4U0eS+tHVlgUnc4GuOwKHIdU3bC8w04Lqkh1czcCnp5YSR3cw2uV05d31WBaS4TmagyG3 + qONOIa3pHa4Ec7OjumLllrVRz0bOJ4eoylyWpMzMRGJjT2Fy3hlQj1uCex8G35iFQdX1ctqMlWEC + Qtw1r8Bz2BHT2ty0GScdPdc7Oz3v/45z677HcreBzJcAFyj7GUr2+fCBotZpj5wLy7/wCndLl2YG + lLd7ezeySxPtsITiqowH7vI/i6VcqO1zxRgsTwgRBZLuPUi0aOnHMOR13xYtU7RBT1xK2hhyhmtA + R4OQgfWBWFtX18ZX3DmqCAmqKRwBkU3PDXFLcu5UUkOlTkTL9qxyiqJdqtksvpLC40sdd6B587Yl + nIubs+MZiHtDeiZMPD1S8FzTmcOfo3fpFvD4ca8qmnd0pTqYFHdbU7bpIufYIVg16BDN9aGqEHvl + bmCXyvXKQZKiz1t2cNDyGahFRK12V9aaxNCCj7s6A71u+DvZd7tdt3Ywxtae+icr6PP7GIxtChgx + U05d3FyupJAzHRrpUjAz4dHkmPXIlrGJMeSNpEIA0zODEm0HcwhzhQOadIdCm0qmJAx8avEo6OXA + Zqv4ZEU0jN+qb5tUZAtUUH1Y+7RHldfWjVmgjZc+VrWC49RsMdfoqEY0syffQcC1rAcnR2LqxwFE + 0RhyswUiYA4WVtmW60wQ9jJlj1K4M4cag9wVHb4wiEnZOEIa6zUZm6TEyBcYhtN927/sjmFzbxuv + thRSwK6PsRtVDsSt7OOFZnxGQ6aobNyonNQsXG2QoLlOebxbDD1BBy0rBwrPxdfB9jj65KU9Gjtd + 7ImXtYJJe0As4jayG4wt3A7FJvD7KbMjQ1hfLA8rdooaEZNG5HrPGLIGrgvOXCLbksGxM+BuIW6I + cSB7UtuHLvgYbTuU3fm6Q6lybvAHxtWo6sz1os15MFibvfG2khpX56nlUb21Q5B1aJFw6qQrPyCi + AhpLRWCfCNqnM1O7Bk8EsGbT3nccZOqHLiyeIbtMmngdosKeyJQL5Fpoq4gH4eg4LxEoUq0Pu18j + bCOQECfMOyNPo2h88dr1uYA4XFf3pD1qup2UbMFpiPkD56js0bzGBaRshwUZvLnxHsGngKkkuy/V + g1gQPp7sOd0L7NFDQZ4evDliUdFPfhOgA7s7BemjvCnHgw+MTtMNZhP18EqLk7Q1mFMGaZzwqddm + 7NvCoueNr25yOuQPPj5D967IBoY5GYthShSNnuWM0s3GjB1rjWxPjmRRa/XgFfPZawEtK7JpUdqL + YUM7VnO7dRhWV7uNQytX/rynLuqfeK9YcKdTlYLtae6RWsYga8bpEGNv++7T45u0n8bbdlwZVIo3 + EFDMcLOywA4jnMLMKT6+7PU/Kf1iMIIqzYmdqXBdOsyGrbfvFIgrF2PCmDvi+qHVpLIVmtkdg4tw + lRvCwyWXx4CnvDEvP83RVepGJmSLzTeUltq38o66lMvmzf1wSVGnackQZIQasKIoXto3l+4nSAy2 + u91UV2rNp9UUe2QQ22mjJasYG8JtWbdru9T2QYX8ccwQmuKJAYX42q1e1sIrTqLdNS9GbXdbPvrU + 9GYbbpSaF9FxkBtwXQ14dp8Ik7XtEtIpCOSlcUV3R8p0G/fS2MrMlNwuRm2VJXU6RznM2QI7bNN0 + y7MxQEyVIXwmPJ4LqyjIRAYVAfNC4XaiOyoC4xbXnhZ0vPa3GKvQaxt8udOR3InOFFOLHsd8Kw6z + FVbogLJ0LNMgdzB1bha+enFAeFMzQJmuNvAs6ZLPKMnFwcSQqWOnVM7ypjdRGaO0LDo81dK52WVp + xYUYHeW364epucPALsz1y8PW7prjEgqiPKLWHiYQWyvwJCHoWw84zGDzDu6zLrTX5FvSu0dizWrH + pgOovqLOBFnCFVcJUXe4CI6FuiDdrNx0oPd2lBnnLJfYoXONdcaSyeVtrlhDpVDOlY76W3fZYTuI + iOMjsy/L2oNpRUCqaeFZ8D7a65Fe4FC7Pa6gpv8CkfHWiVpKjKTvWCgglZbdy4ZkyDEDLvffAaDS + KmqgRtdTyOb01obTL/f4ZTOTR/kXwhlOOGDZbqd5XwIiPVa2Wh0mjFO1eXOQw6kplbw+0sR7ocMg + 1nEOhYxR9fSCOYFsXxkg76lmuduHyokeyzS74nXEIbPCK5O4WjYku7qbiznPIgKLdzs1h/bchaNv + h7LaOh4R6K4UFmJvCtlqBw9mTJYXqL3jOrZ57KpWwdJ7JP1y9EVED6WqSqCaPvIP7qw60I08lU0s + e7AUpOSqF9ynFHmr2GUjpykGb9fT2NPpz6+FaMMYqtuMAGtzo16YVx3WXj1e/l8WOSNGrV1tiQKH + snSX7RZyz9UMXtg5gucBVNele3znOHUVlF40elJFtGnJxTgDXIpietnXwXbuHXU/zwIkvamaAEm0 + L5BNuWgkfxQGtBdXrNU+PDvObZUapfDaMhKeA3LY0698zof8/OvzKnvqVvfo+v0Yuq1id67DavFk + B6I77R7cAlc2F31VSevu7khqPz9b9qJFrOUqCyDbzAV67bkNQrdH8KKevk5jQvWdTKGX4+W274RX + B6PVfAXLmU7OEUhN7l+jhRR0XKpXLEfwzQhvoBVyzZ3F7Lu52L4y3JOMYtTuLgjsNeZKuPwapJgx + He455dS9WaGpI0HE5FpVLbU2p4GOevjULETJ+5/tUVgqPHt9+1jyE6gsgTwTLtTkYsrGtQb4CGoE + To9bw7XS5DuabUpNfp9RQ/vfsTDi6dEs35F51ja5hWGL5JWTJqyaUZ90xVEdP9G4g31X5VYYsU4O + 6iQ3y51yHvpmp+gnVlPC9EIMewgfQ1yup7TqAMZ18RoThr4xUrgjolXDiL9QOrk67v3rcF/uOcnq + 5LQ+j/P7Otp2HIYdQjukZwes1HVgSnUV8T9UKGwZwp6xVipk33CncXsJae3aYaOeUBSWG1dshNX1 + sqsht4O6gQHNDi8H7OM19lzex87MtFxr2OejIZxT5lAM1sjLB8BF3gQZzrENtGN0mDHrqZM2tLhl + 4W3wlM6vtGgTuRagcLPl45nUI3sHW712VFM7rJw4c/7SuO11YDWZXYeCeBg80/kUaa7KWZZZoaOO + NR8W687YoPHORkoV+cHStlIQgTM1XcKiEdNg0Ewm2L74FSXyT4O5A6xq2vTE25hSYK/0C6qFPK+r + 6tDm1E0LsntWW1SXJwHCzs67iFlxNm++U5JoelOxlbIH08nMgtUdsqtEJEjnQN605FWINTndRex1 + GxCI5E0a0cJQqcH862CuWaMVir72LihYVp5OAz9MG3O/KKtZT4tjx+67KN9xPVxHnb21Ep50ESTf + 31Q9EM8mg4pCLHQuqZFWfo1NhM6dtRvweJlAQO2qLvhCM7elPc87hS2/q1QmhRtFfFw2FPXLVr5S + YtKi/7i416NAtAQ/Bsdo4tUkOlq6mfSozNzB1XUJm9+p6bksROJtIMulq6Y1VvCNKdF0SGrNfwdY + nKm3TF/OmNOOql0aGj2TFoFCEyGD0rhOSPYz0PeDZpKTySTstDMktVXkzB0y9u19B2q9WCyqsnou + auaYXXkq7Kcx4kgDM7yZKSuEVC3YLs+JjpGcxTHsOny8VxTee3AA0ZhkYk01mV2MpI0rz3KtYMyu + d92a520dl21bLH3ZW4w8M20T0zuzyzsobc8MjbU7BJua3GOieWLI+yYL9k3sO0+O5oo673gLm8cF + DdIjnYEtdPzCKX5L2Tdjta/TcJDVFTLfATohD+O03Iqx3ZnedT+T2xxNdcetn9bp0+vQcRTJ6Dpe + w9RmWGkUCU7MIxR7x536iSa1+QHzanPwv7dPZM0Ppj9/4Fv/f3s8/vyHIfyHn3758qsfnx8fz/ev + /vX++gsP/tXrsy8/ewF6/UN/QML3/v2Pz7756vnxb0f4989ff//lp1/f//r+yw9f/fzH8+NjSf7s + 8/2X989+/NG3vz0e/3/7/5sBAw== + headers: + CF-RAY: + - 9b20d6131c0238d9-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:09 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '101' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-647vw + x-envoy-upstream-service-time: + - '127' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_a1d8bb94379449cf8b642f8b45613267 + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_disabled_by_default.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_disabled_by_default.yaml new file mode 100644 index 000000000..59cd405a2 --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_disabled_by_default.yaml @@ -0,0 +1,473 @@ +interactions: +- request: + body: '{"input":["post_1"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + AC2IiGpWD4AiZJjb/5Bl2qupdrY+3Tz6pKq1ncTIChD8Vyv7FxD+oc2MHAOHZs0jCiNBQS8b25D3 + zPImPdRCU436FtJtb3OEXmNThwkwYh/a5iffsvqNyXrdtpQHMMBwUrWsDEF+2e+6x23XKVEka/5X + /315PJ6/fvHD11++P98ez5++//P9+eHl8Xh+9fn758+3xycvj8fj8d+/f3j3r3798xdff/XV9798 + +0jc8Hv/Rf0fPt8e+Onv3fhJ2v/n8Xg8XvER6KTb9+HKgXGta/zngFZ37H7gEMnNIJ9v5201K2Sj + nkj7hXgz6A9KVQFavIJtIppXiJgR9msCAHWokn6Au60SH/mA15t66deIj4CgVq6QmqnQWh8gBPL6 + G171dd4HKLSiGvJO1x0Ecd0uFx0wm7WUDBT1bMxzFNjUtGJ2Rnc4/QTlsLso50BwvM6+1B7k1Q9I + rOB4TJqtWfOyAccNQ6Kevp2TWPfe/eac2lXr4FJVFb0UV4c7t7tdbFudyplcWQfctmetALl2NlMO + EadW+3a3Hp9kKt9x7Z+H8G4jLEQPWZerhNO7MxZ/BbvIeIitam6EQlSMTSmGbizbjwPCYR/nZS1F + KyGHkPAKtA7R9ihtSIa0LAT0y/aMspGsuvLEISDYG+XEy6xxDTHrLuVhNjGYTpRXQdfGlt3DnjtZ + SlV9QAbt89JGX/Te1aDvx+TiBLCgh0q+rTDcKGPg4m6g9IuMosPJYEkWHgzZXlTZF95E0g6TJ4Sq + sJjUkOxLagHC2Td3I1d5fLCVdmckw3ahSrPHJODrAhmV7s6NH9KSq8BEKNjxjiwreorWYoSxO6nH + EXHqgOaLOOAKFEPkNOpse5CpnVypBrrWkhu/BgD0XqH1I8ZUnAdq7/xL7JWgRbzPib4ELWS0dR+k + ISYxUwB72MFq0VdxvCfj+y29WdUwrvuuslj0XlUBqIsdT6A4vXQ6luhrjX00hWxiVrLVvnQ7OzYu + PvbEEeZuNJVO2FN1h7eaN2MdIqq9VXEOgcpKa4hHlpAwDUtqXHVDgEiOiHSUaE6N312mh+0Tis8Z + nDjAWculC7DAlbBje7iqeZG75hq+8oowYgYQkHp4W8iPAPZOuTOasdHtQCrCbu3kjVHPUcIhXWV1 + vqDFBfRCLCKljW+lAfMyMdsxosZ4GHGQmd1qrK015/B2Rnqwi4jI5lD+EMsO7vCQgYauPYtk6LYR + QAYXSASnPXawIFnsMuwTaG0xBD1idZesLLIzoFwJ4O0yO5kgoHl3W1BI7cjaMyCsjt1BQFIn59sB + BNk9Wkag6pIg7rda7HRtyApvg5CiZ4NACQNyxpUPLCSVXsHD4JQf40nqwksMdHGgChUbV7t7p5JD + aM/GZx7Gu+hi3m2xaziLQRAiyrYQgLXOUICJmmQwyitVgNZ7tAer0NjvjApg9E3NYAanGyjVbF91 + QXeORpHhqnTKRTRAX3sRpi7bMfOigZYqRpqok1CNaf2Ci3UUYNLO5j2k3IIVDqDqrox/dRNDPXfo + rqmIm9xMCr67JplbAFJMcPpqMZoSyQvO/QAc9JQOGNQURLyoD4211MXGFTYDvS3zYwRORbty38L8 + IyJlKmuBJHlV7XnKfLSQG+eGzXj0Zd0fR7tlTTZsq489qcBoJLASWw9SKJpzdq6Y9a6c0cyQ0IMY + 5EDBIAV2OLSqpRDhWk6p4dD1prXbAnNtSTuenMpwHBTlViualLt29kD0rPNzCXdD4h5ySlu0NFc/ + vJZqaqAmxSSrA/IEy2BLK2j7mnIpcbeoK7B0hI411k7DjHmlLjgesIoaCBNcW34LanAmFSU06BLR + YG9cnJpcs0gfQq50oxaX3Bx8SUvIiA18MiipmcaIbV3C8Ft1W7CT21ngfMCuSSQ10cNcGtCtxmXw + ABjbvj4mzdasKtyxkrkjBL03WCbLcYqb3xRGvAEjj3TSmFCwMkgb/tBT5cYgRjRFDs17CLNwsvEN + OsQ5RDSDzNlmm11i68IDOTE8hwU1leX6IbjS7suOghcK37i5abO/kLxUQ/QF5MyUQ4tJAB33jDpe + ZoPtHTMbRd7YUl+XPitoJ8E5psajyZfBRZyoP8RqUfYl2MXmzgzVfQSzZQkXE+8R6RaYR4C6lIGh + gROBhHxGVe32OAV1mKRI2JmeGya9IFal1VuYFcUepDYnOmxrSHHcKlDzWO0ptVuotothKiwTFp1Z + 8zodlHCpF0e4HPTRL5vlka1khLswqNzxHG2eljmAUBgYapYi7O6devYDYEFcKgfJmxi73JJXSI3C + dMmNCLa8bsCsOhVwwT5aPfrbCzmLhRVqqFxWqi078SxOU+sVebfFH0GOWaFODgE76rXPmaKC5gKq + A0ODQWQncdkOxqzlmZwatyAQzCqkCuRhmUF/sqCGasu4jhDvoOE4KnUVX1ISndQTuufCz0HDJfNF + xbQcNJAt3uwWAOdgDju2vY0CMqaMEZTx8ZHuZmmK11m5Cvpuj0TT1Er+jSwVKfY8w0Z2R+qd5HVU + 0YeAqqKHD/Vs4kIHUUz3OugwAG2OuJTzvyHc+GZUoC+w+LXMbVRYJLCabe/VxoNC2EoXQ0vlTFYz + bXEpKVjKbTe1qHa3SjuKEkiIOQRX7Vn9Q7qgaFIWnUXVRGT2Pl7YzLiUm/KzXlPwQ+Da0/6EkHIw + 8J3y4gVEGnP0PEOuBupqvHDH+RiaPGkp1gEOO9BAzCSh01MbPJCXPiLsEwzbxz3c2abLLO5cTHox + d4RyBS8V9ejOrDcILmQRRQR7tzduVWa5vRUa1jqeKXCcO0LDQje1OX/k1jn2WzQpJ1e9J6S8jZbt + ST2bUJwi+ch1b4hHoo/FBtxHTLE57zDX2+iWCWfK+ZJ4hISNgBvG0TvwKKfNaZqieZxFcoh1uPyJ + tb3e/xdYHF2JzLZ0G6vIO2M0uxtr3m9ERsftlshdKFo3rrrNC1GRm1yQxEyzmC9zAletpFpk9hy3 + O2NLoWe3TGEcivSwigsEWkEIRN7bKu9OfcjSDo77hK8GWL8VVRerw9XQqc9UJexYBwyZBupDyLR5 + cLfFIsMduNClqnII6lR4b3vfOpah5axV7bJNsotbLqzRzvbV66xhY3GnJwnCMmwxLPR3bHjWUQUh + EoHh7LrriikqS0wvpdnYbRDETE/N6PmHaqrtJRZrs94DIK5rcmPIq1s31wU26SD5vhUcwHEKaWow + YqFVJy6HHwip2wAgpszKVcXVWErI+EjzlAexbPfUaqEU9eZB2jYpbR4ZiKbivK0gcBN6eyhCosxw + BtxtpMoP1i16YE0o9kJ0I6jstalFE+DMLpC7k/E91obXZDV3VyfrKdQOFC+lsUJj7HWaF6TJ61QU + YXNqUIZriynHS+Pc7l1S1RrNWGxsSgGIV62Uhr1rCow8yHRyS8+5CZdlL1fAL7FPvcrF2jqW6EfH + yEfY2ropWQyR+HMM0J7bM/YMHKWYGnugnc2gxGrHc8vNsaqpmX4GpWlaSMeG1wbVKDc729nLfUhu + 8Yjp1OCN73PrE+FARDXt7dJCnI7JH03cApzRx7hg1faFrkljELh5e10q0M06+kfO1O26YFU1BFnd + YGsYnFiHBikpej1Y0+60yKWYNZ1tBNnpxfYwyyjjxtrxpVWQqGvwH/NHi+edCNMzylbCqhV4sYqc + RIreXWZ/PCFqvc781JXsCWYgbpxirkHXzBU85ZLtm73PwE3cRN9jHac6tCXvU+zMrQ6AiMpnMpsu + ZKOUf3gPJB7u+h3iUDcL0IkcvzRDhyijmB9jUIWr/wuVWIaLm1vO5SAFjI62Q7K16gUkHWMZZEPE + Hkyd8yy16nu66WEZHwIOuV30AUrZ6NZ6KhU6MEzLN4PhRbRW69fVWrDhBNsglqfkubYbD7sOU0Wq + YaZ4XJKGKMSjK7H7JlKNZgNMmA4K/HuRqUYsNNB3TKsGPKeM2ImIEecWECp5PX0TeySYyFJH2lPn + 2CrcbIU72EuKbBqd5t618nd2a0zrSvNBOC0OQ2vKsUrAEsbFBrRVBuJFzB3PYZOuAEsdUX8OxMdG + KHObDQeLriH44ImjO1mmL6sdM7qXN88DgMrf2NvE5d36CBHWn6C4KnrEolmD9epqkpyhx4b6EmJ8 + Ucgq5JnMMzrtotlv/esP32iZc63Xj6oZNUQbjws5fkX0pR1oXbDEMhYsHNgp8OrA5zFdKB0NzwBH + Faofeum6Ynupyetky0susxwBuEoP73BC3ZGCQwuQ5tCWrtX3nVVUneTJeiQZNbwO0bcFcpXXrQvd + KgZEbCXypPnXoYlYoUl5Bz4BuUBhzV4FYWhmpf04xuR05egdXM+8MmSNb6AMysg12iRVuVh07KgL + QQ6ZJP1SXmfhHbESEnepuUpRcUIoQd60eR0ULJybhyX6TsSiaJ0ds/r0DJPrkP9oZ9NzYaXnAjMl + Hhikb/hEOp0Qz6uLdCZUwIx9S87zK+PCQOhFTNLuvQCWHdtwlNghyQyqzZk8rYfBaeda/fmPiGux + trkoKS8DEqUJPSvvsYtp0ew8w1z1FeKwmxjMnm8cw8CsBhsA1HEFgnHTlQwKWyfEa3KWw/4DslLa + CBCaM6HRWIb0l0EK1wEtbEqGVudlrdLiBm3z4KPH/VRd1ZjKOjlUDyprIuBgL+2CtImGtuclEKvB + NqOJiCIVUi4U0LoVzqljjFet2mTUM+xa8ImJpISg2wMHBPUtam8DiXtDzc1NNAC54CEeKehgLXQZ + ZoUxQXS8JTPBM941CJKHOZ+DWjQDFU+gL6qpUvXb2WxqCpAdCZ0V6RB5UpJ9PC5WeFpSYb12WvZo + E9KTa6DZ/Mir8ZHW3/FFdEjL5PY6xJpCVqIdZFCldMeKOwnw7K6qYhRCvOgwO1Nm7osYMSRYTXAB + LDq5qKXPNd/Y0+zmRkMvsphOfrY3UKnNZBdA1ZrqJDtPZtv2JTfXoafUIVqnQ+jiRhOFlHEQdbXr + thVAU7FHDLLKGXTQan0HB6Ra2baYLLXXvDGnKSqCbNF0Y2IyCTXUPWqdV7oIxLTS5VC0MUFHMkrb + FTC29uuTS0M7BHtIe1ttZ8WJK5LF0DG9NFrpCmVrObyJ7q0mVkCOa4us+8Y+TR/Dzu4NPgyv1stb + Tww3u8NTuhGqcMSrQZJRIz22ml4mMiJ4wWrq2Szx4zGSuQ5aRapPzR4/AJ0Ek8puNZwyQPu83pYE + tEXKGN20Y6WwJl5ZoCLC3hU0sS3NLCocF7JXxbTlO0wMoBpNBVcYq9tpOTHiEnJjvtwpw4wYUyVW + Ab1b5TxObwNz25Mz9XC2zja/tEdUkFcX4opetFZhKBJ1kd8jTInqdhMapQaH3VmIHWS2oUCEDNE1 + A3ZE0bXBGhhB7GXX+rgDT29mxGCXynHyDo3LQMsVKq3Z3TJ7rDQkXhlRMUPXjU9H6AkM8VMJsrq9 + HNJeqmpFl9Osaic6DIQGMW4sLdyOUJAQ2xjT6IzI5g7ODYLDXRdvXc5JIwbfi2noW+4ciqE79PEE + FTtNajk4Fqfx7jsZKFSicaVqKhRoQsBFtsmoShubyvKErLyDavTKjbVhQPjWPseHZequEjmMTVRE + LBM3xYtzZk/zhTIwmcWWV1qd0ZYzs020/LSwAaDQAeoyyUkCkHTrsLJTMjoMVHfKVVgzym6WtYqL + Ol3XNVP1lri6Qsado7hv1Tf5dNCe3jcFVEZP+O4gqMROerF4K253sBvHiiUqdJ3++z46u8lh4DKa + LihCbVbic1ipNJmGJghu8UTyEVU72O8rsXBnrzYhB7Nied8EEt2z0ILZ6mScbbkt1meDQO7gbmtJ + AVkKRZV7yFUiSbNnfiAMSCpSvbw+JYWhBU8plzPMdV5cEQMvrHB9s9e4en5N0bly7YgMo9KSkKDb + wFtI4wvtguSc9gi9OFSszjW6m+TTO1Aqu39tgbRTW3NGMMMCkDSOGY5BU7FT8laxXDDTudIjuWN7 + lxgLuTA1GnI2aKRg35DNeA8PkRmeMbuq2iprrsLY2D5x9rgbx82lO8ZScTKpPu/hiU9NVg7zma8A + 4zmpW5ggM+yZp3ema0scZuZCMChdo7zp7Vr39XEgau8xckDJ92biGQXr3OdBZrdrptDToRopKs1t + VczkEu2BVyZdz/wuOEL8kttAxkwjNQx7i9mY7wKjhJOMEytkt6DZMqY//CwmnMzeyQhs280LqR5M + sr4D1G3Jv0OF1VGxPrEtcpuSJ1LrIZa9nEZYGws2jb31KHawgXLM3TwRYVnKlyPwbG+LV2xPljVg + aFhufvMOzJ2yKHJ5pkrpULrt6UvbjfX0qdcWtdZQXaCIrnkHDF6uFseA3q/WWEoDrlbCvmPz4eTM + gh1mh8OF9mbRHpC7OIo3c11J9JbUMRsGxu2W85GJsOeFZU0PN2jPFEzUmfUctR7jydHjMC/rEBlg + 39UqEbcauYOylGYTG7Tk9KRve1AQ57PtlpjIB8VjeNt9U1D52iKTogPROZNpSJ5e+i15roXBhdFX + dxQPyL2S7iLdqulVJPcBmmmyugLCYPVyc2CKycJH3h7LI9qXTko7QSF6ijn4rIaRFKiOShP2yOmJ + 0qPNBRmNRnOhIGlByjIk0H9j1ORIxEQoKtAsbgasW0jJdxXWoUuWPdZbHWmMk6/tA7Qj3QhNz6VJ + ccXihts4RDusyq0piduqm8hp72b1SOy06VFNdTiKj6h2b9d2LSsz7k6YJ6LNRjskrb5mm2KHguMY + u8+aruARzyl25T33uPosKCss5eDjPwVA8tuu+VqHMdxE6i0RvoxtZXa4W1FS7WllHTKeYF4YqwpX + ELBa2qm0VktCUaeKsQpLtmh1f/ReRd9uDW+KWO6uxlg9o6mCLfY6sdKmasPKF1KdLCfjjKGa5hGW + r+AcdgVH/GpQOUtBwZgQ0hsV33fM2aXV1wGwXqi8I+vY5hxQb5K3QETGF7R1oT6Tup254+ErRJ6m + umaCHqg61oyPM1IXz/hMHOKidmuRPS0oOdc5xVonqy+sQ9uzSCji2asSzk9UoLjCo1nanqFKlGxf + OoxzNe2DsjrkYye7qqZXGHKESwGHcK3e9QAyzZZ/lY+8Ye0MCla5BCwhM8QiY70oho46QvvueNws + q4pnhH6f5gSIyJLWrpjdallL11FaHTh5N1PcmBlrnEUhQ5fVSxQFxLamyDRvUXIadLfEhRxDwr/+ + 8HCQDIDunfTsxFMumu0VfCLP+R97mrJWC2ogun7jyRbwdcu5QzGuMLiNeE7j7oy4LXNTWFjzPi76 + 5zTS9uTSRTVcguQHfFXPWaHorRpG/Jq9Kq4twVN6t+EYkrUr0757KK6LayuyMGBrXRe+vnUFqv/D + r/jIg6W/zv3BoyfHc9DMvK2gyeN2cHxOkE/dOM/XYfFMXr4LqEzDsnao5DQQrcGYwQnFh/4GXmUT + spGl1MQs/r/dwtTurjy6p91h2iBiykXVOpVzeeINdLuXO2fbIlymNRc3wc5qikFyoQh+Y7xYV+OY + kR3+5kKlsInamB1yYJGM3Sxtb+mVdsDWZIpteifRiHXDCcdcsDdbAGNLPS5ib9jj4iiAFgxk7U8B + YS9dIPcqugm+3NtavzgxDTubFkrJKlV4U90GChgzbJwyqc3TQ46lsyT2SOZMTuiJF7aNbqbXuVN2 + W/nUxkeCgIRG17/W2JvKvVUat1HJbNvYHRss2hpiwQ3+R4ctbE/E6MWa41xsPl338Gbp3Mm00n3h + giKwmf0nBsvyQzxbTcNlVrWjv8W5H62ucov5F+QwJiSYE0mjeQYn8nDfHqPgf+VeTTFFTwcqZWN2 + gkvUaLO7DhwzBJUUdlSAJbbPxWwHu2PDCDTm7lhfw87ecOGXxKrS2yEsyo2tAmAZ3yxS2FHw7/BV + XSktk7gWpVscD7PLa7nhq2FFrgPqSmon5GomqEntzivNnrjMW+JukhzwjMPtROJdExeugp3atCLG + 3CRr4kFwyrNSDU9Wgqt0rS+RO9juqT1Ez4G2LL0xzFzlZGCPBArirph3Za0J6U6sxe8V6kKSlJxX + z3SdCeeK07bDNrOZYAGjd3Gr5Gi4I/ksGlRlm1TKuG2rS2qbfBM03jZixn3HWTsBPLueqprPVs0y + W54G0bHA1Ach6OgUgULLyPlvCixKWdJm3aII+FuGW1RwKCkg0V7z0PZlE7VobgUXmWEbQLBE8J86 + orUey989DK4z3dtmiIZ99HIyxz5gT3nSt9hsJqlMQQOyerZ76SbMjZ5gETEcs7SKoyCPZe3OjtuY + iMfJe6ySnVSNznFoA10K4Y9H8J0YnumFAj6+8Z4t39Tnil/2U4i0pp1d63pENGTtK0wxGYvwwKzG + zRCTJVQK+BRgD8woC2Ju+4lBbyM98YQ9tVt9QavbT4JOU3TuELgVDifjxSn6c3Ll9pympn1a2qJF + c7AfBKv7r1e439rjVOdspGP7Q8hVNSdbUr9cxT8t8P22UYTh9x9+HIdCL6TqdrsZ3xtEG+exeDhL + ec2Z30H2DsSAGKZLZAW5M3elsoIAFk+C0XJ3oWWmwlRCZe+MlU3hdNZ6ZHg0ochKF7c7pG/AJoKk + +6o+rZOiGZH3LHeVym1m48oLdy6WZoNGX1p1e0iP5/FauHnh8LS87Ept+WddU/IoLwiz0ZeK05fH + hyfkNdfYa6SyQ/vgcZ6yvu/Q/xeRW9vgqmOO7qBU0da1l5B4ApwKntYRQFzwmh1d0cu+g3gYRnPe + WAyyXS7zf5yr4/RtrIRZ00y2UgfhpAFe9Pek5mz8qrkoS/jCdiSmnYuHR1jcQR90tEde8WyPkbIA + YyR4j9BFg44j6Sac64L+hbN+JNklKHDUQBmDeQTP17AcjY4vqo81wFluej6udHUcUbib3X5tobZt + 3MnWBg3YmeJzNFFeB2yvl+tPWtNHxS27y2mOmsw+nutlIhpawZ31tkVvmq/fod/15b1TwNpKiszH + Hdq7W7gYNrhx8R7Oe6SEJmiDo+UR8bwYDHDewZU/yydHZfOtgy9rLbeoFJAVp88b3Unt+FgUP9zr + Ct2dzclZlubYBx6SrZvFRdNboX8BzESpOzhJ2Uv4IUDqzdnHEEwH5Pt1cLjoHzth3QufgumnZVZ/ + MEG6Pp2RWHbrPsMptZWM6CYBSNuhw2+qKIDEc+R8sXg62ShilB60GxyZNHlPXOYX3xqzt5Peu13S + DuiR51aLSBthi7Bpe2F7FnnpSucwiLFyU2QCLSSHkzLvOKYquuyolBeHCoeVxz0t9314N+KO+qw0 + p5yqqAHZ3ec9+sw9VSOdSTIYCSgoRLAZD+UnZ8UuoDf0BEd2XB0+Qlyp7Sf1SfWdvfD4ONY8F2hq + YMmz1d5VFQswgrIxSRDCoqRzZvRK3BPJY4+lxTkOoHiHZfVObrfQ38k0lDXeUfxALTkzR1KVVMYu + NXNp/NlTOz6dh0T20jbwkrRyE8TbJ3RMK0jQexv4AY5teV/JpWXRDuMmUF2sjAL+su51jEsKp5lY + wMcGz/hD9lAIiTB629iI9Q6G3yjMNEM+IiXkMsRu2xHXu6ae7pmTL0xF4G3gRnSfdjoU0myZsRTk + QPwsAM7p89ptcTdBKDWdBEk35FwKIXQBXjhH5+alfT4+VH6wR23hKJaO09BDT7R4EpJYoKZLXxq1 + NA2+s4IhPokGs8eowRChCqOWmHsyqT1Hg4NxdlQGHSi4xxVSzemA8wTFW7Basw3ccttqm8G45wLm + Ms7SMkJZQ6zBpGJv0Ji28IocpV4XOkjLE9o8kORTAJjNKu2ofPUwFs2tymlWLdp1r/sgqSfQN33O + 5tlJ8ZFc5y5xLUjIDETboy1UvKJjddZk1RqC5ZyODygPXmGpp2B6EjBoOx7B6235hRXH8wdpbJwV + qb4+HzKypBHMpfwJJAefILyyNwrwN3eW7+QbT59980////J4fPZbJfyXn3/96uufnm+P5/vX/3p/ + /fUQ/t3r5199/gro9R/67RN++e9/fv7t18+3XzzhPz9/++PXn397/+v7rz9+/cufz7dHm/7L5/uv + 75//dOlnXx6P/7/8/8UAAw== + headers: + CF-RAY: + - 9b20d61a8cca6e5c-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:11 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '136' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6f5bc845d6-v6jc5 + x-envoy-upstream-service-time: + - '159' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_0fa01b274cef4713b848f2b6d6cb54b5 + status: + code: 200 + message: OK +- request: + body: '{"input":["post_2"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + cookie: + - __cf_bm=5pEapH5ChnPms0horCBnvsIzgXV7H9AkvCxWb80Q78k-1766419271-1.0.1.1-2Vi8L.XSeTRd5tRsQjmsfo517ZjHnGSllAXgI1Bxb7iG2qXfF1Ao9oNe5G7rWMloYH0Zp8ctnwqjjguYfl7fNnNMFqTSPxDRiNflhTW_4Ko; + _cfuvid=Esh0uoTwPvSc8aTBpmYZzqr3BXOVxN6USxHDfGJrqCM-1766419271190-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + wIwDgFixTOMiaOuwpeo0yYgafQ7M8MRP+71wHhm5dkKXD4esRtDvjVpQQZGndqg5UTmhjrMo9903 + Z5RCKQ2k39rrQ9YxGimP/quvb8/z+uvbX3/47v/X5+f1+y///f/69PY8r++/+f+b1+fny9vzPM/X + r7dnP//DH9/+8P33v/z500diwhv/Rf1nr88P/vWNibdW+//P8zzv+ABvsIA+jQyD7xZ1go5B4BMo + HQb1vbnhn/8AHxDGfTfXyF1KL2DBAfrWLdFDDfkB1cFNzvAHbDWaOxJXc5ZmZteWqKnR332m0sVV + CjwVejKwQio6Rcym7qK2KwH2GvM3L3fdGEGEr7PPs0Sv8VehL2QP1ECsMzVyFC0Xe5EScBy75/8d + WmF2taOjZV9OrOR0990Krr65qhEQKKzrxJbRqiCNUveDoXa6r1bSjKqSEdZ4VmkXT1ADJ9LDWqME + zSHcq4mhKN/XQMZiJyurr0e3CjjvlWbEEn0j6LdKQqzd/JXVaLs3LKGcbUA9pVnlLO2IWbKv7Jht + cy4irjCn2U5cmfkuIqAcqwcdes9ESkDXbPWRhW66T5QnwWN3nZF7YC1tNVnV6o2Mbrsfo4xjVcEv + r2rN4w0d1dM1v4WZ0IJ36O6+21K7DMDdlRCXROv/Ppezy7Wv4WSyg0PvKoTwoVgmuWtzc3Otuq6L + wlF7xLQ+MiXEoFXdzNEhFBDWrvnlsGux7EQJ07aOncSZ03kNUzOOpylY3ORmFavaa0lx9ncmd/yW + RGVoO9ihSmvQ49HdnHxLtnDkGbNWXEvvcGB8g1qz8CXENagKPhAZ2oc01K03bp1YbF/BsedUdr8o + FVdhhbjFiRROfcTJISooA76AMrmB1aJyJQxQAldnRglK0l2hOJIebh5GEslgbcu9c2QwVLpCCHYg + ttSioR2yFVZCW10XNuwS7pRIeaaWpilJ2VR4JWHhNYoQve41Txt7MrW2XB428/HGSQyVbeFodGnH + BWN2pL6cHUWgGDBOVfJyLlY55ZRgYYS6LEZWqoBXMBnQFzm0Nn2eQDI1EGIySE/v3WLC0cSWatsM + tSo9eQet3gIDDXVyZbOSLDWtYcXzOaiFf2H0Ed5wSPUJW07XFGSjiiwm6iEDR215VGNsrDVs53LR + ZOXmtsaEfs9udNawZ1aZLLnGxBVJ3PQqwZAwr+5ptrDngxVDRuWTZLk7nVA4zrhm5pvenHBSlDR4 + 9a1sQuP71pibgN4wsLTaAUzoZe0tJMgBcxRkzcQdSWYFp14Sc8vNBnBJJkUwNcqYA9K+Et2G7vGm + YpTjNq/uHpJ1J3lU710PbySdrvFSyq3O4DiHrrbHRB4BK5fWst3Uln2ihHdH4SoAyyzG/RDRO47S + SelW3znRUFEsNC9TGAjhdHuzNXDJk8PCuF3e3VZc3HIDDNuedhrzFTF1EoNT915w4xLgS82lNSUk + xcWErF6+qTyzPfbQ1ufyOz66kwtL2Wayfzcls0DvzCATQpiEHxUMpL0kB7O2Jc0JsoBVTl/dmqN0 + 0ae01ML2oM28hIh1N6+jBEqBzU4e+RgvLdlqxswUbuHLBRi9p5B/gD3oAQ2XDS6WGMWx3AcdZw+u + QR5ltZIQjwbrQrOdAkI3qGP3LqHE7ro7aIzNiria6sM626yNhm0O1dnR81Bs8wx91FaE7dLKahQl + 0EKktDLxXuqoJkWF3HEn1g5Xq/RxU2QnAZaCsWJcEoyGXBm36+SNUn0qwVaFZU8TMRoOeji+ItCI + 2jjgBmHxhqjXI7bl/V7vntciuBTTOcmIuiRtGE+t4ccdJa+jFOcl1InY3sMsJ4WdyupyneYpI9rD + 5nSCUbidSi7nMPGO17DIbLAJjRTnUmyF5EiUyA4wnV3qcNFk9seKrhKaDmtl0eV1P+2A66sSBVWT + TRliybK5SFyII3uy2y5tWes6iHCx7PJVEpkDgPqO4FRqdZXfVgoUGLzE7fUyOiVgp5U98Rq9GhgZ + 75VdbuS1i+spM0UBDXMJiScyAWc1nse54y1TXVWYd/Dd+chfxQNmQpoi0lu0oabTN54Ea9EJiRSo + 2+ntAp5M6hb4KSf27NuOl9U7f6lx0dd7mqUxjvtN4DRGDtCTDdNCMGbOhkRUccOwIHif3KlOWQZe + XMN2OspIcP7RkT7YloRWVgye116lqXKzjmgsxKUSohQJJLmrRsALdYyHc9KWtiaHLWhVYLrY6xZ+ + 3rUwF3JvdFFZ0VAbNpeiVyU8rKGJLYtCZKb5Ms24dTGfFMp91wgiZnYWKqzZ1eYA4hOYqSpmQUnq + JiqQmE7dMahXRci85h4GR8fh3M2q4hFUz6xBRBmoWXAgXMa1lSv2AzVEg7oSjyA56jAxP4nFHLAu + 6Dq3QWqQdea+LbjdK3Qr2XfqJFQbfctol546YeQhspCpeRnMOV0gwR2LnLQU4xFwn6B6yrpqnWLN + viRbDTWTnirc0pch9ZoRMlJz8Rxo25cr3gdAPUuI7FRcduljERALAw5TtlOxI5JUMufzNnQcxdN0 + FAtIy/LiLjR9WjKgz8gwzenSrFSzZ3zWAVS3UTOZkAh/ouhiKRR0C0oCkQtRndSGLM8t0dx0xdDS + yZo3yeAiiVZCWr2zZsGoGzMHPfjmCK0mZQdEF00takmySUh2tTrjlLxIxDqSc50UZLR2e9cXL48I + orWoi7lcVX07ITIjaZljI+a1Wj0l1pBZuigHRQl2zRbEscpYH2CmOZ7VG8XkWJlYn/h2mCkzs1PV + NBMssUmL/XEcnvqmO9p7bo/JzbmmTeVtr24krYx7F7SES5/C627pWmQx23VjtkEniLlwSk6OoDu8 + LcAguh0yVbtzfflwEbXb5sodAwN3wRKanRl5VQ7GaKqrWF3EvcY0O4ju9sGm9gGO0WXf0SQIFeUD + LmXfWqGIXZmc2qMmxc1/NxYFxgN0GmCzNuhsqszIPaD0h+zJ1bikeojNVtdTV8dyvvtdfwI951h2 + gYni1uVFC4GqlOPDp+q7sKGA9NmA+bwyOfYhddksO4cpOHOFqbvdZzdTK5BYxaWJCPpVaqndSuUv + ReDcuKjzgfLO1DnSRhO/516ehmh0mSoFpVoA1Wsm1MFsGrqqyqcg7WYAqaoipbdU05O1ZzeWipd4 + 5+7ukdXO2cK5+Sv8TUtmtmqxng9sqFNDclFdO6YuDVcxRElqDzf/E5xFX1iePTK9JOEQYJjWkRBk + EcU6lzRyKZfZV9MNdrmiSVpAM7IS6vj6zSaAmgnddVLV1yy20nYh2+EuZx+4A9b6dErY/oFQSdrw + UnBnkfNMj92IwOBg2L1ZguITgJu6SsMtTCiVKCJjOkgxRnawtiduBpuRe7uhcarlBQtEJnJ+wbKd + pTtwKJXomqRW93X1RyBvnYr7LtJGLj2KZ7FwFa40GfcGBPs1G2byOmh2TnxNqJYDmj2d1VmoR0Vn + PyATikTz+JJepudau3O3yiMOg6YaQF/fcRkKPROWJCd0F7IsnCYjFhO988BVtws5iCbTeIqJRslu + 1EqX0AcipcEq9liS7OkK/aVZm+uGgtForJqq5vg0tAH1uhIB9tC6ve23G/U+s2c3ZMJTYPPTqKQY + tpTeDrQ+7yJRSs4jdfzZuF9q1FxZYpoQla28XVvZtia2WaaHKGuzA1wW1EoghUog81Sr5jGULuS9 + oySud0hQR9cGu939tMC1AtDaxh33Ezxbnms7Lzx0lg9iz81pOI0JGq4HXPG26zk45tThOmWuCEB5 + ndXMqVW4S7BgeRXWJb1Va74lo2i1EVG1Yn6Ud2rL8jSuuSQctXlXLIrkQ4LjkZxGORdShPY2vCuh + u6rz9Irpv20dQ8rTPWvQuTKg3CLbt27ubje5jkrWa5ZB9uZqmBKN7okMTHWGLdTcYML+L0yuXhhc + copbdw5qJgKzV6yriVtrc0bj2RZ5owqd/rj3e+/sWThsH1OMXEHBpblhfnT3Z/do11idJj1uVOgA + 85urzKPLgA5ab1eCg/ZtOaYJHfn3QVqcD8OzQYtHiGV9uaxcypHHBUgNy5u5SSN9lXgegISWy01n + aqt8uLpW1MGbuXTfIdp3sG6DGlRho500xdEoBqf74YBHLHqFRWQb/SR2r5O25YLdvIE1M1tJUjiX + J0GTxNzIIDQu6ebpO/RM3DglMxUyJBfxKh5jJVhEb4ubkWvkapjBTe8UMSjJDvfeb+GYUBFH1FX1 + Bz/EVens7TWsVCVQOJIsMz/cggz3uk3iXOcVj/Mg/HGofLNqjNBYcoqJmt9pwcEWLWivGLUuMjyA + rtGa3m06ZyTTvVCM1R772q6gR4wfylxBLes2Nfohzdm4YUB1zfQAS6RyIGs3UFXVsuNU3jIUTBK6 + AY89pUO3Xw5UbLWHSmLzNj/rxlfrGJ9209cURp5lW2ovvDhW2hHK6ID7uIX0hR57wFmlrUSr2+dK + GrbQRbHhFpw8cxe9HDQ/G/j/AUDcVM9nSwAUC/zHr1/mfZSLHRlbhWJXIZFj3Lqp+/bXoDoqrxXV + itsqB4dJLqtok8vtYzA0aqk+7kFvOUC6QTRPq3rA3n375g7kiYIJGg6V3DYE5+ES54/of+LY2ll2 + xRK7+voXW71TC+j5LGpZu7c3fhOKmqg4AqS57l3yZ/WlMqe74OHzrxZn6v5q2rcQfTpwxVbtsyYM + UtvrL0PyoosKXKmzExXHgK5H6pbrlXgqlOtvWSJovnfdQigiuXvDPHURPYk8Gg09oDD02J/7nYC6 + 8LpolyhWq4ykw9GduZYcfMPHfRfbePPIjwGLw6NBWVqi6DJsZ6eVCcuQ0wTam4B9e39ErrImNDht + Nq1N3se+p8eW64PVxKQUfffUg+eHULBnL8TAxD6wIUO+ZK5kUnDcdzf0wtF3FwsFaoS+ds9LTjTH + IyMgyvhZPRTGDLWblFZCX3AekOovHnD0Ro7Uavqur5A9Z48/XQb0th7R0yYk37Pb9jcBP0ZPywN1 + floVcHPDo4AG8PhcfDNtxB6Q8twDL5g2uc0H/bNWVodwY65z7rcw1pgncnJYXw/SsfarYsygnmLG + HnHpOQYaT3NnZuygl6XqqPUQxLKNhLcb3K57H9/5vYVC98ZDIaxyZXq85XFebyJEsDiK77hbQywO + byj7ddMyo4mpAb/IiE1MAup6EB+wqXl01lZNbW7xJHf4MkQ+PNMfwhh5WjTT3lsKXpUCwu1g3RFY + wPRx2yXGDJV78gqxxLOGcLEYc/SYIq/WCbtrfDKZYIjOM1ud1FVN5w6oC2qfXKxwvGBf21D7yisa + XTdGeZDZllwLJqHt2GC1yjpGBp48p4cnUSASXLcvgsJeD0cVapi84PNZeaH6Dt/Y8mEoWVt7nqB7 + iHby+rVbj9mjWDyNiu+vM7BRx4ElUxO4ZhOPVoeIO7gLTY6bJxvL9sx5nzpHzPlHePbVTTDy7p76 + VY7c9r3xZOfmPZX0BB59XV5bS+LNk1COTbEQN8YHISQDVlR/7JuT0UN/yECTrivvgbgP7YnfpXpu + fY2CdBgeHw1pkNkGjZNlOnvTbXrPXRpE3+v1WN6Zo150OmmRotjMcjhyRQ4qxV2CBT0IArN2vPsE + EP2OsNM9cxPPrjFIIEXwO2F/O9sB3vq6XneWbxxh/ZnC8Erl5KWidV7oDOKTrVx9V3D5kPu+HfkN + HGZ1JP3z3uyu6uYV6JIbglMSVheYwKnBHB/KNeyFYbJYYlDi8u2icHQ590K9ocHXD3SrdWT1FAv9 + 72gM3bHGZxDuAi3Sm1AmvEnxefmO3G2FafsM/G3tuuNavsmIsnsNVRMcRuw5SGvmJ/Kkqfr6iTC6 + 56+1bYhTaHUdWcP0HoE0i+qJ0PLIU1MkwmVUtiAQu+8qyX+UtnK2XIWXC5X79fuWw2j6gXjRFDwN + le0Sv/0WHOINl2Y9iSfJNL34P6ezj6FXM8rtH63J5ab1ZHbwoBiqA6FLAT+aoyJ3r5Xeg59owK1w + FhtcdnIeq74hY+PBfnCOc2YLkvpT920LTubDdD2wcBhm02N7gTkRtC/ZQ/cMn556FDl6gNN7mG7b + NrYsJMNXmINh+rDFTiGtyzNXguu9075i5cjcqGcw1ckhaudaJSnn7kZk48jG5PzuAD0+E3wtvnEV + JrvlcvKKyTIBIb5nXYHnMWOmtdOLFScDnOvOu9zzf+DpM++xngTIfAJeUPYb26YuPiBmnfzJtbH8 + z7/crXXIDCi/5HE3bVZX7bCE5XMZT5zNP4tbubKP54pzsKwwQhRIOq+QqKD04zTaJl2iskWb5Cal + JM+hVrgGdDQZsrD+Rty3nWvjEDulVpDQhcIWEN300gm3Wl7rkppqdke0jO85pyji1d5i8Tuz+Pmt + yneiNXmbDefqm73jCkx6Q7knnLl7lOB5T89t/hx5j46Bx5/zNNH8JNvqYFJ8j5qyoZeaY4fBE0GH + aD4XVYV4XYfAls51lSBJkfqtExx6uQZqEbFPb1VqT2J4wefZdKCXN/qd6tjuPUcrGOPtq/iTDaR5 + H5OzQwGjZra3nTSXC2nkLE+NZDW4u+BBciz6zNbxGmPInqRBANN3hxHtAFeMcoUDuklKoZ2duZEw + 8KnV0tDLgTdvV08mqmH81b4vlCJbYAfTh7Wrt1V5ve2FBdrxo7fVXoNqap5xDRjVqGa2cgsBa1sP + nimJSz8fwBSNIYcxiIArLNxlu95aIOxlyhml8N0Vew7te2LCFwZxszGOkMbzCxk7y4lR32A4vKTL + X7Jj2Hx9wasthVlg14/xXlV5YRzN+3nhGV/QKVPsvHFQuVb3kGqDBF3T8nhHHHlCP4iiHCh8HZfB + 9ihde+mIx65f5uqldjD1PhCLeBzZBGOW26kYAb+/NVMZIvpi/TixU+yJuDai9nvGKfdAM3DWFtls + BueeA3eFuSHOA9k3+3hoocfI5SDZec1QdlMH/IHjDXY6c3mINQ8GzyY3nneyR7eZWh6btysEWUUk + wtFNV71BxAQ0l1bAfiZoX14ZnRp8JoC1OPS+42FufhjC4hnmPc6QeAOmwpHKVBvksrQp4UEkOi7L + BIq0z8Xq7zFMEEiYE5bdkZdVNA681TQFxKHZcNIee0mSkl14AjGfkqOqn+Z1XiBlB1zI4M2DXwk+ + BUzVMmmrB/FAeHuy9SQ32CNHQZ4e7FVYJPjkuwAd2PduYX1se+t6cAo6LReYnVFOVyp20iSYSwVp + 7PBl1masWxHRc+fPJpenfPr6AtO7ohuYThUshilRDHpu7zRsNubYY6+RzU0pFrVWDo+Yn9cIaNmQ + LYvq/XBqaMcNH1uHYWWTNg6t6fr7nuqIP/F+4sKdTrsabK/nK6VlDLLu3A4x5sXtt+e9oZ/mL05c + meysbiCgmOmbZwscCMIRYU7x9XW//BOZF4Mx2NU1sXc7vC8DYcPWL60DcaNjTBjznfjy0LSobINm + d8fgJbzjRuPjE5fHCZ/nifn6bY7sKkEm2ojRG7aWklu5o6x62Zrcj5SUrrpYhiBH2AMrxPCSR5bp + J0gcvLDdVF1F9+3uljkziJeJ0ZJNnAPhnrl9L3Yp14FC/jjuCN3wxIDFuHSrl/WQFdcizsyLsS9J + 5KOfvbxuw51m70F0PExPWE8DnkklmNSxS0jVYCCvHl2mO1JOYvShsTt3N3K7MfZNWa2qJsph3luQ + YTsfW16dA8TtGsZnwrJe3MWGnLFBRcH8oNB302e0AsZnND4KOh77R5w16OUCX88wkgejmmbqJucJ + 34rNbIM7csB2VY5pkO9wu2+KXL3YILypO6Cs3xh4VuuV96iWD4WJIWfLtFTO8htuQgWjZBcdmWrl + tTnk6kkLMSuVt+uPs/cOA/tgvrw8bL33rHEJB1FdUXWGCcTbJ+gkIeg+n3CEwdYM7lUd2WtxlPLd + I3HPdGLTC9h06TNBltDVKiGqRSs4FraDdlOl6UC/vlNnXKtcYoUuBeuMW9Y+9vWKGiqF8nS11T86 + 64TtECLOS3ZflvuK0IqAVMvBU+g+8vEoX+Cg0x43sMe/QMz57Y4qLUatWw4KSKvHcNmQHPLCgOX6 + ewHYiYYaqFNzg2wtb02cfj2Xl81MlvIfhHe84Qm3cdzmfQIjP1Z1twZCGM9L89Ygh1Mojbx+pJvs + hYGAWMcrFhmjyuWBPUEbdwOQj7T3uNqnmpoeZZutdB2xyWywGxKnbUNtNiEXa51FFBbvePYa2jqL + re+AshIdjwgk28JCvN6iWx3QwczJzQK1LZ9rm8d72rtg6VeKfjnSEcGhqKkEKnSpP9h5ykA3bbUO + sRzBUpBmurnhflajbBX7GMxuisG+58s4wvTXr4XI05gqCSPAetMTF+a1xYtXj4f//xJnxFn33tii + wKF5dMZ2Czn3agYvvKvA8wVstsMe75S3r4LqHwJOSlSbbC7mc8ClKC6PKYPtnHdiP98FSPrNzgRI + ot1Cdp4XjdQ/hQHxQ4c1ncNz4OnbUUMary1Hwu+APObyyNd6yD/+73fzKrZ6xNfvz1CXin3XjKrF + kxmY7nrn8BY4SS763ZXuu2tJej+/l/2QFWt9NwLIhtOBXkfeBtHHJ3ixvzRtTLi+i0vo5fHTth8M + u4XRtF7B8i7TcwRSU+fX9MIsdCzdK5Yn+M0IdzAKWWtnMdNea/vG8e1kFKc4GQhsg+sIV78GKa5Y + P3xNytHcbKPbiiDi4lrtPnpt3gYyyvFXsyFWfv9sTsNR4ernt48Vn0DNI9BnwgeFvJlt0HiAX8Ge + wOO4e3ifNXlH9yKpqd9nlGj/Tx6CeEY8yzsyG21TRxhmJVdJmnD3TtnpxFYdn/RoEd+l0gqj1rWH + reVmPTPOQ/ferfzE6la4vBDHHOFjiE5zo9UAMN4vG0wYumfM4I6IaE8R/0Gp8g68928gfXlkJ9PN + qd6P6/d15HKcDlNCB6xnL1izTWEqfRXxPygUVpawK56dCtURdoK+l5Dq1A47yo1EYT14xUZEXa97 + CbkDbA8BNAfsFNjHLXIuv+Ldlclea5p6a4jklCUMgxp5OQEXNQkyvZIGOjAy7Jj728obKt6ycB8y + petXWuSF3BpgcLPrsiH1yH6HN70OTFMH3Kk0c74TdHm98HRz7z4I4WHoTJdnSHO7nqcyEz7quOfT + 5b4zNmS8i2Oliv5g7cUpiMC7PZZQEDEJg1Y2wTzwDTXyPwbzHfD0lxdNzc8AME4AQCxZatwEnY5b + mrLViCf50qp9v7XQw6P9aDRE2zX9HQkaTWxLYvFcQrU6OtHhs+PVbVo1bRIA/Rca3ZjCwl6qF5QT + eYaVdWCz02kBVvVwi/L0xIqwvf0sysxwzLp5JiXB9FqilaITwxHdFyzvkO0kIEE4BnC7RK+SmB0r + L2KunQCACG5HVbRkKFVA/hWQa9QoBUQfewYQLCp3RQPfRBtjvSiqHneLY8Wu3ShfsIcr5NlLK4Iz + nQXJ64nMB+zcYCCDIWY8l1BIK7axsdC5MnahPJ4uIETNKDf4imbsJPc87hR267uMZZKoUdjusKBg + vyzlTS1Muug/nRx7FBElwaeho9Xh4SQyWtqR5Mjo9uAqmbDx6eway4Qk3h3IeMpqGmME3Zi0mi6S + GvOzgcnufMrwxrrmtKIsJ4cGd0eRQEUTQQal6VxVsvdA+YNGlJNmEHbYGYKaTHDmChm2e9+GHA+m + FpVJPSc5s40uXCXup2mEI40Yze0esoRI1QXb8V7SsSTHYBF2BR3vGwr6HmxAqE0wMaaKyC6NpI1N + z2KuoI0ud+4Y500dTsu2UHpjXIw4o8sipjM9Qw9KWt1NYe0CYROTs0g0TjTpN5mgb+y+42SrLeq4 + w5O1eTmhRvRIeyALbX/YQm8p+mVZ5a1oOMCsDDDfBjqCnIzDdMuObaZrRv0MTrE51QXXT+qo1eNQ + mIpgaCtei5ETzUwjWeDYOIpiTbtT3yhSG08wg4XBv6wVmb2h3e1w+H85jrsXQ/jz/uOz5+/O23F+ + e/7r2/UND75dHz97fAV0/aEXSLj8/vXxy+fn7d0Rfp+fvnx8/+nbw7ePb59/+Hrejkvy9vz28dvj + d5uOL8fx//L/YgAD + headers: + CF-RAY: + - 9b20d61d5b3e6e5c-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:12 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '974' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-ffmmz + x-envoy-upstream-service-time: + - '999' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b64907e6788a40d7b8d71c46e86df779 + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_enables_fulltext_search.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_enables_fulltext_search.yaml new file mode 100644 index 000000000..314bab513 --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_enables_fulltext_search.yaml @@ -0,0 +1,709 @@ +interactions: +- request: + body: '{"input":["PostgreSQL is a powerful relational database system"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '124' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DLgVREQ1qwdAETLM7X+MJeZj1M7qJvPoU5TtUZFzQFDVqkjOD8ADUEi2TEezRt/APrZQH//Qv5ml + r+feXrTVaKPRROsbb6QWFZWojAshHZQOS8pr6d/MrBeDACFSVcpFtfTio/SlkwKDLKvmv/Xfl8fj + +cvn33/1xcfz/fH88bs/Pp6fvDwezy8/+/js+f749OXxeDz++8vLt3/+q58+/+rLL7/7+ZsPiRd+ + 439R/0fP9wf+7G+8+M3T/t3j8XjgDWj0VdXH/78ej1e8AQJzjX6EDhjtB5zgcpTZ3/+W2gnnx1eF + N6gao+EZ2nMwg3FPKp98AitP9t7/CKYHu/q7RI15++0EVcLwbPu6wLk3vPOkA7fm4a6u8/YJDs5J + 39eOvOcZRm/M88I5KHWY5BE4UlVnfyQOeqizJ6/d6DQ1FZviauEus7q5B9/QrCqiGGZXPM88RTzX + +QlIz+kEVJVMf7a/jSu7c0a7grU7dzOKcFN2Agq6946hGnPO4IAR2QnEg+amz2f/M96A8uyQ9YVB + Su9ehehELQ+5EzIVsq8SbwAFTAkKKEVIUH4gYFFPwjSX89bvpxj3HPw64pHXYIaqXTcYoeuq5/1T + uO3jlSNAh7n54a3GZKOdjQtNuEBXWYHUhVroQG7zNktRgb15gLZTYZ2imL1y1TRSqDYnpU9CutkZ + 9DqMytlLBV/bPjsFHg4jSxi3ehRfYGvYrmBEtV204whPnW6YneJu34EPxBQD0oDzjPGIUoArdyh2 + atQuo1J3q6xFFRxRwJjWifUVyVeDjLAVp/2IhB0gIxm5U+eoo0HdtA3YdfIG52mzs4dBWF1P8iCm + zoqBzbLPCwRV8OgPJhoxQoukHm2Wos6O62ZOvOjBKWkoY94eFpgKlEPedGwtr6uhgRSwcIhVc9wB + PMmuoozpDOMY7EOO2ej2mvI24iTOIZSMiwijHa0DT8h23+DwHwF8Ht/kvkLffE7j0am7e0u+DH93 + PEYsHoAFPetcVlreucTY0wz6/Q45npjBG852G2fhzmqZiNdNBnN3gyWuG6nwkdFpyjcyLkWpmhjz + zkTygFPXsYKeJj52bfh3NIpvm+O9QdBB7fehAOJUMy/IWnivjJXZZT0yWSqvP/D1jpFw+5WlRj2B + yt6xsbx3obhrEC/UUI4liXFnZjbEkDPkdTFEZ+fOcCGv7kax7V1b7I63+HbSuGnSN5a4m6BLGXEj + VdXiymOSe0WPQKpnCAPo1smcB3HGq8ShbF9DKQJVNdPlnzHBQaUKctdIeE9hvGJNdKBA9L7vytJg + +Z4lcqgIMyBY21dlXPumAnESYbOIo59AdLLfw4QQyy4NvPCwfhFepsR0GLsLyzCXmZprfLY6o4ZP + JPoGpTvrEYLgcmFfDRuAjJo8PO11VblNJpmunStq6mzhngmCJSISA6ZsjWiX1+z1CHMS40C0FWBH + OBUJRBJNMGuNSK4ecMfrXIxeMV7cBCvFBeZzdhrWytx1eSC5mlbBjQkVYpFxb9SFtzdrZW91TwXK + FM+JUw/vTmxAdTOJryguTXV90iSGlpUkmjBtjRCIqGTdTCBzkghIjXYmIEQIDCR6NuYy7E71Oeae + hmY8iFomwQRvmKUiD3EbnLsJow97+7rGzAAWUdxiMYaeTHd9ZBjjZg32Eu+aPwPXS/9EMRuN5jzr + yvUTzEpzCMg0GG2Tb5Cb7I50SPY6SeOFZJkdEePaK4WYyqQZF0RpV1IMIdvK5RjyoKqcxlB9KQUI + KJqVEc7cm6JXy1PENV3XrsVcx2Wr69J00XdiWtOJtQCR2A4e7kRRZnmpFl0PaseHPrBH3UXbSvhI + SFNaC7B1pqbdMsIu7ZEiPQonoQElYPfQ6ArTqITYddM1cUDXqihwUvB8OnJuydPSHwRQubltEvWL + 7MYdEyamEy4y63bg2XOgihqunnshnckoKL5RZpeh0OrYmQSXNgCmOzRPbT64uSzGZlidfDIHwnTx + 6OIJMdLYD1whjKZxCOBx4uO3NFO+ifumay2mOOfCUzb6XOKjteG+nUVjxcpg1qnVTym8XTHdg0Zv + 99TghI01K6y6Vo2PsJURyq+FSPdLi4UzYNxL6giKkb8rseceDArVmijEzFzSGsnXOa+fA+rc5zHP + Ks2a7TtmD4rqFMfHxQDXkPoEjFlXapWaqxuMIa7SC3+ksG7OlX24KswxrE2l2inMZZdhKa7Hy5rl + YRYjD4n2HvV9iCkMZ/PId0uXQz28fQU5TJp9wyLFdQljBrqTmighnOYt0GupzVWWh6gSSKmaK8e7 + 1O6wCkXvqmxlsC3WQetRSjlSp3TZdb1xaCVDdbhLy49gi15Z4RpXOcVtd7E8QgnnFQ1y2aN5R5bR + GHdiqoHnoOttfY4MFqFFj2yuhfHZDaUrZJe8YFazXhCyxWqx00pC1eEOzQN52FjjdnhSrdA6VpOy + Fx5C/PBoFROSSB+rgXS0fTRRdXoSMqjETczYnoH0+g215Yan5bIVaqIq5lKZViCZSrO6poWR2qMA + 6p1FBRipKQRLCKMaXhhifGU96+kec4dKRaPes87VGnz7ejkYbHe1MSpItyQUCHvv6VUrw+l6uGxl + UF5Ob3hj7FyopTo72IWlKn+oMPcRc9wjK56VSfFAOLluOGBy30n0w+OysxjTc00xumjdXdLoDmUC + IpNcABKDn5VKwMQ0pBqqZFQGNrZHvOnYU/lgAUDHbm8WbjjgnrSDWU1Yocj/8S5lIsLOo0xltBJA + BeExkEb1OHgOb3B04kDGURPvzPVu1vBfGIBZCJq86LvL+LxTtXWL8VpEoCDPrgUApJR4c2pPSvZI + HM0GJA6gaLskUEKUGtrIIi81V90YRkhRnkByWtYHcTynqwJ2brG7AnSgtw3WRAUjqHGqnR4w9sTZ + fA680Vei5Kq97l0FJC5s2j5xNiuJu7jutg6+LbRMb3kgBEVhznktTIG0Da62rz1rqYN2sQ9RHrGO + t0FrfmQNe+nZAYVBopxd4oEsDCyzFcrF7SHmxF6+W6+PixKCVK6vOXlhq6sqTpKIlNoOjn/9wJRx + Q/oJbZkX/nnAGszU5XGWaxXZ3EnnDXp2EwlYl+3q1fPXvSAVMRqBi7/yKTJ8XKe/cslyStPf7d0S + RSrf/8RWa2TuCLKjHA4bDByim+tTDGd59SUaeUpUkdeAL+anuk0oUWbYU3QKzF+cOO+12CROQfk9 + ULJSadoHABZ6c6wVZCfArFlxIhEzyGInPm87+lDJqz2IH4zuL3fYFuoBzU3ahaxsE5JDQsegkEB0 + vLBSyGzMZKMM41aI9HUUUSi6ro5uyd61wNVi9BQxzzY57KvU/l1RhcncHYWdgMHAtYp52QwNZpfi + czE1w9Yy5jzhXJpssVfBZZ12j/vM+zJNicLoFFm59LfXsvZSXi1eCnbb45lXduOEe6hLajkhrehM + yqZBaKeXHnMSmO2uufVb9RWvL+5mWBEm0FE3hESjkbh5XangaYgq34WKwsjgnbGtBzcLrl6M4PyU + QxB9O7fNEGsNEhZYma7J1+mzzjBFyDRry1zQpOIh3jd5qWcbdNUzMc47paoOZRBWghy85RguqfYk + v7aJLqBQkqU0GTvLLas40jGHOAFilNLcINau9oJXsOCzUqii6zKXL19djQG5s+YXYrBzC4p6uc8L + 1+cqnjRpdAeZkFCN6QLehnaBUvTiJpVFBtnjWk1WxhkLR6h1HQpjPdwJs4NR+sdlQQPg0zqhfMLg + cqcxa4FG1kKsEOsCwWSAKlHl+yG6Lw3hIuZ2sUY5POVaRN+dercwZrlgdtRZwKrM7JaoOQ4UkLDi + +ElfoxSKPMudGAjSzUtqgL3VTrDja4jzpyt38IYY6BLJzIjgcJ/XZ2h9X46gxrB7ymQdSXtm7HAH + pTPI21kOz8CVirXYDfRthdexzamE1Xx0Ch8Xk8zl/iU25bShnSVXir/bCyuZfgvPPimXUnZffgNp + 72lTQ5Fbm3QULQVx57WrppeVUIFXB8fapvBwfPghLKK6+f9Q5miHfGjYVvhMlAzNearG1ECqU1OP + fcWghGjMcRUVpNaWCEnyOvHvqTnY9pbHAAryZhrk7sCRQu61YOiQpCqweiCDoEIJ2GAfy1c7zLmQ + lpQBdX0d8PnbMkWzSGzlMbXVEXyH7fFXsiuXd3qXTlUQmbCjvEkM1jPzQNHT7jWokLqdTTgwgbtE + 1aK2LiyPFSLrpgjTkHs4k0c3kHR54ZIwfMCx3I7sZ25ue17IFKxZoP45AtLKlfZUdidbxzBZfm+k + SWmBIMaGpmbu0RFTeUEdETSCe1036ogxH97OTXjfwO10NBnM3ojEiWjN2AgTY3yqJ8acYqqbxlYt + uCsRmqhh10LisgooGGZ11bfmSOmugbMrQcIU+oJwCeCnYuwcWCPFTi97NHVcSsq+3IEN4h4DhmYo + vFYwaFLb4K+AYZHlTRztikwL1E4sbQ0eI497Y+3Zw02jDpA1HYMvlCJa/EafFkxAsUVrbFmRPgWD + RanIFqiCfxJcFxuXw0SDRGnISonS8Tw9uhO2w4bQ3M56wjxpk4fb2VYiWQgxOQvntLqrYyFxr3PB + Guay7moOgdRhOyEwFnfmVkkMZfa9apUC5452C5wLDY5iBMjbuO2auywRqEEBFUX3rIZRe99Z7eWu + 3POSbc+LzSRvKWgBGren5owdXPPq//pOWzYdVwZlwypz5h71zrWMqxMR790NyebjMuKQXMLS7fbW + b/yS5NY+N2O6ldvhDNxgsTXu0sHwbMffeFf3lrklznIXDK4+19dhFMn46JLuhZUeXaSpYdvK1eQ0 + a9YeI8n5mg3mRRtjRkGzYe9Qp6wkb7WUCuTdPUFPm5Sn1MLCPBcJGXCHORxlDk7E9m6sIY+I4Oe7 + dq4xhciWcvt2vepqKMkjdUdi7ggYPfqceAQaVYV7Rxoyz2rj+5sigTdMwgDoVR6DrEY7JvV9KAZU + sRtkFkdjF4VR20cw6/UcGwzTbhTZ4MpSbv4btDXV48uBWrSdYEfy66wGA28vc9vWDYbpzIqn25it + ZiavrKaDykecPHFOn2zrVI+yHmOn2uVMDbEOtREgNto+Pyr3QnJ0B2sPoeBbhLxja95Lex1txoWt + cwOglqqdt7NTp7FXFf0nvF4wm7JRq3k+GMtb1DTqzqKeYd+QZ1OlmgEwIZ2hqTvjqNk7xXpuhzw3 + C53xFX087eJsCYJWoSOCE1PpTubKM1dctpef9yyARS9P5MKphyLrKqbyd7mp/27MVUoNw1JpOyDc + 5pLNWB7TiXAP3ytF/uPLOsInW83rUItCNVNYOL6FpMLXw+9wigSCbtSa57gnIZL1bbSCuRiPPFix + fz9eRMq6eg1icFahAWLjbFw2qXl++YVhz7bvedykgqK0pNAoNos0WxZifDPZei2MgGgpUwbUxqb4 + EN1QYyJpn4MJPFrRRdI+LnnLUAeVdC5nhsldVTNNh6lyy2HvZpiqav2+h6VFSVr2tblpTqXLC96Y + 0OPKc7G+idFtobq4wOpHCzdor6LKzSyXILRu4cE6i6I/KKbGZqe7SOLidT5dQvPfg1QEnZe32DFr + ab0fmF2FQYip8VXuzkQ7qOCQwNwgyx7LTcEMcs/VVYMDcp2PyZGGX3FhLC8uaeMcGjEOAJuWVEze + HNumfTlspLCa5Lae10RO554rJAO+vGIZryoBNWvRYisgw3szuRg4uK5vcFXBaoMuU+mtV8jdtJqd + XG7YjNianOL+u/HqPn8ZyVcQxYJB9bZBhFbMEjcEhRTGjt5eEWnvUHtTV5Gyg4V2PlYjLL/aob0i + a0DJh2Du/3EP7k1QWW4CrwqDJo9FThaFe5OLSXfadZjIrylV0WsjkxD1rBSoBjVyrgvakUcMd3tu + Ug2fZuzlLYlX2Whvn8ySo0kMDoBXEj8z7wZtnvHNbFWaYtL0NY6SZNVAcRvtLG5b5QXpbqCKqfA7 + 17OUpRtNYR6vSyEF4uouHDpn+AYBLwKWKLYqdavyQuGtqlZVmGczdTzt8Aqx0T1rY7/QFp3dK4Qf + xOE1sn/AshqD/taAieO2/XaU9qr1HH7munWuTgM2msssGN6trEsHNm+pQZcHNOTFPBCub9lPeRpY + bwaOIadnxxC/7ZQCWhs03Z1j/3dILqzUnAX+BKJ9eINrGYKONhC9SIs2TCrVm8xaBy4wH+WNmlaL + YE6q/7dDHsCHMwcq500U8R7S1qVsnuM+BsOGdE1pxHAGXSSODpPZEGUo5Ej7dKXR74B9ord1vhLP + Gt2wVaPtry3S54h254sBa5oj71UoFifwUM6iC9/8dpEXiLxiyEb57SLBlnm8HS20TshfnHOZHD5b + aymQ4ul73Q0ChUHqwGHY7GCm0ABRFBLaJcu+XLvcisfqFytLbBLPOVej6Y7RGCzKxiWzMDAauUXU + LG0Waa6KQS8R+mKPkg7DYYwNSnJhs/ZwqNBn3UVIM80/N+H42p5eTGzjhozAD0HjWmZlvwxVV+vX + 2xRlly4nrI1633GmPzAs3pjrUhNVYXH8uOreUgW8ZzJhUMWLlIoRO5IoJQ6L5Spor5t0VjjVIFh0 + 2LSPl+YOYWqbGMBYG0q+I7fAZjyChu/C/x8DbEgfQGYGx8hsoEJywkpk046ZmUlVCWZxtYSa9+sq + F9mW2GuN1lEcsKeX86D2lBmjYDd0X2ew4NnQRix8mwuWGJsjuJFi2Oa2APL7Gc5kCPF5udwOrWyz + 1gKKPTydZbONGqNdCjqeU9javhuu+s3spdIOrxZfqnPfglhxAec+bBt1ydYjyWCZZbtH5AbLqUTf + at0VsHtWaa7UEnWEXcHMW3gr0xJa+mAzNHW47MTaUZLjlFmoZ/N8KVrlmPfErHZBPC06r3GOwo48 + ERN5JmINspvIOSnBni0yakyNnrork9VSD1Y5N/GItS1MfZ129YhX9tSGoXVyS3pan8vZlR3vjsiO + FaYjMggVFS+91DC35M2JEw9oU6zPtPr2zOL6yK74NtBfGN5nLh+3HM2y5VZWK13D4K7sAa8HQPGa + SFkS5CGpmsSTdTvvjnIwEclW3SKf3iP6DrQLNdpsJIom7GaQvxxXsy/fKEfX2REKoAuIor002Vmo + E2GdeDtXXO3Wqbk60Sa15IuLrYOqfJbC4gHPewBduTVf+tomAVmDIWNvrXVg3iF6w4rxhrJXg8fQ + ajWww2GTJDugvB1sUwjZBjum29W9BsHWm2cs9nbV5KIAN67Ricsso8ZIOq8YpTMJuM7FaHwPAOpC + ljzu9CtrMzM6bpedHuEd4VyNHbWkuYGvo2n3Md4Kf7nFPcDUAt2w/hqNNGSiNE1fXrnUuBJD3NOg + 6XVTtdFquTio8fXC+wUVPhzMYhsH2kCmhJssZqsUNzTNKZ+ehoiK1jRqI0VCdKkJoHEPB5RGzOs+ + MQhA2VnN+g61MP0BaWtnNCyKVCGwobFmoGI9qPRZQ4kC3+wIqfWMgxo2OtjXsJXVW6zdOwRRpery + KWRsILfr0BsulEvDTIyTYspJSBDUsr7xNXVzdGombNoOU3k9zafkQt4Q2+6xcOGpxcdfC0gHNc+4 + oHncQNNTGMnhqVu86sY5pKnKEBPqghH2EWuCsRTu8Ogwenm3qFzYDWbaDSXKzlSXNg5GUztNJwgR + Q14UYpKtMpxBba9QYcNMxmgJd9Qg6A67b9uZ8xa5NoWTZfay/8OGd0Uuttg+lWSV6Kv0Q7qCsgOY + 52slT18WmLrxv69NbXRV9PN8MqiA7RzLLe23Eu+oe4w7hzBwuMU74pu81YkrFl0eYaKkp5itSQ+k + 1bKFTUvKedZ2ePmNRXoLAYe1bxJ8Rh1/ZUTw2nFp5fIdJEKMXl1glg2l1KM2JQ2W6XisTKZNAgVT + N3iC93KHpCAyk+McYpgd4lqHcQLhkVzbAFnJFhDIoLk5OieGpoUKggtqUQRJY44iWGhEjnFbZqmw + bmmrD7JJbXDbLcNRlLCgIZ9KhSXTZ6fr1Losec/+J4GoaE5UjDm4UTtKNm+EF6DB7YpiBiTLnG1x + yuuI/ANFFZsRvxYeI9+KWfbd7WB6qJjjht7x97aSmcq4wJ5cSxRqFZhtn5eSMf1eVZXIqIOGu7Nr + SQYoPZgneE7Dm1aX23CwO17eHDTqISkytfaO0LbuILEKMTJ0h3DBdlgynDtUNY7ESfV7PavK/BYP + XYH9H/ytRe8ewO0rOWa1d64BjyA8a/ZHW3KUotQGr6oXr6N9igKe7sEqIcrU2ZG8JzRer25U36Hh + MtLyQvPlpMMqD3Sgggy0DjUOO1glMoHO21dtKBw90xtgrlYG22A0nGNvRvZs1iGmUVKOCkqFA7te + OJ4hV/sP3+pD6jDAvNz+iaAy8oyBZE52k5DvL5TuSylejpKwgLAYcmqPAewh0Nf9832H6FSKMQ6b + ZjjzzarIB0yp8YOhDVoSC4KSHNeF+t3iylkW7MdPhjaLUPWYrwWVpmE3wSmJ+XzNpaFC4Wyh1hm2 + ep0gsqMrHqm2Rl22kK4FdGu8Zgd9yh3SORSdmWwRYArxtMRoRXdUUVatVbs6zrUQMSSiGnb+agAk + GSHIOhzrMDsETrLEmFZI7nUevcUj79RWF41eZncf40rQ6+UFLg4lBdMbUqvKVhD549LKVuGygjdH + cm2PPHYfJ+wAmZv2S8uwzKNXLcJTojjy6CsYe2ZPfsfBI7kaVFvYY4RHYXiddGdJQGWNRVIgq0fC + UHU16ogF16xjBvQQGLiy6Ui3rtXwnL70RkU8DzI/Divms2ZF7fBG1a52BLil2mV06Fc3EkJm8RlY + zOltKtpze5bFRkZ9W2dYhqbJcmbTyjm0j9dhnd0oTiSIfFbPdEtolae9CCy6Ftum421r09F4ixX0 + EC5ywbCYz8lgtqavHO04c1ut2JAgB+ltdTVQQYyjjgKt3HWbviNM0BNXdpInYQ0UGPdC2R9rpsvh + vdUMpqogj6rDi4QuEXq6AbZCe9tU6jCCJHk6HSlFWQWKN9nJ5tBwsjjsNbPEXrHVGNDJLCU/9sIi + 7vOl9n4xBDGJrs7plr2O9HCFjHoBlNo2OLtCSk+llla7R9G1FyM6ujXnFha1k7bojXWNAdNCr1oo + Irt2w2dMLSHf/RQ7ZsnXHCaq8JwjM2FdO/K8mlRJPWJuLULKWOHiHA+MZrNXYkE7D4gW3NTOXnh7 + 0Y5pAdeKdldHR1VrYUZB7eIY5AA3O1JD9IA47GVBd8Zp63p1QfYayoGs2Hf3cFmD/U61WFMHMbkW + Bik4yJd9vKi0VVq2injeSUTtnD4uCxQJvOB6xBj2VG2vJdaTTeTEE61OPg55ODcivsK5vAp10d25 + h/bVChqvtVbUyO5h68470hSbvq4+lTp7CmT2dgsJ9rg0qJou4uwFINc+ry6XAmDPUQxjzJEdfTV3 + QR3t7T3BCuKEdFGtPoMg73Fok9vkWX7jHpe0ZZmjV+pxc10B3GgEsHVHM1cNym6wIAkUpV14FCnP + HYpWCDzUDi1WZ25628iu4Gp9XuvYmLk8RH6yV6TVr9Sx+wfKaZ59stc9eho4Ng9Ux5TI/4lep9dz + 41KkvwG1/pN4QxOIPpdH0CJ7YhGaqzmPdz0M1y2fJLeoGIntJfKzFQr9mDBH2p6Q+JG9QxAlyzOx + cli8vVYQuLPRgsZQZ+H0ZFfqBqONTlQzdnziYsEtaitRi0zJvqoBW/WafRROCY52cQoMU5t3yA9M + jkfQ6dvjwwtmUgPjhtsLc6zwusnTc+OVj3l2Co9IbpKXQWNmJceHU0LdJrlz0egUc6PXV3JFFEZr + 8o0eu1et1R0tyFLXqw0MxR7Nmv0e9lSUS25yjbpRtj+3NL0Hd9fIsCWv1sxhELWJDjGZXlAY/Rl3 + ddef1S21unD98wf+4/+/PB5//uTl8Xj+9MuXX/34fH88P77618frjwLhn71+9uVnr4Be/6EfZMLP + /v2Pz7756vn+40v4189ff//lp18//vrxyw9f/fzH8/2xMf7m8+OXj89+vPTjL4/H/1/+/2IAAw== + headers: + CF-RAY: + - 9b20d5ea3d1af564-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:03 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '51' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5958fbf6cd-hs9xp + x-envoy-upstream-service-time: + - '313' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999988' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e6d07c3cb9ae43c8936cedab02af6fa5 + status: + code: 200 + message: OK +- request: + body: '{"input":["Machine learning models require large training datasets"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '128' + content-type: + - application/json + cookie: + - __cf_bm=v1JKT.AAxWOBYn9tSh6SxhMGZzbmGXCSbDi0xgUBF5I-1766419263-1.0.1.1-fpdkGq5WkzIUvEBlidlSozVbPvZs2RWNICjL5COTKbL3crEgawfYfbd0o_HMRTtAm132s48EMa6k2OPRyIUvzgeRMu3_PJOr7dwnLHZJ7nY; + _cfuvid=NYGShCe.FDEP6WeRHL4lrKiq1tAJpukELaEHLZh7eYA-1766419263905-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + QC2IiGpWD4AiZJjbirGkfIzair5NNUwPRNl7OuQ8EPz//9J6Of8EfjjIS8xN7+sh1Ub1maBDYgnl + vvc5lRzVaJ6QTiGdctKWY2FTLxNghDzMOkyxW/t1SakNMgjRqVpWGALklX3b67brlCiSNf+t/748 + Hq+/fP79V198vL4/Xn/87o+P109eHo/XLz/7+Oz1/fHpy+PxePz3++u7v/ernz7/6ssvv/v5mweJ + G37sXdT/6uv7A//7Yze+t/b/Px6PxxNvYNe4dz+58o/QK2/GXz8i3sABrng/O055aOV+WDfQl38q + aduJZQ5i0f34LnRnbXcmjVorH+GJN1TlLt8+J1oT/694g9cbuO6mEEvHR7eLzG3qrpDhOqYVEk2f + ZxUHqYjZz4vbTKn/AVG2Pf9adA7MYp27Xe2bvwyxEa7MqtcdmzvqQXMRYXkHg5K2rbBM5JtHeNMZ + jSM/1hNv8DDa7IPiXJy9QtLaELHYRfhuYyuwa/Z2J9at9GdqUtnD6EGjU+sJ1AwqcxDXuL0ZeAmG + j4g3cKExXMmmG+fcPu71cYLe3bkN47GaQAMaHXoCxKiYiCN5J4Xa22WaDSe43SltmWH2ZnUk9gAk + wam9ALWr8pFxtZyBGeV4CIMPXJxbB++Cs+e9k+aPhc0KjBOyeyOodbUCmVez61BRbFWT97+Twi6e + drEuoQ6PnRgYz303qYXp9jzcNGKRJiKuOVJujdRmVluG7h1WU4haHNXJ+SrJwk9ia5tr3beFaMi6 + HSSxw3AHtSVnF2OeJnmiNq5xvTKZ862BENcGjVBKU4dkw0XMNP/CsWqxukNuLqJJ702E7THloHjN + N7M0YPPyNDKEp5gRIEkBIHdU00Wnh3tMYScmJh7IRbn3EKo9HNRLVIPZu5fMi7scZ9m6BKOAcQ7Y + yqz/OHLjEj/hfKR14EChvfeZ7dzXRhivp3p+PVA3pcTRtqvuiomWna+pPcHNIb+pVeDc9lk5rdjc + qsEu8eEwSLVvQ+4OdAfycHtU3LFl59xR3L3ebXuznEqhziZent0J2xhC8wAXNmfGy4KrETKO7Cq9 + YaSdE1SAPSRPEjKCBIM6JTUj3yrl95vdXHOtFmEJeg9Eh9cgTEhkbYY98foKohdbzBAy1zUr28GC + rqRP0PaqsY/N6Z2McNNdEl2LzVmxZ6oIWjhXEUacG4/PdwJSg+A/hHFtx79BM07UR5m6sGuKTilH + Vgg9oBYOd3hbOzyy0bUxy3FXzROdgKxSBTd3GKUOjM8BfiMhKlgX7tQH67YuYbK0whb2d4KjRgpQ + 7u4WvnzBMpaSRpBj7yCSklttERBGlqpse9Rn3g0FGkgBkM5i2hQKzNXiqCGB6/YEJnwmEx55r2gd + goLpxsRojpXBqeou5+4Ad4bVoYD2bl1+Z0Iduwuv84qbn4s8GsVQquaIsL0+4PBB7FCuL9hYU7/V + TbHEMswxBQqK2EL2s0foyxQYPQ3xn11oFRUmNkQMqPgwRr0648xgM7tkGG9hsSRrzw0gk3O7BzuK + G/ZcHcCyJy7IoKeYlBfcixwrusXUotuEmGAT4cPEtCknUWXDztVug+HbXB1+T1YXh2RQ6sbu8VTr + uqSanlNE5x5XYkJWdf1uxdpCcJxatpEZmacglaztek/Fr6Mzdr1b5wgXqYfrUXa7CmXEDeoSdcjN + dHUdqoYTxj/PSTZV3FpdGPpGtWEYIiRkdgKe9IIjQCHYIuyl7ALZ4Fq5gnSm0CGNV3FX3WsTxPbG + s9h9J7a50KBryvMTgPNE41Q16PaJguxkZ1guLxttH6RAl0smgJi+XsRBDqadIyg0QsDdnAqiJoCp + Tnd3tDFbnPbbr+HlQxZADZIRrtfuBxkylhFzy/Gx994FXE838WExosSGW4JweCL9QY+6O5aIGjkn + 91ZmmnYERfG5vgID6svMXYDkQC5DGxqtNCKb1p3jOWesTjj8YJZR2gVcWcu1MAJZ6wuGMDkveS24 + csztNNAIbGtx5bsSE5C6vCr+CGcHmVzudScc6JoS6JcHh/Z8h57tFEaS1g7Y7hwPJqCH1ejbDU3t + teErLXaNJlikYVALdTftj6p1ga4sZE+1kGIPZts3elXOxAhZXTkXUS5uw7ziaQgROwHBhWvvUYHR + rXieI7KZFVqlru5TgRRUTLc6lFBoVLSNB+TEHPxDFsuSqhAq5U6xFj6jb0C8S24AgNnVkH4lhR6i + gpjsTdgh23PXBkDaoenLLjg1ZGeG3UD62rT+YTQHKmAOC1dVgFJeHj/P9ZRGLWVBbRhjQ5aIuJK9 + SW8P9KmMUMiuqYbKNb2r1FturcCAOdsdmSWnSrEKH+Q02/DYOnEQb3B3PuO0HMtiVNnJ1N70Njm1 + 2oXuGOdDgUVdNJmQmU6Kd6J6Se/smsRkC2aQuArKn6Dara5cY2tz+3OREsT5wiNV6QbDfj4DUTuz + h1K9gsEMbDYYN/Q2dwOXJEWJqh5BDNIuo9g7XVdztp2ghMqdEsRed2dMTIBLRcbaMRi6w3qr3e7R + 6/yFWdrpi1610bYyKCHgSapeT42NeyxlYOO8dsTIN9mKyVwPjoNnbwsM4NJXY2MXmIEzK6spLmKX + QHHieQqUmcBl7DjTqLgpGFSCfpSnaraEiPSonK+YKwrm0FQp90yDJU3ssA7uENm7QB+yihbdd5lq + QUagS44MaxoCz2pFmkQ8x6ouE4ecC3e7dfmcUCZo5Au+4F2ck/khhhVJAFDr7hUKvfamNUUdO5Ml + a1TASjlM7KEOIkFT8AMSbNzc8v0I55MMZ1w53N6Fi7zE2k6OLkmDEYnVddEI426pMTtEAI1csGC5 + 8HREiwVmO3FRgyoAgoD0Uz5wkGJvI+6wsbC7E974kB0Pb6BOrHCPT0zAihvvxhhiB2nnMFUxu9BF + o8oUD4bmFE/R8rykqM8K06EYZaqazafeSHm0tqI+FrF1F5XKV2m2BGywquvpX+T0hhX6nuU8UYpz + vD0qQWZjMTTjWuWm1mAz3AovgrDWLrxrep92o2DLkQFl753Q5kVi5mPWs5BIdKsE4MAN4m4EBM1W + pWINgTxSrOTFWCWQIA8d4oK7GHfjJJe7Eoe1ezCVQSaSoLY2cUurMniIIrxYjDLS8tB3QNwJzExX + JuDW10eZ7zBmOSXb4OgpizDUHc16bhVt84twuZwECEWX1gxZdzY0Y1YoXV+hnjhCzV04UdIBDjp3 + PMjCbMUGKpOIXxWT/rBSDH9iZxqLVkDsBlf0wg477jaw2iYpsdq4ZwGMdQJmadBHrMDxIbJOjE2g + GZB8Oh/EHtBRqCWu4onbYnpmjSp+6MOieJ7Sp6DhyVKSUEZpDlmExWo35igbL198BrnFzO/ZkINJ + t4FqkBixgVlm2o4vV9Yv9vsYHvrKCtzQCnY3xK1KSUUoFqmi1BfInboOKE3euz2DrmP7sai4PsPt + nLokBdUZEX+hzSPU72tV2kuhkLMFQ6XWmm3kAZMdcYAcJLjbnqeICzjTMzrtyjcnwYm+mnCnbKGW + pSNE3KryPcwUpDi1mCXxGk5rzIw8ipN1JhdkGlMLLye+PHqDUUgg7F641VR6ir88H3xK9eaRebm9 + 67CKcYgtsg8GXdFtlZAXh8cYydMlBODTBo0iz9S6wqBHhNOnmq+o8YUC+WmrbIkPo85eDcsBkZkt + 0IPh5OpaInRFje+WuS6kUCOKAhRRmKJJxzK/QrmiLb+uHc4B1sUicyyLi6LLVJ0zN+YoAUwnvUJ1 + xy9a00VZ0jWZOThxwi3OKMAhW4Sd3LW7chHEa8xUbBi4oC+CKypcge642mOH0VCnmSZA9qCiUtvF + BsZg58AtpQgadC7imljyGiE5lCmrkJkWKxKYpuIKFfZM7+E7zs7sCPWomh63XoiZI6Gpqr7JCHWp + 1Lwr9tXoNrm7h5rbwqVLEhC1u2FSeWVaAKi1XDUcO+5nbKvdLWlx5ZS3bKWrom4onmogGm0f4e2S + PBPdlo/SNqOUcor8OeouPTtNXY5bIdFVt9aU6fSpy/McwIAp+WxkxODLMo6XQBhWO8WDUwFyi9ph + xEcXmgt1+Qn6hAaQM8gWGoKbk24uDwhoY6bA1ZD3k75HPUXGOnSD3OztQ/Rlekhga9DaOCdw7LPN + 3Kpx028Q06zhru4Ccki2hyBWMxh+GJe9zADUOa1SySO652be8saZrr57EbEgDUlSTL3156fW4KCY + uqGdX7jNzueL7KLCB4kmpfYJNsJXiSt5YSLaMla3jEfScTsiyyRNtYPzaOU9E1KfMcNs+Nu5lgZD + DhTFp+Xig0jGPalZtqHPJFMbt4553WM5q8vGO4phMfjPmku8L8IonEmdKk1Hch1HXALJJo/hA1ET + qpbGICdxnRGDV+7NT9BTfMGWEE7LsHz9lAdoU0tbcewbxMwFkhjv7InxUUchKxXMv56VAYXCzQIr + F1BvdsQAI3bxHKIxYWeuvGzLmSyy71o81VE86qyPQELPsdzrxUidqdVzFM8CmY/cV2JaAGeZ9yhl + mm0Iyb1bNPuZspPtplDT7CUNYFWlsd7PGS5BcoXCBQg/WegbI+ge0pXOWW27pBrI1xwtE7ircYCm + HEL3J1sWr8HBXwLAVA/PS7JJ+oo+anQSECMfkkyKnhsMkFao7drGfVbCL46qY+m+vtvK2504IDJZ + KzUKxDDedyfgQfcWXyEKxQrMoErLS2sny0yz2x8haN428BCo7aJGdla4u9m29nXglpqh6oniTREH + HQbZmclIOO00KC5LVXzNmCi1nlVTNDBieMIOOOg6J9C2lWoEBKJEURzji0vHPpCKzoQQqJ1LxQ2h + AvzdvQHZlvDhJW9nzwnfWKI8VOkcqo9PLupIbSxIsaaBIeomGTYatYCaGe9K8aoOJUYV6Xmj1hoW + 29gRQLRWmhEIpXqV6Eyf6Qy85ZtK8aCgD5h9DeihNfuFtbcawdXFbeCgRovPyQXYCFyGM5KZybCJ + 7pRyb+s5XQ2hA4ucr+juWc/aHLrEf4fhMD7NiQz0x+5ubWXTp4NeV3Lt0m2Oiv+ST86aNCPVwYa4 + WwPRC4VkXalQ7/RTAhToiKzLkqU6gq61blEAWZfXOraxkJPkqrycbN4+Q6KuYlcX7lzOxZHqmSvD + 5K8cQ0kx21XaDhWUZ2MjkPDKEmKjlRt5yz1yLpR4/RSM8bal9EeEhd20KTvC6lJPexe83uVItHBu + tF0yjx4kBBU9ypyaGXJ4thxI3nGlDrHOMrh0lMPr0xVAHy6jbHL9M+fy6uaVEhOqvdU6D6mbUn0y + OKUQ2cdQpJOebWBSIA/q3TN/GjNuAUu31VMqzF6rKrF2rGtjXGUmgmI1RNu2L9DTbV5QDxegqhb+ + ck/mg8ViD0xGZLhsYUgFp+gJW1djjFh13zlWYPq0t+/rcU7vEzTFdCPsACsCzB0OU91F1HZWDHVr + 6FJgj+XRxedIGy0ukm7UqrlOky1BH9cbsa9Pb6DbdboeqLSrE1+G3egcgBZRZWzwWiqGGD3Rte/q + BPq2Zwbx8iqyJ4KW3FlsJZDURUN9DAQvHdQhdRAhSZBSarFcTw1h1IJQkUPFLza59nVD9GDcGC7F + C4Ct7gmZF2qrRqmTl7bFK79VqgFSt7co5OEU2FzPx1kB0138AOxi774WPfTk1ZNTR/ht26vVGqas + 0Fm8ygyF6NkrJnsBdYm969OBdwzpKjB5LLTOJ0G5bQNhdMhGVLgkxGIpqetxj7mlYwitWVvJr7ZV + PIWwpBnX3P1BbPixh0Q2J5Nt5BLTV/IGnfJH4ns/5FQd8/STThCvtlFdGODvD7y96aw+vm5joZOn + ggVH1Lrc8WIgLL7tsUoqAZWehgq95KjFgZnAlbcK6WxvZ0+di0kcdzus8KBvL0N6YeVEayvU7NYA + bGsV2yLJw6nkj4ya9QZcwLqbAg587WjS5YgptD3ajd0kno3XY24ifPAMWYRaBFSd1/ycJxY/56mz + xo7ds0X6Lwo7ERVNkom9vpBve9E0tlMpoFUKy36AjRtNe7vxze7vA1qanOgDyekK76k9t3X/1UYT + UO7thPKQ3U0+RWf2EvWZTJLyTSRn+EZUd6ErvCOIKneY8QjduiaCeOXSouoetXc9ajvQAgNCQ6CO + EcrAlWcvQQ5houDQVTsNv0Gr54KaYA13hUOs3Hr80S5qN+KtqpQTEbRc59GRxEFJa9RalSqzbNeB + YWW7FINycI5VwvP/zpkBgeT2qFcgTsuUtiGzg/syCO1egItIot8i4pSxPTJGXShYWGCwnZavFpll + Qw6GLAfzHTJiPycQz6iz9kJfecSbeCFpLP2suU5bzVHlzgDL3s2lD20ojlWszDtcSXxWhz1eQOaq + QostLW4Ilk+R80Ti58lLF1dtcw7sBoidygw4q667wfVFpJvsljzFlcSMF+zerNYZyFINvDosuXbw + wsGzuzJPmEYw1CpIXgE8hHrUYjWmW3lnq3c6rEVCeTEbD0KPXdeYlf9inXC0100LGu2TNUcTwoUY + eqmAgWX6ssX7Xt+gq0rxEOg9jKEBSFUy8BeDQh0WZiSjbtQQiKrJYu4dU5QB3RyMc2l0UZAhctdb + ++hxncrR3VgOZoWxnN0ezxkyG2E/Cp55I72SRKpPfSc5esMD4HUqoC4rug9IXXOzs9TKeXU2AAPS + lK8aP1h4o6uLt+xkvFUUjdtLCqzcnbUZQbUz+1bhERe/JkEaoyh03K0/rmf33DRjus1T9d7X/wdb + OF0cfNt1snQ2wK5xJ742G7wUAtkHqhfnT7be9OA8kNQhplJUhwM1D51Op9IEEj1psjvUFRmcN8+i + c5eXNtDlHg5/h+qlNdm17OFdV95q7ZJN195E0YpXPLZsw7K4vWa4lurjKnYI1ON3lzyMmGOF+0P0 + jcc6xLowWblsHZDMOQnJu1qaDWjtp0AA+iK08KxJLi2LMxmRhto9zx3ow7LgxsmFv2TqLJMQ3V5i + SJJsiHG31U2mXELZSlNa4z6IYDXFMKgdcsJC62rstlO6f9VF1gdQTXT4dEDXpkej63YnSChKIZEh + A3EKhLkf4fuhMW4gOxBOnXg5xrJVi1yUObLeZsxfO4gduXHaSi4hL9pBvhEOV4Anvgh2s2eSZ3fQ + YaHR7AMWfaUHoNQLjcGS2+2gan2PIcs3wz65i0FjjDdjjCr0qSwbPMfFWdi8KnXjaQIHazk4t60B + UUEuyDJt+sNrkWjMcXVZgVBDxav5X6moGYq3sywqyzZVwchdwOPN5rZII3sJTexatm2Atwcx15hh + l4t2Tu5pFIlcHUhRg/IAYBcseF13ZLAzy4Qnu4JRadgbkhVkG5NtTJRaaWa/c9Y9VqCHOIHRsVIg + lxDPFhFzpANbBq2JYE6upDsuCa4tVSyLWZAmVvTeHnHkIKhVNQMFnSticJjWXK2lKjdCJ73EOSNz + v0gB35B2lSNA4dr58rwy1AJv6zEzxuzcCUDS65lWm1dmVcmFnHHawozzC5VB5LxF7W/cvV5quWNl + dARMps5AohZqEgfEK/Rm6BuC2n4AYQxRgL4XqsMi0shVAFR7tHuHA482SXdxNcN7bqmpgsuUfMdS + Vbq5QU4qLFfXpTiImanx9KuYgpFWytsR8jHvuJAlz/DpbAf8KVupVUtGEOmixRR93hzPDwJC7u4u + YNZVOc9DUq7q9nBzef2Pp46DgO4ExpdsgnRMixCXPMa5dzYXu0Xp4p3Qxtz5thMyhXzoWyq9xlh2 + UcD8ww1LILkgLYDRC7Wj2PGlzhAJNoCl0o5L02e6ZDm+0v9tMZV4N0vdgiZcDnMMusJTNmCd4m7h + qlaM4SizD+WC23gz206AYFlxPDni0dqtMLmQ66bb5lgGvV5aqRXk1Y67OUXN0jtP3fomKoIORiBC + uwI9eAqwR8OMnTNntwpPhBQkB2Hc5bXReIAcce2amT6kVJBS2OleLhccW4u0xzfigSWqw15iWT1C + bWfy+pITpRVdYI6NfbQ175zs6/PCBB1qMRKS7IoDsLd13PEYsxVcJ8lkGuPWF0Cw97SsW2O3iJ4d + usgOjXy10sW0XYyZYEzmjnOEJK/aGb2Ax2I1uN7ccudijbC883GV5qEFQvKQWpv5UkSwdPHKFUVt + oUxV0oHjSIvHTU3lT10vhomwTdh1khfjiKLbBnZ8726yTFXab3re6WzLGJoYk21l45sSLzkFZi7b + sV9ikSKlPFNYndn4tHN74LFBCo0G7I6QD3tI3pdCVdOMxUKlv2iQk2LIDYzxLFUtX6UNzWZc970w + hSHeQYS4bgqpTTS7vIaGDWaZ4/V7XOFgRq5uzvpXhJ4RY+qdVMpYuspnmuGWAZ0PrAIwCr30xoKU + mwdNUWROGcQnxw7aCNOFvnDKim0UajoK3ZbEnpFW+Dsur/v5Nad6kMZ+r5md9WAj06oSc66NaDGl + TqOvuFvH48OqahXIdGiUvdxznN+3uKcoee2tjhrCRulq9VINC71m2CIuQxGV73ohIERVH01jKdhV + UBVjwzMO0Otr59YBzg/TowPMK6fxlFPrhVGuVT2Je62sgHateXZEhzRDn0DUL/eviWD0LCuHeYDN + SDDLhZ51gTrNc6g60rgeum/HSXpH9vCLs9/UfSgdYe3w6O2wa4Mr2W0AiGIWTH/geO7K7ydpWdRD + A7bMcGouVl3g5O04P2OSaHuJbYYxNS7YT1OBcqSjlAFV3GVBp47zZsxxXIt1u57K6Rnj0KVse6tB + lcIMKp6sdaaphq/MUPlZmgRb4pLjrSD7rpF774Jsqnl/TZS/FTdTj46egG2vU5ErDh5oo0EuL+Ef + RlyIWWWHMovDnq0qVtVUx4h1XtPio+HmOb588hRNnokjM1XUyO6ugekNlZTDnGY4Q8kWwphAZ9Tj + DAkVVjFAFnpJ2sWSGdvpQINIKV5i8fz4v/DsubPBmXFF2hOf4beO5iwUfgOR1K+4L0XmSaqx9PXW + OtshPmLQY5QKYi82ngOC6swUsDhdLU6Q0JzH+nhMCT+2S5f3tdcyagHHGkjSsvtXut34/HmvcOwB + KZrSYqUm39Fi3nPuqEL28H6uw5EWYYeHWqBVqsaUF3OrT8zj8GdLd9TcWCumryzNbPQeC5wppB9Z + XnBlsxAZppbVsRENrZbClK5ixTFlvxQoz/pg82+fLXrzqXhqLAacOXtbSGE4GyuUhob839SuNULl + cbFA1hpsKxx6Yz3Vjdva7ofjY5UFqrdS3knZispsRPA+tQw7Mxc/tbbNyqrtdrl9oVB79cLBH0fE + 7h4Z6ZkaHXTBQv37y4DsjViu4spQ+e3GPmW5uSF9Iql3WQCGRE9V0V7Ct+H/ig59zDBE1drIc3H+ + 3+lnWhJL7nC3ZHWz+sCVZCAg445XCOxQzBfMm/gyz1Sf6XHHgcSaQuecECWnASzMmWoAJVKj4XIa + oKpKjCH7HyKlPCvmckzQpRLatvXljcvRx+OIhVekTcqBYEf+8hniEZ1cwWQ2POivMCxv02NYLjsc + qMsd4ofcbKOhQuddsVl9kJuq5mzP2NtzHd6W+nXpoFf8fBuL8GCLmgI+Io+aEffWXMFUppB1yM8U + xZSHnI3JOsEoiCZ2lmdrYpK6UfW4GpEscTsOJCG6xea4aEUXWK2nVJI98h/t7rFpYoiJUpNrL72d + 1KIT7IFlSrsVr7L1rHRVl3fLCnl4/o1FKRNWKtngvvb88kwx3sAuKdbS65XeVVp6arnLfKoxPIlT + G34Z0A0F1XeAXAtSNDXHHzuyIYJPL9m5RVUz8tP5InpU4BZwRaHaquKAbcgU6vnV4ZEYKO2Ifyhq + pvo6+ILV/hIQ2msd5md5QkiWW/B6rHl13WJFn6IWzX9QD3ZScwjrbmwDjlCf8JcO6XGtjoKadMxC + 2nUdFpZ4eLtdaabeRkNf6E/V+Pe7Slt1F6Y/3/DN/788Hn/+yxL+w0+/fPnVj6/vj9ePr/718fwT + Ef7V87MvP3sCev5Df4HCd//9j8+++er1/Y9P+Pevv/7+y0+/fvz145cfvvr5j9f3R8f+2dePXz4+ + +/HSt748Hv9/+f+LAQM= + headers: + CF-RAY: + - 9b20d5effd63f564-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:05 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '60' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6fd47f457c-gzt9n + x-envoy-upstream-service-time: + - '369' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999987' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_1e78938c6bed4b718cb4c35d42ad0287 + status: + code: 200 + message: OK +- request: + body: '{"input":["Python programming language is popular for data science"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '128' + content-type: + - application/json + cookie: + - __cf_bm=v1JKT.AAxWOBYn9tSh6SxhMGZzbmGXCSbDi0xgUBF5I-1766419263-1.0.1.1-fpdkGq5WkzIUvEBlidlSozVbPvZs2RWNICjL5COTKbL3crEgawfYfbd0o_HMRTtAm132s48EMa6k2OPRyIUvzgeRMu3_PJOr7dwnLHZJ7nY; + _cfuvid=NYGShCe.FDEP6WeRHL4lrKiq1tAJpukELaEHLZh7eYA-1766419263905-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + MCyIEalJPQAaocPnvO1jLL98jJoavfnV9CjKLt0i54Dgv29ZnwDxhZ9p4NDIXlIr1GINZRxzSD4i + 5WoGlXw26peoXsneli0sqiMChNgy6TDFemv9GpdghhA4t1wtqeru8Z+Um0RtaYCo2Sin08evU/ZY + CCGxZUm+/9V/Xx6P529f/vjNV+/Pt8fz5x/+en9+9PJ4PL/+4v2L59vj45fH4/H475cfXf2d3/zy + 5Tdff/3Dr9+9SSz4of+i/pefbw+89ocWfizt/388Ho9XfADlBZ2PrvwzuIBY9enTwAeQt+e99Sd0 + W7qTlBMcMj3+iKp7jze0RFe0IKRremWcgXPo9q5/RWo4mvmXE5LZXGHKYNnbOAMcu5WTQonDWto9 + dDxqhJB/De5ke/XlBO/Au/r4MqWrMaS3lenPMLOW7PuZszgNmVLFne8GzJQn/xLUrsO7JtgMF7c3 + ZGy0XzFwG7ryhGXNsK68CrvTSf/lg1qmbCi50P6hdNXufn+s9Gw53APvFoxyEN0ob4TXqU0LR6VD + VUgyoLwH15+SyJa4fqdtKdLDQubUWz46Je9OwzLsTG4Ch1EXCKnyClQaPYVme8CIhqIYSYbT2T4t + kFF1lRKklwKyN4CT06nK1Nhd+P2UPNfRXrHSbf04B8zucvMDrVDdO35sV6NYrHbXJG7IoLO3fEbo + rU1l3ytU46HN4cGuf6Fq9ST/X0JednSCQfdW9gHom+oA67A5UyG9VBjM9IE6MEh1S81OIG5gHIxn + UDnLPXuDvGAAjajmzspfy+0dEGUXA5DBRJanLjYyyzy36dxCO+yMXc6FUz3JHphxYwpVOAgty5Fo + KQLhDIoH7N4gu1glGvlabI9ZZ7ChyKgcNlsmnmBCHSB7F8rcc0DMrWpPot3qQyjBsa+IzUxorjts + qLNh0ToQ231dn6w56YSiWF2vgZxud9q6omocXISkTuVkxlYvClZeymLm+LtQl5IwuxOii1Gw4+uF + FEA2l+n4GuboDAryhM12QbnPSRFYN6iDNEgGVtGDDQzaBhZTW6Z1GtB1BWI51y5nPCyjHIEqXUTq + EI3pQ1qk7Exyl4nVxzGYLamRjgRTLEdfpJF42Gc1jGkHVFtdmO48q6DRaRSublYHNfJAL5MKfW1E + 4rttezmGpq6p6imw0+BkDRG9vYokjOJgWRIkqN5qw4hzPFFzQjvWlmW7Zk0FKIMrpyEdiC70RD1H + 74HFhqBGO+AHiMKiwIOoFHHzzuIyRSQIx8PjLihRHpIogvEIUwNvqEmdZDlX6nDZhezTgiLlXFad + j2jnsksPmGnPypDqVKBdjGn1Sd/HmVWOBkpiz3pEL6yKlds59N1doEjCDMzKQY7uQxPXm85uUVUs + 4kV9OI/v2oCUoxbrCiUR3eGpgNJbfSEL5TFNZl9h5kI1Y257rO/LDPBIuUUYZo+sl/CEFzw3BufQ + jK8LYziUtDdEuD2MHarG+ZPXN5DVRUxBB3TfR8f1cXeIsyai6xTUoir8igi9zloS8za3/gF3nDmj + Ey9bWzeE3FwZf5mMCpg0ThwqF31PCRHripuY4CTs6b5OD3tITbE+KVY1S+t/twdSmtNlh9u4o6JK + W5f2hFldUcNeUXtIEUxZiyYSKUcgGz15nmrL1OKh4P8vIVJXe7LVCjc+IEAeTyQ7C+iSax7r2zkt + +CIIgzRsO0q6LjqotKmmuhQBTiwJm3GvyJgxKSu6c3iTpmCBa3DCCWh5u04FK0VL2KhSM6fgdKhA + tYeCQN+2Ln5vQsIq+6ypmE2b3WU9utD1KIqvag+24CywOjenRm505uxeBQoTkoNdaq2e3ugJsKZ4 + wVdkc8elwIFd/eo/e23upk9zPm7bzkziCaOxYTSWXQdepmsyEy4GNOlSGZJhC8geKpmRQItgpZHz + nUm9ZzoG1RbVWfWo7TVEYJtLx3AsxnCtQQGLNDvUVq7KF/C0D4sivDHnKouhGno7GCAOtCaKdxzD + NifJHglB09u5K1CN2yKhyH2HHkFgjgnM+RC5bvtyrzp039e27XwlFC+CFtrpx6xvVJNdX0OixUIe + Fjd5EIenBaO6Q4CEprsd9EQK9OEXnFspnwNiAr2h+R+zwYVxjyLbi8QIJWIdS9dBY6fyabvQ6jOh + yrIQWBGT0NVgqsN5AWpOi1iaZT+FiRlW2IaIN9CmjVQp9B417XENZE/uKh+VZCcWc4Opmm1jlNOD + Se6mqok8ZERwdBnt4yZS6fMzjnC7rJ4lSxzUejoaymkihekQDQqj5hBuxDO5ngpDQX3Xgnu2KFOi + zW2QjjjFa6WZPdYVbcae64nKS9e8lZZC4ZqyjIknJ5+BdEXwhk2vGPzqkuOyT6AKBuXCQy42IiG1 + A47iD3B1x/PTdjeWQ69VXU4QMyiUeQrahSjihJHqNGRja0g1BVvZgrY7pe3sJlmzCdZuYkx1El3F + wlzy6b6ctuyRY1vzXTjEwXQr2AlMKA5GMs1coXMAuoUjg4ROz07PtONta4IV3rDCBO7E6BEwkBif + ejLHMIMIp4/MhEpi27OZuPZI7WR4D/smywiGU86u2d/B4ahtVWHmKoVoDkp5xGQ2h7njq1C3aY6H + WB/PBzPHLYydfJjp7L3iXTCUexIL0uduHzHO+LbZAvQF0BTJU9gZ16BdzOHCNXOQnMhwBnDOtKKd + qoh8Cx8GYDY9G+ZYdtsHUZOpxI4edTUFCIPmTutHWeuVDWFudy8vobama2LkZ1o7yEGTaU2qPcG6 + Sz06YMEtjsIsRnuTBSYsPRZtD7AiknFuxw5eRq/HkqF26o7NEFYzbuAZzLk+0LyxpuJny8HunITa + 9fzbipk9R0IO0tdTL6xGa2IhRUv/Ppx0OG+2xsyMnemUa7imGk0cl1eaFENIegrAICM3H7LAKCdq + weJkIm33kFy78BhEgOJP20h3dHmVb0skxoZBV7QjpzJeazOA6CJTIfpwoBWoNjk8gHKSo8EN1z8K + 3TkWesAs1cuObA9jb1pstQcRHdiO0YVj27v3knjWI94Aa1zSLTGSPh45s0K8cxfcEfBs27IyLlFW + Ee4858oCpUw5Kc2eLBOdzTv68Er0aBz76dEW/zGuW7bPo6Yb+MQ8UAKF06P6zAGxVGXKZj3lqUN0 + 1LOT6Jcz0VASqhncAx2Uad+FLjF00x4P171NjUEQNwQG4VY107MDxBt0ExXEbVU9vgLtPbQKqG+n + xNUgG6PuxQ+wOXF3zR5DM0bXjsmwDsqirRqcxggKxzlquSPpPnYIR6SPeDWFndme5VAWYWY65nXB + MWC8jVXcz57aA/lOK93HA3J2Hluw1V374AEloGPu55jmHmZoijWDq4EKqXWjQlp7oNs4hiYpvGBt + jtvX+RbPmEpyFtqsv7k00ILeVPwcEIv0qRFXgPVfkwUFylnvZM5QqVMDqpXibCAlTvfYCOPZIras + InX9wtjdy4FsqcYypzcWrQvJKN5nl2BLwXOt1h7U9aBrK5JuatVdnL27avbymQv4oC9NxdKjkJHA + YPUVxUciTRBTjF5kaVfuWEL38zFB/liX/g1y7HODDHfSvPOUIBOi9goy2FWs1wdxqlidUXw7FPq6 + aCDKnDpXFyZ2+3oHboWktJh1PDRweDnDe5upAFs6zJGiUjgYU7g4UM44G3j/F0wbBOxdD+GqJ1Gk + 4ahqRlej1G6haJa3aqhfRElehRihdn34jWK34LtaqoV3eMCbGwdmDQDvWcYC/nQ3ONwp4XYniFCC + 0/VlWG5Tk+VWP4lYh246GOq8gVySq30NioyYXS9YWW/m0ceB0adWn5XoQo8Po7bcuxb5kTU15UiE + rLkj5cPAVIZ1FoVEB7h59sjFyF7PRNTocXUiMpdMGbKrhF4Wocgdng2Kuup14FHXEhclIlb0BRx7 + 3vKgZuHuPYazd/0OpRzixQ7bl3xQXWNw7FioqbQVjuU/qxQlEUOSujkDrXsbE+w9Z8cLllLj8jP7 + sWfL2dLuwnlVqTQ+HaHJy61f8SossgWgyBHHcxoZsts9+iFE93KQMUQVWpsywhM/r4bw7VcU33aV + 4hkc5oQp8TC2hziLbU1H7aWyec33QLEQFo+5a/V+2xRH5G4aqwZttt1A25PmngZ8R12+ztymFm9G + F4QK9BcxfaRHq62RyR6qiqWBiDYRw13TI5Z3Zz2LQ7Kn4RCS5lxLpG7GbhyyND96tUd1nSWqEM8C + Xf/uXNkj21OMp0sSzKndOF02lXLpUVnPub5b2/ds2BkPil0A1hOgbib7g9/W9pnvBW2Ebevp0AXz + MtyWTTeN68ADonSVwozhcsu0fEV3WMkgwm0WqlYl1JjK+UCt2mdavgKOjK2axnVLZQaO3l+uJBoJ + UqG61v5uh8mEBma3bf56nV7qaFAlddkz1Kmeu5ENu+sQolXAUZowi9hlaiRmFnZCOck4ADrEW6+V + p248xZoGVsdIGLeAlnCF/gmBcn6RM+mBD9auSwnpgdphVfjv43pfPVUFrQZOEFWbNAoIGWxWaGGE + jff7oZud0XaNGqunBn0dVnxVSwmn6T0J71rj6Up+YeBy67oFq6AauSBKq8waRd/FtUYpdXWTJ8m9 + 5jFBOqtxSaPMmXWwclxztwFR8OCj1FRQ5BgTFxIKUbHi7r3YyJAu5845Cg36ikQpZPG4N9upwRwv + BNep9cLL2PBIuU85HhmOJO31Vpce0GAHuz1IJGfSlYsH6RScwlUp+2jTLhVTzNBBbogGTQzOYUjx + ZgqDVo321IGAm7CTdBaCFEY3u41jTvTxJLWqOt8DpneYAOV+kBsXURTnbYz07TAlUkgINciWZsza + jhQSiroe8JXrI8fj4ZaaAoleucjwZR1W8xneJq7l4CisrujntAa+D3Z1S0wk9DlevGAEui7bbd+1 + 7J/MBrYwajwQyBCn/QuF0BfnkEVS1/l68tpKpR5qkDI0VdesPoYy1+cbDFlbDQQ2CVst9dXshbQW + ljTrKBbucJ4a0HDIsyYjtEHu9O4PLrzh2cR4VbD+5ZL3p4QPqEx1+WqLJdrS6WJOxvVa1hnz/coc + /XPcGI5BLpaK/3kAZg0gSuYW+Ngfwxruz9zn3Aqn9Ljpd+adXWTLdPQDhRoYy8j3zYzBQN7U0hR6 + zU7V7UXgsrNxtD/2LYmKy2vYPi9ZCAVzUMKGs/bKWGmq4VjtJYxqsu3ZNpCo1fAfFuHQ7w1p3dq4 + aEV0QxkswJIR745qYgsLIxZp4nBKDOPlcqd7hjVtegEr6NUaCyjTfYCbQXdKE4eYxe1jfBb5v7Om + 1WJqHPvGgq/PfLFdZ6aX4y5nzz0260SwJ1s2nXvgYLz6J3G3zWBRkDmd4zwuFX8RcossDE17VdBV + hodUKTofa3K8V6w2tHDWpvAkCQVUyuBkVknwuAkEXwKJipCNYo3Sla+etFA+hfT7BXG9P3vXqqYw + h/8IVyKdKQEp1+Ffkxc3IVJl8S7zkxrNolMPf2C2VwvuMp5YRrzoPRSygMerPhwh1roIm37meMS+ + DBGEYnvmyBkiXrOSLKpU7LjecnDmiiu+Pci9j+q7mSCzH0U5wM4tqWBn1OsvRm0OKlyx50oE1e0o + sHs3XX+QvRaqa/Ehi9jpQ+lSARTa3lEHDiV0uKOitUnJ0APJ7TxdHp9vJXtse+/ZsJZ9EAapyKre + keDvkI44CAGgd+pEmPAqHyGIp84zHvEuBrOxWcfxayXfaUq2s21RTGfGka492YVvWcR7n/TURdXq + vCEUgjt8vWCOV2v9OnkGYZ2wn27SvT1UTYGMlk5d2PKHScgGxcNZX65V/kUWjtVbfB1f//CzmuNN + tCv70g/2oAwdKzJ5irIbgoxy0nQOPDud6pncVZR/r6J4EvhGenaK1hRtVhq3HYPPibKGZTe3vQ/F + ZxBi+xZbql52sZj19oAq9aQsMG67s2tH6AiulTooJKrNkr/n3fQgsccGbOs+sWg0bwv1enQlsYsb + y5pfdv3qAbv4iy0rk97dhifH0F7ksD3okgK7irNZXuGE2JCzvuAqB+cOBZWsg5O35QlmBiSyLbuk + UTavPwwCD4i50ZjKYdt8JC5iW3NvnshyrZMpCmqc+OiHdmNvoSk9dK2Q2ZM/mMHpVIGehFc0haBz + pSgOcbY8HTC1bjBzneuWrk7QcV2RqjC1usgd7Oru4GzEbmteiiM0SWMVecYt41aNlsnYRGlHp2IE + OVXEhNR2oJ7x1lxnFD2k2PEN8JiWu6wrZbyzQilWXwSVC5YXl3cthXninchZJ23QNjqQfpuSVdSq + l1euTNa3u2TfG3US6eTWCq5vTEc7Y4BMiJTr7R0W4mqsIJ/Nlu9yoCa6dkSSUMDG1ljWJ1dZwirj + cE+VdopKgnl9rpWmdG+wktLZObLQo4IpKqTWlBHsArFMRpzevaIP4MmeDqKooWWYtut2Es8RVzp8 + Y98Wl53bZ671IOz2EusPJGpPaz5iqtxvNIegcqfc11uxYXYdm+cHeQBtxV+MSNVVM0UnBCVSOtDl + diMYp0AX/ItI306sFOOggyljqln6tLxHsrTa6NjVnd1lP0CJUnDvtFTLEcgBu9HIVB0I39hGZLIj + dbmmw4oKU9UKHKtW21d8IEhjD+VLNNwBo6a62TxQ2Wt1lIBloy6vO4twkr46FELOfIeqzE/2DFMM + mTj3nnuOEKPOOOM6JqWNSVmO1XfdsV+okzzV/BKLDZjkILagU8O8LSqdZ0+5AlJHKgtxrcwOiyhb + TCaowx3KogyjZy7TAJN125cGFTb5A6UF3sAp/C3OEeYVRVzox2kckdtaTwwG9eSW9uIxCpUhsHqF + WxgL1sNl2m+7ONuj3TYr7dDrVp5ZbcjvzCCCLBfxQusWY4bOPN3bWLHN4jT+skUFgauLQpbt0GRD + qeqQTtxRFNUFIyhVO2DuekR33tiwAGIyQN/KdQjyltgvhE7WfhhaFVl/IaU6S/j17OxBA3rtq1+H + HnW1BcNWl10TkovjSRbTlZWwDjfIz0Nqd7vk2jrcDDSsrYZ5XDnaDNkbbvs18QODvQ6I+GjNxNtv + IrmIAbvuEByTc2Com+dRybt31XsdB+bVJsZyT66C+KiOU0F3uWdz7loYZTZbGnq7gbhckXvyFHrN + clnQ5B7Bl2Myg8Uya9IRRenSCBpn8qyxjlM8CqK8cAOypVOXCVVzQHWaiiMl4Op6fG7i4W7oWTZg + WsiqYkOZtbEjYmheFozZJOcirkVzoGQ7qf8eUOH5i8G9g+ocY6g1I7OuWuAixxFj9n2oLiULYqQt + wPbeKE7wuLsIxfWkrLjC5ECLotnjqtahHg641u1aN2FTds/10p8zBKurVLFi3mlBH8s9GgLuUr28 + 1BY5qnKwBglXpsRMoTmvJe1IW0rCLc+unhLo0jL1bNAjpRj2OGDDhbk+MUEWycY4rqwaOeatt3zU + xL+sZlvXN/tYsskPIKJZKjNBTqFSl7wYcGVTRHqqbaY0WaEil+kXBcfo+bJ9sF2mwA3kzkzS4tUf + bsYMzjIcqiY6zMA9VLs7L0RVrW3NLOki6zk3l4j1oMMiQ3LVWakV6sQw5ii6UOwse2GfV0GHD789 + XAI8q5sNJcLD7XlpNLPrLm6xUzPckmuLhA51cfvYbGvWbotB3YWVgDHSpDr8QCzQnTRGTxSH3JDU + ra4gqno1Isra3mMzUlOYmquQqx7iumwq6Lr1jmtgkJTFAWk9XkRy6xree5saW08uFzGThWm7LUpN + zVYeecC6Xlm43DlK4jwGWwTagm8WqbSv5tzS8qHuHddK6T7sdotb4vUctxTJHUKiGuOA0FVhdYFo + bK0vaA+67zN3fR8IiTbWJJbpkgmjFi66Qp1DGUA+QVXvvXT2OtBd2G6JD/KCG2YDuUoRUdywVdGO + iybVkVPgvewhmls2YfqT18uQtV3q55p9KzU7/QA69q2iE0d7DgvbD2TXVujFYzlYDJP+6IHK4j5m + c2BY2TvixfKxPOXZW8CDnHZ1HDvgkV8XkPZk0QZ0Ldylx2upSZtfyK0CPd1rMwpTIKXcFgWRO0jg + K2vraPQM4b1pNAEqGU9wq6mxSQZi1eLyYMRq3W5dCPFqc0DsIgufTlks8W2tZpVN+kk2PFLXlnMX + gRhE3VEoNx1CVAtVDaPUk01WUCgwXSJ7FxJZRSeRM9PfA+l74ZkXw2A7dm9qUs0scRNqIEGyPcCF + n1bluvYTVsOrlL+HOqLTa0bdoHfsQj/7muFtK4gWlEeseH/CXfka+O3wBA5/IDHT3I9Y5usKiqyi + IpAr2v8ofzqbd4ahECPWFIEO0CdJKSrZoTR7PCS8qqAeFXWtvRDLxju7KYyKNzymJFr29MTfPVQO + m4WOKdlReznguWfG5ZStd4GSjKjeVuYPcdPifMG4Ypp9BNWwY7BUFUgOcLMrOyz8+GIgcppPW7gq + s5weW4Ta6mDqYeRlWoOBWmQH5C/eUKzDpXcivMeY8XJouEzfLyg0yiuint3eU/K+HrHQjtFA+AWx + sPiP+WSvk1tSnHtWAZM3akVkm7SqGkpMdCdRf543xddJRK3HyXs8xNTvMGa2KhY5s1DjWVFytA9p + /hTtFNYVt1vLFzWDvU3P2teBC3liq/mPeUknXulx7XpxImG7Vo1hAZtBnOe0VCeCImmrTso2MJ7X + 4dt0G10/huxIbrn9PpTfchJbrF8TTkw7RMQprZHxVME1+Y483R6FUkdfs+rq5ByhZhjPyqRkMj10 + 70NklklMO5zvoDZpv/2Qc5JWlUszmuyNEtSIAdBCoQmqa/lQV21wCUqLLq55Rzg6bg6rFDPXVTkg + ZFdY8BTm1Z5DgZpPg1naOTSx9hX0ohsulMvVbfPLSBsrvQsePgiXGK4kMsvmzWgoK47C8G6aFeWi + KVEab+pW1/7Qp+PGPHZ2GVwS5o6twFw1aYsjqLFHZVVXRwmR7m8TyOR3uERs2RYHd2RZTHWgpDek + zPOyZ/kMWLOpdUyKqdqp99Qefua3vaVWsaSv2yh5aTdaQd09kddqqaZCISTKnCxw5YewTiMV96xX + 3g1iVV0iYtx7nM6HnNQ4C1pmwD+bt5iS5UBOLhmIAvVtXlmKU9RBmZNMrGgRdMAqbWOQduWLmTCR + 0LU2Dk4VMUG80uy8dVnMOBuy20zzMrOz8NJwmRlikcRyGV8zN2BL0Q8gRkPrbmuf2GbT3qyuborx + JQMiG8DjUxBpsXLeGm5mkRaHkZmTZu4L88XhTZjTxGOe1FIdWnPz8o7tPiZKCcJUdAyM9igCqdqy + Mc+U2/9vnRgxRZuKmLl3XH6ffIg6TmatLbhiec7JEBSOt+0WxtJi9EW5PaISx3jHtMfyDNmuU8h3 + 65B5AV8/2zQ69HvebkOeUNF734IPTHQQGbeqKm95e6gAQiqq8aeEPKbLrOoqOzakn/+FssPlsi3v + slvmsIOdrT+32m4s2s2LPQJWpVCzXtMqowwc73mmiJ/etHm90G5jjC2h2W4ZlRYYZftKH+xxUapK + S2+yzY5s3vnsIS6N7jkLtb5o7aqZuEg76M1fC9eytha80ZauHfY4uk7HVJ2oxe6AmNxbSQK5sNXo + pXpcq7WzbBz8HMw7mUu3Hm3XRBRfnNRgPkD9obpa+fpepn3+9O2tHXU4la0WjnKAal2T5Zxv9kvh + g9z8YBsXs8k7DM2+bAVl3OhzgYQo+/yB+1QihrGquN8X7mi6Ug151NF63CUNZjxS6a9jKLFTahLs + dJrJbtqApIEgSU/7eLhD+pw5i0Jai2WiLXd2Xi3FVrkdhH45actevDaCBPXz0I13349+3hOzoW4e + eJ1a/ylAODyGmfPVigC57OsqxgFZRVKAZWrYGRux0Dc0ZAo3pwsAhLyVF6y16PhcFw/cgzgmhvFr + dhHLtqvORlMb2/7GNoOblkAex6v2C+NjAdgzrDTqItW7B0Vm0BD7y0mWT//99f+/PB6f/iIJ/+WX + 377+5ufn2+P5/s2/3l9/I4R/9/rF11+8Anr9h37hhG//+19ffPfN8+13TfjPz9///O2X398/f//t + p29+/ev59rjIP/t8/+39i58PfePL4/H/l/+/GAM= + headers: + CF-RAY: + - 9b20d5f82efef564-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:06 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '71' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-tgk2r + x-envoy-upstream-service-time: + - '370' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999987' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_77c55130676a9431a40a9201877fa5d8 + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_none_explicitly_disabled.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_none_explicitly_disabled.yaml new file mode 100644 index 000000000..d82c6bf5f --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_none_explicitly_disabled.yaml @@ -0,0 +1,472 @@ +interactions: +- request: + body: '{"input":["post_1"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + 8P+DiGI+AIqQYW4r1j7fn1FbTweahk7ZqM/gAt9/M3sBAx+QfwxNq7NDQx8eArK/VrIjD5rOqhJS + KZuv0TSjQWxgbH7yLavfmKzXbUt5AAMMJ3XZqLnv/d2paimEJPxXX9+e5/XXt7/+8N3/r/fn9fsv + //3/+vD2PK/vv/n/m9f78+XteZ7n69+v3v3JH/749ofvv//lz58e0Q1f+i/qf/x6f/DTL934rrT/ + 53me5yM+AZ10+z5cmRjXusZ/JrS6Y/cDUyQ3g3ze5m01S7JRT6T9QrwZ9AelqgAtzmCbiOYMETPC + vhIAqEOV9Anutkp85A6vN/XSV8QnQFArV0jNVGitJwiBvP6GV32d9wEKraiGvNN1B0Fct8tFE2az + lpKBop6NeWaBTU0rZmd0h9NPUA67i3ImguN19qXxIK9+QGIFx2PSbM2alw04bhgS9fTtnCS69+43 + 59SuWoeUqqropbg63Lk97WLb6lTO5Mo64LY9awXItbOZMkWcWu3b03p8kql8x7V/duHdRphED1mX + q4TTuzMWP4NdZDzEVjU3QiEqxqYUQzeW7ccB4bDXeVlL0UrIFBJegdYh2h6lDcmQloWAPm3PKBvJ + qitPTAHB3ignTrPGNcSsu5SH2cRgOlHOgq6NrbiHPXeylKr6gAza56WNXvTe1aDvx+TiBLCgh0q+ + ozDcKGPg4m6g9EVG0eFksCQLD4asL6rskzeRtMPkCaEqLCY1JPuSWoBw9s3dyFUeH+xn2p2RDNuF + Ks32ScDXCRmd7s6Nd2nJVWAUCnG8I8uanqK1GGHsTupxRJw6oHkRB1yBYoicRp1tJ5nayZVqoGst + ufEVANB7hdaPGFNxHuh751+xV4IWel8SfQlayGjrPkhDTGKmA+yyQ9Sir+JkT8b3R3qzqmFc911l + iei9qgJQFzueQHF66XQs0dca52gK2cSsZKt9mXZ2bFx87IkjLN1oKp2wp+oObz1vxjpEVHur4kyB + ykpriD1LSJjKkh5X3RAgkiMiHSWaU+P3lOlh+4TicwYnJjhruXQBFrgSdqwPVzVPuRuu4SuvCCNm + AAGph7eFfAawd8qd0YyNbgdSEXZrJ2+Ceo4SpnSV1fmCFxfQC7GIlDa5lQbM28Rsx4ga42HEQWZ2 + q7GO1pzDOxnpwS4iIptD+SmWHdzhIQMNXXsWydBtI4AMLpAISXvsYEGy2GXYB9DaYghmxOou2Vlk + Z0C5EsDbbXYyQUDz7ragkNqRtWdAWB27g4CkTs63CQTZPVrGoOqSQPdHLXa6NmSFt0FI0bNBoIQB + OePKBxaSSq+QYXDKT/AkdeEUA10cqELFxvXu3qlkCu3Z+MzDeBddzLsudg1nGgQhomwLAVjrDAWY + qEkGo7pSCbSeoz1YSeO8MyqA8Tc1gxmcbqBUi33VBd01GinDXemUi2iAvvYiTF22Y+akgZbqjDSq + k1CNaf2Ci3UUYNbO5j2k3IIVJlB1V8a/fhNDPXforqmIm9xMCrm7JpnbASRNcP5qMZoSyQvO/QAc + 9JQOGNQURJzUh8ZG6mLjGpuB3pb5GoFL0anctzC/R6RMZS2QLK+qPS+ZjxZy49ywGXtf1v2x2q1o + smFbf+xJBUYjgZVYe5BC0ZxzcMWsd+2MZoaEHsQgBzoMkrAjoVUthQjXckoNh643rd0amGtL2vHs + VIbjoCi3WtHk3LWzB6JnnZ9buBsSj5BT2qJbc/Uja6mmBvqkmGV1QJ5gGWxpBW1fUy4l7hZ1BZaO + 0LHG2mmYMa/UBccDVlEDMsEPLb8FNTiTijIadIlosDcuTk3us0h3IVe6UdOlNAdf0hIyYgOfAkpq + plGx7UsYfqvfFhzkdhY4d9g1iaQmephLA7rWuAwugInt62PSYs2qwh0rmTtCMHuDZbISp7j5TWHE + GzDKSCeNCQUrg7Thu54qNwYa0Rw5NO8UZuFk4xt0iHOIeAaZs8M2u8T2Cw/kxPAcJmqqyvUpuNLu + y44OLyTfpLlps7+QvFRD9BXkzFRDS0gAHfeCOl5lg/UdMxspb2Kpr0tfFLST4BxT49Hky+AiTtQf + YrUo+xLsYnNnhuo+gtmKhIuJt0e6BeYK0JQyMDRwIpCQz6iq3R6noA6TFIk403PDZBbEqrR+C7Oi + OILU5kSHbQ0piVsFah6rPaV2C9V2MUxFZMKiM/u8zgJKuKsXR7gc9NGnzfLIdjLCXQRU7niONk/b + HEAoDAw1Swq7p049+wRYEJfKQfImxq605BVSozBdciOCLa8bMKtOBVywj1aP/vFCzmLhZ6ihclmp + tuzEizhNrVfs3RZ/BDlmhTqZAnbUa58zRQXNBVQHhgaDyE7isgOMWcszOzVuQSCYVUgVyMMyg/7G + ghqqI+M6QnwBDcdRqav4kpLopJ7wPRd+DhoumS/qTMuigWLxZrcAOAdz2LH1bRSQmjJGUMbHPd3N + 0qTXRbkK+q6PRNPUSv6PZKlIsecZNrIHUu8kb6KKPgRUFT18aGYTFzqIYrrXQdMAtDniUs3/Snjw + zahAX2Hxa5XbqLBIYLXY3quNB4WwlS6GkcqZrGba4lJSsJTbbmpR7W6VdhQlkBAzBVftWf1DuaBo + Um46i6oNkdn7ZGEz41Jtyp/0MQXvAtee9kdCuoNB7pQXLyDSmKPnGXI1UFeThTvOx9DkSUuxBeBw + AA3ETBI6PbXBA3npI8I+wLB93MMT23RZxJ2LSe/MHVKuw0upHj0x6w2CC1lEEcPe7Y1blbnd3goN + ax3PFDjOHaERoZvanO+5dY79Fk3OyVXvDVLeRtv2pJ5tUJwiuee6N8SV6GOxAXePKTbnLXO9M7pV + wplyviQeIWEj4IZx9A482mlzmqZoHmeRHGIdLn8Sba/3/x0sVldisy3dxiryzhjN7saa5xuR0bo9 + ErkLxejGVbd5JSpyiwuWmGkW62WOcDVKqkXmzHG7M44UenbLFMahSA+7uECgdQgB5X2s8u7Uhyzt + 4LgP+GqA9Vun6mJ1uBo6/ZmqhAvWAUOmgXoKmTYP7o5YZLiDFLpUVaagToX3tuetYxlazkbVLtuk + uLjlwhrtbF+9Lho2Fnd+kiAswxbDQv/Ehmcd1SFEFBjJrruumKKyxPRSno3dBkHM9NSMXj9oqu0l + btZ2vRMgrmuyMOTVrT/XFbbpoLjfz+BAjlNIU4OIhVadmA7vCKlbAKAj8zNXhauxlJD4yPOUB4ls + 92i1UIp6+yBvm5a2jAxkU0neVhi4DXo7FCFRZjwD6TaS8oN1ix5aE4q9kN0IKntta9EGcHYX2N1J + fI+18TVFzd3pZEuE2oHiVKoMjbHXaV+QJ69bUYTNqUkZri2mjJfGua1dVtWKZiw2NlIA4lUr0nB2 + TcGRB5lOLvVcmnRZ9XId+kV16iwXa+vYZT8WRD7C1tYdyU6I6G8O0J7bE3sBjiKmqgbG2Qwk1jie + W29OVE3N8QsoTdtCFhS8FlSj3FS2i9f7UCyxx3QqeHW/tD6RDkRU0y6XEeI0Jt+buCU4tce4YNXu + ha9JcxC4eXstFfhmnf2jduouuhBVNSRZ02BrHJxYhwYtKX49yGlPtMylmDWd/Qi208vtYZZR5o29 + 42urIFHX8D/Wj6bn3RCmT1SshKUVZLGKnkSK3l2mPn4E1PrD7E9TyR4wA3HjlHMNumau6KmUbN/p + fQRu4gZ9j3U86tCWvE9xMLc6AkLKZ3GarmSzlF9dA4mHu32HONRNAvqIHr+yQ4coo9gfY1CF0/+N + SpThtHjkXI5SwOhoG5L9XPUSkomxTLIhYg+2zmWWWvqeb3pcxlPAIbfLPkApGy3tp1LQgWFavgmG + k2itNq+rlbDhBNswlpfmuVaNh13HqSLVMCMed01DFOLR1di9QarxbMAJs8AC/1xkq6FEA33H9NRA + 5pSBnYgYcS6BUMnr6UXikWAjSx1pT5sTq3BTCg+wl4hsHp323jX5u1oa07rSeTBOy8PQPuVYJWIJ + 42KD2uoC8Q7m1nPEpCvE0gLUXxPxKoQ2tyk4WHQNyYdMHL3JNn3JdszoXt45FwFVv3G2ieu7/REy + rD9AcVX2iJumBpvV1TQ5Q48N7SXE+CLIauSZzlObdtXsXb//4Y6ROVe+3qtm9CFaPN7I+Su0l3Gg + tWCJZSwoHMQp8HTgy9guVEbDI8BRBfXDL11XYi81fZ1tec1lkSOAV1niO9yg7kzBmgUoe+hI1+p+ + F5VVp3iyJSMZfXodom8L5qqsWxe71QkIlRJ70vwvmIn4GZqWd+ATkAsU1uwVCEMzK+3PMSank6MP + cD3zypA1vqEyKCPXqEi6clF0XKALQQ6ZNP1WXnfhC7ASEneps0pRcUIqwd60fR0ULJzbh2X6TsYi + fZ0Ds/rmGTauQ/9jnE3PhZ/pOWDmxIOD9B1+ojxOiOfVIZ0NKnDGvtOc11fGhaHQO5ikrX0DlB1b + OFrs0GQG1eZMn7bEwRnnWv37e8S1WGVOkvJtYERpg54d74mLadnsMsOc+gpx2A0Gi+cbYxiY1WAB + QB9XIBg3rWRQ2DoBr9lZjvsPyEqpECA0Z2KjiQzpm0EK1yEtYkrGrM5prdLiBm374LXjeaquNKau + Tg7Vg0pOBBzs5bsgbaKx7WUJRDZYZzSISK2Qc6GI1rVwbh0Vr1616ai3sOuBT0wkJQY9HjgwqK9R + ewVEa0PNzQ0agFzwgEc6drAGXYZZcUwQHW+NmeAZ75oEqWHOT4EWzUDFE+qLaqpU/XYxmxoBckFD + F0U6Rp7SZK/HxQpPayrs587IHm1D+pE10Op81Gq82vonfIgOaZlcrUOsKSQTHSCDktITK+4mILO7 + SsXoDOJpw+JMmb0vYsTQYLWBC2jRjYt69LnvN840u73R0IssjlOe7Q1VGjPZJVC9prrJrpvZVr7s + 5hp6Wh0y6zSFLm40KKSLg6irXbdfATQVO2KQVc6wg1HrOzqgnJVtyeRWO+eNOW1RMWTLpquDySTU + UGv057zKJKBj5cvh0MYf0dGwngGAFgJArBgr82fU1upA01CUzwOCfc16dQ5AUGBgoGFoP5+qIMGF + hmY5ivu9ybUKkpBHaHvQ78nZyxaHpqKillVsee15MpH1kiAA5XOTXQFja70+uTQ0IdhD2rvVdnYc + PKEsho6ppdFKV1y2lsMv4b3VxAqT49oi675gn6bNkLN7gw+bV+vlVw8MN7tDU7oRqviIV4Mko0Z6 + ZDW9TGSL4AW7qWazxI+3kcx10EpSfWp2/IDpJJhU9lbDKQPE5/m2JKAtUkYM08RKYU+8skAFwt4T + NLEtziwqHBeyd8W05xtMDEw1mgqubKxup+fIiEvIxXo5KMOMNqZKrAJqt8p5HN8G1rYmZ6pxss42 + v7RFVJBXF/CEL1q7sCkSdZHfU5gS1W0TGqWAww4WYgeabSgQTYboWgETUXRtsAZGLPaya3+cwNOb + GXmwS+U4eULjMtFyhUp0u1pmj5VmiVdGVOyh68anI9QEhvgpBVnDXk5pLVW1oktpVnUSPQyEBjFv + JC3ciVCQEGOOcXRGZHOAc4Pw4a6Ljy7lpBGDz2Ia+paDQzF0Qh9PUDFpUsvBkTiNT9/BQKES9StV + U3GBJgRc5DYZVWlxqOxPyMoTVKN3blsbBoRv7nN8WIbuKpFD30RFRDJxU7x8zuxpfiENTGax5JVW + Z3TLmTkmIj8tbABc6AB1mWSRACQ9OqTslIzOBqo75SpbM8oelrWKy3W6rmul8i1xdzUZd47ifqu+ + yadBe/q4KaASI6G7g6ASk/Ri8Va73cEeHCeWqNB1+q/76JwmDwOX0XRB0dRmJT6HlEqTaXCC4BYP + JB9RtYH9fhILd9ZqE3IwKZb3TUyiexZaEFudzLNbbov1GRDIAe5rJSkgS3FR5R5ylZyk2TM/AAOS + ilRPr09JIbTgKeVyhLnOiyti4IUVrm/2GlfPrwmDS9eOyBCVloQEHRNvJ40vxAPKOZ0RfHGoWK01 + upvk0xMoldO/tkCa1NacEUy3ACTNxwzHoKnIKXmrWCqY6VzpKbljexfMhVyYio4cDRop2JeyGe3h + ITKzZ8yuqjbLmruwbWyfOHu+G8fNowNjq1hMqs9HeOBTk5VhPvMFYDQndRuTyQx71unBdG3Jh5m5 + EAxK1yhtervWfX0ciOI9eg4o+dpMvKLMOvd5ksntmin0NKhGikpz7IqZXCIafDLpeuY7cIT4JV9j + MmYaqfGwt5iN+S4wSjjJPJFCdguakTF9+FmbcDJnp0dg2+5ek+rBJOsToG5L/g0qrIaK9cK+yG1K + 7kith1j2fhphDRZsGnvzUexgY8ox9/C0CMtSvjwCz/a2+ET2ZFkDNg3LzW+ewNwpi1ouz1Qp3ZRu + e8ZSdmO9fOq9ha01VBdTRNe8gw1erjZHQO9Xay6lAVeUsA9sPhydWbDD5HC40N4o2gNyd0fxZq4r + wWhRHXNg2Ljdcj4yEPa8sKTp4QGtmYKJOqOeo9ajPzl6nM3LOkQGs+9qlYhLjdxBWUqzwQFNOT3p + 2wwK4nx2uyUm8qB4dG97bAoqX2wyKTqAwRlMQ/L00m9Jcy1MLht9dUfxMLlX0rdQt2p5Fck9QDNO + VldAPFi93BzYxWThI2/35RHtUyelnXAheoo5+KiGkRSwjkoT9pTTE6VHrAUajWZzoSCJIGUfEui/ + YNTkSMRAKCrQJG4GrFuTku8qrF2XLHuktzrSGCVf2wdoIt0ITc+lSXgiccPtHEc7rMpXuyRuq76E + TnsPq6fETpse1VSHR/EG1e7t2q5kZcbdyeaJaLPRBkmrrtmm2KHgOOL0OdMVPKI5xa685x5XvwnK + Ckk5+Ph7ACS/7ZqfNRjDDaTeEuHzsa3MdncrSqo9raRDxhNMC2NV4QoCVqSdTGv1pCnqVDFWYcmG + XtdH71X05dbwlojk7mqO1SvaVbDF3idO2lRtSPlCqpPkZJwxVMscYfkJzmEXOOJXg8pJCgrGZCG9 + UfF9Ys4urb4OgPlC5R1ZxzZrQL1J3sIiMr6grQn1GdTtrB0NXyHyFNU1E/SYqmPN/FiRunjGZ/Ih + LmqPFtrTgpJznRP2Olp9YR3KnkVCEc1elXB+oALFFRrN0vFsqkTJ9qXBOJfTPiirQT622FU1feIh + R7gUcBau1bsfmEyz5V+lI29YO52CVS6AJWiG2GSkF8XQkUdo3x2Nm2VVcUXo92lOYBFZ0trVZrda + 1tJ1lFYHTtrNFDdmxBpnUZahy+oligJi7Ck0zduUlAbdPXEhx5Dw168aZ5IBMLyDnp14SkWzvYMP + 5Dn/Y01T1mqZGoiu32iyBXxdcu5QjCsMbhHPcdydEbdkbgoLC+/jYnyWkbYnjy6q4RIkP6Cres4K + hW/VMOLP7FVx3RI8pXdMR0jWrkz/zlBcF9dOZGHA0roufP3WFaj+H36NNzxY+uvcHxwj2Z+DZubF + Dpo0t4Hjs0A+tXGer93imby8A1SmYVk/VHIaE63BmMERxYf+Aq+SCdnIUmpihv8vtzB1ujOPrrUT + pg0iJl1U7VM5lwdvwNu93DnZFuEyzbm4BbaqKQbJgyL4xXyRrsYxIxv8zYlKYRPFnO1yYJFsu1na + 0eIr7YStyRS36Z1EA/uGEo55IG+2AMaWelyLvWHPi0cBtGAga78LCHvpArlX0Sb4ci/2+t2Jadhq + Wiglu1ThTbUNFBArrJ8yqU3TQ86lVRJ7JGsmJ/TghWWjm+l17pQdOx/b+EgQJqHRja809qZyL5XG + HVQ02zZ2tw0WbQ2x4wb/MWA72wsRo1hznIvDp+k7tFk6dzKudD+4oAhsZv+RwbL8gLbVNFzPqnb0 + r7j3I+oqW8y/TA5jQoI5kRTd0zmRh/uiGQX/K/dqwhJdDlTK5uwAl6jRRncdOKYLKilsqABTbJ+L + 2QS7Y8MIa8zdsb42O3vDjZ8Sq0pvg7AoN7YCwNK/WaSwoeDf4Kt6UlomcS1KlzgeVpfWcsNXsxW5 + DqgrqZ0mVzNBTWp3Xmr2xGXaEveQ9AHPONxOS7xr4sJVsFObVmDODbImHmROeVaq4cFKcJWu9SV0 + Bzs8tYfoGmjL0i82M1c5GdhTAgVxF9ZdWWuydCfW5vc11IUkKTmvmuk6E84Tp22HZWYzwYKN3sXt + kr3hzuRVNKjKDqmUcRu7S2qbvAkab8yYft9x1haAZ9dTVdPZqtlmy9sgGjaY+iIEHp0iUNMycv6b + BItSlsSq2xUBf8lwiwpuSgpItOc8tH3ZQC2aW5mLzLAPTLBE8J8aorUWy98ZBteZ7rYZorCP3k/W + 2D+wpzzpGw6bQSpT0DBZPdujtAlzoztYRAzH7K3iKJPHsk5nxW1MxKPkPVbJFlWjcxxaQJdC+NEE + 3YnhmV4o4PEbj2z5Jj9X/LLvQqQ17exa1yPQkbWvsIvJWIQHRjVuhhgtoVLAuwB7YEZZEHPjJzq9 + jfSghS21W35Bq9sXQacpOvcQuBUOF+PFKfpz8mR7blPjPi1tUaI5OA/A6v71CvejP5a6ZyOd2/8I + uarWZCT1+1X80wLfj4MCht8fftwOhV5IVe12M74XiDbOY2icpLzmzE+QvQMxTAzTJbIyuTN3pbKC + AIaW2Gi5u9AyUmEqobR3xsqmcDqLEekeTSiS0sX9btI3YBeZpPuqPs2TohmR9ix3l8ptZvHkOXcu + FmeDRl9cdXtJj+bxWrh54fC2vOxJbfknXVPyKC8IsxhLxunL4+EJec019hqpbNA+aJynrO8b9P9F + 5BYHXHXN0QFKFS1dewmJB8Cp4CkdAcQFrdnRE77su4jHw2jOG4uZbJfL/N/O1XHGFjth1jWDrdRF + OGmAh/Ee1JyNXzkXZQlf2I5g2al4eITFCfqgqz3yimc0I2UBYiZoj9BFg4Yr6Qac64L+hbN+JNkj + U+CogTIP5hG8X0NyNLq+qL7WwM5y0+vxpKvjiMLdbPt1D8WxcZCtDQqwM8VndFFeB4zXy/Un0fWo + uGXfssxVk9nHc70MoqET3FlvS/Sm+foN+l1d3jsFrKykyHyc0N49wsmwwY3DeyjvkRIa0AZ7yyPi + aTEY4LyBK7/KN0dl662BLystt6gUJitO3zc6Se34WhQ93OsK3cHm5ixJc+wDb5Ktm82F01uhfwHM + oNQNTlL2EnoIkHqz+hiC6YT8eB0cDuMjJ6x74SWYflpm1QcTpOvljMSyr24znGJbyYwOCUDaDw1+ + U0UBBO3I+WJoHW0UMUoN2g2ODJq8Fpf5xVdj9nbQe3dKygE98txqE4kZtgubthe2Z8hLTzqHQfSV + WyIDaCE5HJR51zFV0WVDpby4VBhWHkda7nv3bsQd9V1pSjlVUcNkd5/P6JV7q0a6kmgwElC4EMFm + PJTfnIVTgG/oBW7ZcXX4aOJKbT+pl6rv7IX7x7HmuUBTA0vaVntXVSxABGV9kiCEREnnzKiVuBeS + xh5Li/M4gOIdltU7uN1CfwfTUNZ4oPiBSnJmrqQqqYxNaubS+LOldrych0T20jLwkrSyCeLtHTqm + FSTwvQ38YI5t+VzJpWXoh34TqK6tjAL+Mu91jEsKpxls4H2Dd/xZ9lAIiWz0tnEQ8x0Mv5GYaYY8 + IiXLZYjDNhHXu6cu1+bkF6Yi8Ji4iO7TQTeFNFtmTAU5EF8FwDltr9wW9xA0paaTIPGGnEtZCF2A + F9bo3rx0zPuHyg9m1BauYmm4DR16ot2TkEQCNV364qilafDBCoZ4KRrMmlGDIUQVRi1YezSpvUfD + B+PsqAwaUHCNK6Sa0wDnEYq3YUW3ddxy24rDoN9zAXMZZ3EZoaxZrMGkYi/QmLbwQo5S7wsNpOUB + bV5I8jIAzFYVd1S+ejYWza3KcVYt2nXUfZHUHeibPmfz7KZ4JNe5S1wECZmBaDRtp+IVjd2Zk1V7 + iC3ndHxAevAKSzUF05PAg7bjEbxuyy+suJ4fpLF+VqT6+n5IZEk9mFv5HUgOvkH4ZG8U4C/cWb7J + b1ze/+b3/788Hu//qoT/+f7Hzz7/7vnu8fzt879+e/3nIfzb648/+/g1oNd/6K9P+OHvv3785efP + d394wn8/f/rlx+9/+u3D33789vMffn2+e/Tp3z5/+/G3j7979O2Xx+P/l/9fDAM= + headers: + CF-RAY: + - 9b20d62b8c20cc1b-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:14 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '53' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-577f9fc864-tnldm + x-envoy-upstream-service-time: + - '326' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_903de4b76c994994a94f4d4e0996e42f + status: + code: 200 + message: OK +- request: + body: '{"input":["post_2"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + cookie: + - __cf_bm=j5HJzpmKw7Wjeiphq3xCKM2X4xMwFMxXNBHCisrL4sc-1766419274-1.0.1.1-_ip3mexBFeS4g5.O2o5oCxDferQDcaBqhVqDn33wpMmeGoYL3IRa8EB.vMsf1LnG96jumDBiJIxPJXNCI2Ne7r5SUeJVHPzxQxLVzjGdMj0; + _cfuvid=JYpLcVrYPTkiuaytnqsIYdBgKXFtNv4Iwxs.chBEIlM-1766419274539-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DJgUxIjUpB4AjdDhc97+x5hVvo1KRW+mHn0aZfdokfuAoL5f1r+cCzEJDlx67rctoRFbKOOYQ37P + uXK9i/qhdxtNjVxXy022bGNRhQgQYmKyaZFKUdVIybf2sQYDDMN+qstG/e/vTq1KgSThVGZkNfdF + mf0NA4yxZUnkv/Xft8fj+cvn33/1xfvz4+P543d/vD8/eXs8nl9+9v7Z8+Pj07fH4/H47/fL3d// + 1U+ff/Xll9/9/M1HYsNP/Bf1v/b8+MC//sTGD6X9/4/H4/HCB/AGC+iTlcvgu0U9Qccg8BMoHQb1 + u+aGf/8H+ABh3Hd7idyltAAKDtAn9xQ91JAfQB3c5Az/AFuN5q6EaszSzKxsiJoa/T5mKl2UcoKn + Qk8WNkhFp4jdrruox50C7DXmV5e7NLYgwtt5zLNEy/inQl/IXjgHYp2psSNoudhCTgHHsXv/P4dW + mF09kdGyLydGcrpbtxOuvrmqFSNQkMvEltGuAI1S94VZ7XSrdkozqkpWvMazTjs8wQ2YSA9Lxilo + DuGqBoairC+BjMVuRlZfj2+dwHmvNCuU6BvBv1ESYuPmn7IabfcDT6GcbcA9oVnliGbELNkqM2bb + HEXAFea0m4krMz8nEVCO3cMdei9ETgFds9VHBrrpPlM+CR6764jcA0s01WRV6zcwuu2+jNM4VhV8 + 86jWPGrIqJ6u+QPMhDY8Q3f33SOxywDS3SnEJdH+/5jL2aXsFU42Mzj0rkMAH4oVkg9tbm4vVdd1 + 0Thoj5j2R08JCWhUN3NMCCcQ1q75zbBrseIECdO2jz2JM6fzEqZmnExzwuImN1Koaq8lx3m8M7nj + DyQqw9ixHaq8xno80o3Jt2QbB54xa8el9A4HwXdRaxa+hbgBdQYfEBnaiyTUrTdp3bHYVoGx51RO + v1YqrsMCcYtTKZj6iFNCRFAGvAFkcoOotcqVMMApcHVmnOCUdFcorsjDzcVAIhnIptw7RwHjSlco + wQzElto0bodsh4XQVpfChF3CnRMhz9QyNCEpmw6PJCws4yREr3vDk8aeTMmGy8Nmv71xUkNhWzgG + ney4YMwDqS8XR1EoLhinKrqcq1VMOSUQbKEum9ErVcArNhkwFzG0Nn2ZADI1EGIiSE/vadFxNLCl + 2g5DrEpP7gGrt8BC4zq5illIlprRsOH5XNQiv3j0EdnwkuoTtpiuKShGEVlM3AMGjjryXI2xtZaw + nctVk42b2x4T/r248VnCnlllM+Qak1QEcdOrBgPCvLqr2cOeD1ZcMiqfBMvd6YaCccY1s5/05oSz + IqTBqx9kE5rct8XcBPRGgMlqBzBZL2u1gCAH7FEsaybpCDIruPWCmFtuN2CXZFoEUqOMuQDtKzFt + 4B5vqkYxbvPq9ICsOymjcu96eCtyuiZLIbc6g+MYutqeEPkSsEppWexKW86JEN4dlasALIuY9OOI + 3kmUTEq3WmehoapYeJ5SGAjBdHuztXDLk8tCe5zubjuu3XIDDNOedhr7ETF1MgNT916g8SnAl5pr + a04hKS6mZFX9JvLM9sRD7s+nX/jQnVxZUpvJ88uWjAK9M4NMHMKk/KBgID0LcjDrWMKcIAtY4fTV + bThCF31qSylsDzrMTyFi3c3tIIFSYDOTRz7WS0q2mgkzhFv4egGP3lPJP8Ae9ICG2wYXSzRzjPvg + 496Da5DnslpZyI8Gm0LVTgGhE9Sxe0UgsbtOB4yxWRUXU33YZKvaaNjGUJ0dXY+LbZ6hRm0nYbu0 + ihpECbQRXVqZeg91VJOistxxN9YMV6v0cSWy0wBDwVgxLgKjIVfa44q+EapPJdiKsOxpIgbDQQ/H + dxJoRG0c8DnC4l2iXo+Y2/tNr8xLEVyK7RxkRF2TdhlPreH7HTWvzYrLEuq02N7DLE8KO5XV7TrN + U0a1N5vTGQbhdiq9HMPEO5ZBkdlgGxoozqXYCsiRKJMdYDq71OHQZPfnFV01NAVrRdHldV/tBddX + JRdUTTdFiCXL4QJxIY7sUbdd3rLVdVDhQuz4Ko3MAUB9R3AitboqbyMFCgIe4vZ6GZ1TwE4re+It + ejUwMu5LXW7s9RDXU2aKAhpqCaknMAFnPd6Pc8dbSl1VmWfw3fnIX8QDZkoaItJbtCGm0zeZxNai + UxJdoO6k9xDwZFq3wE+a2ItvOl5W7/5R46ov9zRLExxTEzjJygF6smFaHIyZs1kiqrpBWBC8V85U + pywLr13DTjrISHD5kZE+2JFkrawYPK69StPlFh3TUIhLpUQhEkh6V4yAF+rYHs5pW3JPjljAqsBM + sWsLX+9WmAu511KUKhpu482l6FUID2toYsqiEIWpXqYZtxLzQaHcp0YQMYuzUGHLrjYHEJ+wmapi + FpCkbqICiOnUHcP1qgiZt9zD4Og4HLtZVbxi1TMbEDEGSgcODpfxbOXKvqDENFZX4hEgRx025k9i + MQcsC7rOHZAYZJ25bwpu9wrdQvadugnFRt+y2slTp4w8IwuZUmVszukBid2xyElDMR4B9w7XQ9ZV + 6xRb9iXdargZ9FThRN+G1G1GyZDm4jqsbV+vOAGgzhIiMxWXXf54EhALAw4TtlNxIoJUMpfzdnQc + 1VM5ig2EZXmhi5s+LRlQMzKe5vRoFqrZMznrAKrbmJl0NMJ3ii6WAkG3oCUsciGqg9qQlbkhmpue + GFI6WVMTBRdJtFNIq3c2LDzqxsxBBd8YodVk7GDRRVOLWJJsEtK7Wt1xQl4kYh3IuU4GMli7vZuL + xyOCaCzqYi4XVd9OiMxoWpbYiHmrVs+INWwmF+WiCMGu2YG4rTI2B5Bpjmf9BjE5VidWE98MM2Vm + t1RNM8EQm7TYH8bhqW87o73nzpi+Ode0Kbzt1a3IyvjdBSzh0qfgulu6hAyzPTf2NugGUQun5uQI + usPbAYxFt0OmYneurx8+idptc+1uAwO62BKab2boqhyMwVRXcbpo9xrzsgPobh9i6jHAMXrs20LC + oaJ8gKXsWzuUY1emp+aoSXH7351FgfXAOg2wWTt0NlNmyz1g9GfZk5txQfUQ261up66O5Xz95T+B + njWWPWBycev6okGgKWW7eKm+KxsISJ8D2J9XJsfepR6bqXPYgnuuMHO3iW8zZYWEKi5NTFBPqaF2 + K9W/nATOjYs7HyjvTJ1DNpr4XXt5HoLRZWoUJLUAqsdMqIPZbuiqKR+CtJsFS1UVKb2nmp6uXd1Y + Ln6Kd+7uXtnsnG2cD74i32Q2o1WL9XxgR50aksvVtRPq0HAVSxSk9nD773AW74Xp7JHpdRIOBcbT + OhKCXkRxzgWNXCpl1m66wy5XNZEFNCMLoY7vfbMOUNPxdh1U9TWHrW67kMfZXc5ecAHWajolYv9A + qCQebHgS3FlknvCYjQgMNma7N0tQ3AHc1JUMt3pCqEQRGVN0inHlAdb21M1gM7S3uzWWWl6xsMhE + yS9YtlmmA4ZSidYksbqvyx9heeso7g+RNvLQ7fUMC6dwyWTsDQj2azFE8jhodna8Espy4GZPd+oo + 1KNisr8gE4qO5vFLcpme6+jWblVGvAyaasD6+o7LQOiZUJLscBd6WbhItlhM4o4DV90WciyajPHU + JhqB3dBKR+hrIqHBKnosnexphf7WrMW6EWBuNJamijk+DW3gel2pAI/Qur3127W4V/bsDT3hqWbz + PioRw0bpdaDVvAtEKbmMVOSzdj9p1DwyxDQhKht5u7bQNia2WUfPoqxFB3ZZkJUACpXgnUutmsdA + upD3HSFxvUOCMro22NtNscBlBWhr4477CZ5N59rJyx46ywd5z81FuBsTPLgccMVr12NwzKnNFTJX + FCBdZ5k5sQp3KRZeXoV1kbfqyKdkFG00WlStmB/kndo6eRjXXBKO2LwriiJ6SHA8kNMoYyFEaG/L + OxK6q5ynV8Z/m20DytM9a7hzZZpyimzf2tydm1xbkFVmGcvenIYJ0eieyuCpzrCFmBtM2P/B5PTC + 4JIlbu0cxEwEoldbV5O0lnNGbW9D3oRC4Y9728vZMzisjymuXKHikt5QH93+7Ip2jdXdpMdGhaIx + /2CVZbQMyKD1dgEca99WYupw5E8gLebD8OzQ4hFiqi+HyqEceVIA1LC8yA0a6SvgeQASWilXztSq + fHZ1rapjb+bivrNo37V1O9SghI0cNMXWXAyO++GARyxmhSGyRj+I3evANi3Y5g1bM7NKEsK5PAAN + EnOjA4FxSTdPX9Az8cSSzChkllwkq3CMlWARvC1urqzIZZixm94RMVySHe69tnB0KOIWdVX+4Gdc + SWcv16BSlcCXA8kyM9xiGe65TWJf86rHOgjHofRmZYzAWHKKiVreseDYFq3WHjFqXWX4IvQY2c9L + 07lHMu2F8ljtsa+5gh41/lLmCmpYt6mJD2jOxoYB1DXT01haKgeydgdVVZYdpvKWEWCQ0A147B6H + bi0HIrbaQyV58zazbv5qncOH3fQ1haGz7JNalRfGSjvqMormPp4C+kLPebCzSp8SrG6flTTbQhfF + Zrfg4EyIXg7Mz3Vv2SG6QVyvyvWAXbW1uAM5rQaChqG6pwzBLKZ78qfof2LterLsGUXu6uUdpXbU + AnquRS+r2prMm1CciZNGgJS5mle+1W2fzelNmOHzexYxtZ4zx7cQPRpoxVZ3a08YpOrmngzJhStW + 4JmacaJkDehzpG45j8QPEuXylkoEzd25EkLRkq8+mKemJU8iR1HkgYpDj/qsKw3pwmtaFaJYd+pY + Ohx9ybvk4IbLuottbFb86BhxuDWokZZIugx1qVxmwjLkbgLtpMG+XQ/Rb7kWNDhtXl9u8h7enh57 + LA+tViCl6LuHDs4PoWCnXkQHYu8oyJDbnUmZFIxv54NeGX93EihQEW7bPS+523PcAwFRx2v1UBgJ + VUWqdkJfMTMg2R13GG3sSFK5fb+F7bn1+MNik97WEY02Iblrt+0nAS9b6+WBGq/KBSwmHAmog49v + wTdStdkDUs4secFU3VN9Qa9VtjqEiVmTcw9hlIEnGnJYLgPpiP0sGTPoRm3FHrHojAKNcz1jZWzn + pouuI+kQwrJtCVsNXr/pfTzj3aJC78WhEbaayvTY4mheJ9FEo7CKv/gqh1gMNpL9sjkyUwtTHfMi + PWNiJaFeA/GOMTWPS3lUsx5u8SQrehkiF2v5oxiM/CBohjcbCl4nNQl3B+WDwAVNH5+95JihelaO + EEusBcKLYGzQY4jeXFeMu8aVQRoguu1sMZ1Xazm3w12Qz8lFhOMCb68NtXucY6PzxqgtMqqj1oJJ + qA42WJW6JkY6Tp7TYmUKRILP1xdBoeaGRy3cMO2Fj1OahdIXLmy5GOouWzsr6h7iLr392mur7FEU + VlHyfT/BGHUsXCo1wWuKdhQdxb87eBOaHJeVzWV79rhOnSMyfgjP23MTjFxVo36Vo6duF57cmey6 + pAdw/HXt3VoSm5OQwqYIxJV4KISmgCXZH3syMnvoBx140uvMuyPWoj3xVdTtTZ9xJB2G4+FAGmTX + NRony77UR7d9s+7SIG73psfy7gz9osP0JSmK6hSjkVfiYOW4a2SBBkFi1sZVa4DQFaHSbVndxq4B + JJBa8G7YT6UOwFvPlePOcuM21k80hmcuJy8dLs8XPoO4stZzc1ewuOj5vY28ocOshuT8vDevynVz + BJruicBZClZXWMDJyRzflG9gLwYmkxCDEotbRWE0Pe6FtKHw6zuaUk1kaYpH/d9RDN9xzc8gzDQU + pK/CmXCS4rq4K6s6AW1P4N+W5iqu5aZjytYKlRMcIt4eytHML6FXnqqXV4pB9/a09q6JLUjNxdYw + nCWRZnFaCVoevbr/IhFTRmkLAlG1c5b8W6nOztai8Dot5b78vWXYQj8Q28qRp+GyneOvT8FNbBia + ORJvItNw2n9OY49CX2GU119sTQu32k9mg4X+DdWOcEUDP8pQreleK+1inqhjWmGSGpx2ch6lW5Cx + svA8OMe4U0eS+tHVlgUnc4GuOwKHIdU3bC8w04Lqkh1czcCnp5YSR3cw2uV05d31WBaS4TmagyG3 + qONOIa3pHa4Ec7OjumLllrVRz0bOJ4eoylyWpMzMRGJjT2Fy3hlQj1uCex8G35iFQdX1ctqMlWEC + Qtw1r8Bz2BHT2ty0GScdPdc7Oz3v/45z677HcreBzJcAFyj7GUr2+fCBotZpj5wLy7/wCndLl2YG + lLd7ezeySxPtsITiqowH7vI/i6VcqO1zxRgsTwgRBZLuPUi0aOnHMOR13xYtU7RBT1xK2hhyhmtA + R4OQgfWBWFtX18ZX3DmqCAmqKRwBkU3PDXFLcu5UUkOlTkTL9qxyiqJdqtksvpLC40sdd6B587Yl + nIubs+MZiHtDeiZMPD1S8FzTmcOfo3fpFvD4ca8qmnd0pTqYFHdbU7bpIufYIVg16BDN9aGqEHvl + bmCXyvXKQZKiz1t2cNDyGahFRK12V9aaxNCCj7s6A71u+DvZd7tdt3Ywxtae+icr6PP7GIxtChgx + U05d3FyupJAzHRrpUjAz4dHkmPXIlrGJMeSNpEIA0zODEm0HcwhzhQOadIdCm0qmJAx8avEo6OXA + Zqv4ZEU0jN+qb5tUZAtUUH1Y+7RHldfWjVmgjZc+VrWC49RsMdfoqEY0syffQcC1rAcnR2LqxwFE + 0RhyswUiYA4WVtmW60wQ9jJlj1K4M4cag9wVHb4wiEnZOEIa6zUZm6TEyBcYhtN927/sjmFzbxuv + thRSwK6PsRtVDsSt7OOFZnxGQ6aobNyonNQsXG2QoLlOebxbDD1BBy0rBwrPxdfB9jj65KU9Gjtd + 7ImXtYJJe0As4jayG4wt3A7FJvD7KbMjQ1hfLA8rdooaEZNG5HrPGLIGrgvOXCLbksGxM+BuIW6I + cSB7UtuHLvgYbTuU3fm6Q6lybvAHxtWo6sz1os15MFibvfG2khpX56nlUb21Q5B1aJFw6qQrPyCi + AhpLRWCfCNqnM1O7Bk8EsGbT3nccZOqHLiyeIbtMmngdosKeyJQL5Fpoq4gH4eg4LxEoUq0Pu18j + bCOQECfMOyNPo2h88dr1uYA4XFf3pD1qup2UbMFpiPkD56js0bzGBaRshwUZvLnxHsGngKkkuy/V + g1gQPp7sOd0L7NFDQZ4evDliUdFPfhOgA7s7BemjvCnHgw+MTtMNZhP18EqLk7Q1mFMGaZzwqddm + 7NvCoueNr25yOuQPPj5D967IBoY5GYthShSNnuWM0s3GjB1rjWxPjmRRa/XgFfPZawEtK7JpUdqL + YUM7VnO7dRhWV7uNQytX/rynLuqfeK9YcKdTlYLtae6RWsYga8bpEGNv++7T45u0n8bbdlwZVIo3 + EFDMcLOywA4jnMLMKT6+7PU/Kf1iMIIqzYmdqXBdOsyGrbfvFIgrF2PCmDvi+qHVpLIVmtkdg4tw + lRvCwyWXx4CnvDEvP83RVepGJmSLzTeUltq38o66lMvmzf1wSVGnackQZIQasKIoXto3l+4nSAy2 + u91UV2rNp9UUe2QQ22mjJasYG8JtWbdru9T2QYX8ccwQmuKJAYX42q1e1sIrTqLdNS9GbXdbPvrU + 9GYbbpSaF9FxkBtwXQ14dp8Ik7XtEtIpCOSlcUV3R8p0G/fS2MrMlNwuRm2VJXU6RznM2QI7bNN0 + y7MxQEyVIXwmPJ4LqyjIRAYVAfNC4XaiOyoC4xbXnhZ0vPa3GKvQaxt8udOR3InOFFOLHsd8Kw6z + FVbogLJ0LNMgdzB1bha+enFAeFMzQJmuNvAs6ZLPKMnFwcSQqWOnVM7ypjdRGaO0LDo81dK52WVp + xYUYHeW364epucPALsz1y8PW7prjEgqiPKLWHiYQWyvwJCHoWw84zGDzDu6zLrTX5FvSu0dizWrH + pgOovqLOBFnCFVcJUXe4CI6FuiDdrNx0oPd2lBnnLJfYoXONdcaSyeVtrlhDpVDOlY76W3fZYTuI + iOMjsy/L2oNpRUCqaeFZ8D7a65Fe4FC7Pa6gpv8CkfHWiVpKjKTvWCgglZbdy4ZkyDEDLvffAaDS + KmqgRtdTyOb01obTL/f4ZTOTR/kXwhlOOGDZbqd5XwIiPVa2Wh0mjFO1eXOQw6kplbw+0sR7ocMg + 1nEOhYxR9fSCOYFsXxkg76lmuduHyokeyzS74nXEIbPCK5O4WjYku7qbiznPIgKLdzs1h/bchaNv + h7LaOh4R6K4UFmJvCtlqBw9mTJYXqL3jOrZ57KpWwdJ7JP1y9EVED6WqSqCaPvIP7qw60I08lU0s + e7AUpOSqF9ynFHmr2GUjpykGb9fT2NPpz6+FaMMYqtuMAGtzo16YVx3WXj1e/l8WOSNGrV1tiQKH + snSX7RZyz9UMXtg5gucBVNele3znOHUVlF40elJFtGnJxTgDXIpietnXwXbuHXU/zwIkvamaAEm0 + L5BNuWgkfxQGtBdXrNU+PDvObZUapfDaMhKeA3LY0698zof8/OvzKnvqVvfo+v0Yuq1id67DavFk + B6I77R7cAlc2F31VSevu7khqPz9b9qJFrOUqCyDbzAV67bkNQrdH8KKevk5jQvWdTKGX4+W274RX + B6PVfAXLmU7OEUhN7l+jhRR0XKpXLEfwzQhvoBVyzZ3F7Lu52L4y3JOMYtTuLgjsNeZKuPwapJgx + He455dS9WaGpI0HE5FpVLbU2p4GOevjULETJ+5/tUVgqPHt9+1jyE6gsgTwTLtTkYsrGtQb4CGoE + To9bw7XS5DuabUpNfp9RQ/vfsTDi6dEs35F51ja5hWGL5JWTJqyaUZ90xVEdP9G4g31X5VYYsU4O + 6iQ3y51yHvpmp+gnVlPC9EIMewgfQ1yup7TqAMZ18RoThr4xUrgjolXDiL9QOrk67v3rcF/uOcnq + 5LQ+j/P7Otp2HIYdQjukZwes1HVgSnUV8T9UKGwZwp6xVipk33CncXsJae3aYaOeUBSWG1dshNX1 + sqsht4O6gQHNDi8H7OM19lzex87MtFxr2OejIZxT5lAM1sjLB8BF3gQZzrENtGN0mDHrqZM2tLhl + 4W3wlM6vtGgTuRagcLPl45nUI3sHW712VFM7rJw4c/7SuO11YDWZXYeCeBg80/kUaa7KWZZZoaOO + NR8W687YoPHORkoV+cHStlIQgTM1XcKiEdNg0Ewm2L74FSXyT4O5A6xq2vTE25hSYK/0C6qFPK+r + 6tDm1E0LsntWW1SXJwHCzs67iFlxNm++U5JoelOxlbIH08nMgtUdsqtEJEjnQN605FWINTndRex1 + GxCI5E0a0cJQqcH862CuWaMVir72LihYVp5OAz9MG3O/KKtZT4tjx+67KN9xPVxHnb21Ep50ESTf + 31Q9EM8mg4pCLHQuqZFWfo1NhM6dtRvweJlAQO2qLvhCM7elPc87hS2/q1QmhRtFfFw2FPXLVr5S + YtKi/7i416NAtAQ/Bsdo4tUkOlq6mfSozNzB1XUJm9+p6bksROJtIMulq6Y1VvCNKdF0SGrNfwdY + nKm3TF/OmNOOql0aGj2TFoFCEyGD0rhOSPYz0PeDZpKTySTstDMktVXkzB0y9u19B2q9WCyqsnou + auaYXXkq7Kcx4kgDM7yZKSuEVC3YLs+JjpGcxTHsOny8VxTee3AA0ZhkYk01mV2MpI0rz3KtYMyu + d92a520dl21bLH3ZW4w8M20T0zuzyzsobc8MjbU7BJua3GOieWLI+yYL9k3sO0+O5oo673gLm8cF + DdIjnYEtdPzCKX5L2Tdjta/TcJDVFTLfATohD+O03Iqx3ZnedT+T2xxNdcetn9bp0+vQcRTJ6Dpe + w9RmWGkUCU7MIxR7x536iSa1+QHzanPwv7dPZM0Ppj9/4Fv/f3s8/vyHIfyHn3758qsfnx8fz/ev + /vX++gsP/tXrsy8/ewF6/UN/QML3/v2Pz7756vnxb0f4989ff//lp1/f//r+yw9f/fzH8+NjSf7s + 8/2X989+/NG3vz0e/3/7/5sBAw== + headers: + CF-RAY: + - 9b20d6326e09cc1b-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:14 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '43' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-pb2vc + x-envoy-upstream-service-time: + - '66' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999999' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_52df98539d2f45bdb6f4ddb7d21c5d6a + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cassettes/text_indexing_source_column.yaml b/projects/pgai/tests/vectorizer/cassettes/text_indexing_source_column.yaml new file mode 100644 index 000000000..a9a041868 --- /dev/null +++ b/projects/pgai/tests/vectorizer/cassettes/text_indexing_source_column.yaml @@ -0,0 +1,472 @@ +interactions: +- request: + body: '{"input":["Short document one"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '91' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + gCyIEalJPQAaocPnvP0PWaa9mmpn69PNo0+qWttJjKwAwX//syo5H8JMm03Bou9XEw3TsIReNrah + vSI+yvKqRvUTKYTyyVteoRY2takPN2KtQ7T87hGfg5lCdKqZabN9vFepYks8AbCmZlkYYH/7dsdx + yzpI1sH8v/778ng8f/3ih6+/fH++PZ4/ff/n+/PDy+Px/Orz98+fb49PXh6Px+O/b16v/tWvf/7i + 66+++v6Xbx+iBb/3X9T/4fPtgZ/9vYUfd/uvj8fj8YqP0EFz8QZf4vHAR7AW3p/+rLoncx8+EGxG + zKfPMutbaduTKFRwXv/1pK3mCaobfXzJsDW+luKzAqhhn+GBQhqyfQl8hHRIZ/dgFHQuHQB0kn12 + Apk9+1abRYKPiVq/1Cs+wpjTjWZgmFl+uauirMSmb9fX7K0Z3Ur3yagBq0uLIFVFS/yY4F7XzzNc + o9Yf15dqxTQZHCZz+7otnpRwAps7XW7HONW78q0HVne3ZWVvdC7PSXEKC6I4V0jM0Oscpyi4Ge39 + VLLMGxtEpR2n0mo50ZCu9hnC7TDSOJNvRtEuQ0/tjs8R55qsU5xC1N1cVz4B1eWsbZg6U3HgYvIA + n3ilLDWpWKo7KmPeFbXjdnpfWYl5mOJ4dQrobJ31yJhzth3UtYrrNgSzV2TeIK4aUWewCDkGO4Gu + mmmJ+wyW+2w+Y861USHf7vXJmFzVrq07RLO1vRPjhASJPgUjzzHDiSiLStIRQjB3Ec4ElBN7ob4t + UFwKHyEG+SmkY28SItJwV+uhjCB7w2nDpQY00vRcQbtzKZVTthtp2U6R8U5GjI54ZjTqigkcpegb + u9+tB1bQF8BH8HqsdfsT0OroXc6Uvl4nQMihMPo9xzaalQ9bF3CvNxJ1VR8kY1imtQeDZ/Tgbs5Y + lrgP2AkvRBUjoGohnBfaGF9VgKbbciaU2dTanGJt3Xxc9/Ter6mmlFd1DeI0dyXcztIqolCqYgMb + 2H2356EeO4Eiy9273HkW1ZrR9A2/tnfCgpoeqFZQVPemJAYzp0i/SDkgop0BykIl+QcRU7c7U9Lu + oyLpVESUM4LSzvYdEWuNK4JIjeU8Zw6K2dhlDlFz8pZCBBnKaF3wKeewKpujDIJK1U/TLifnEFd8 + kelu1tG3nagW3a2xITiUDp+l6XR6/LVV5RoZqOZ6ZxWsbqbkzDkEk4MBxLAWrhG6K85JNVBexiIg + ztSeEl2yXiDMhOrzaOZpqjlpO+Dp3cw2rsgJPatYSnRrViHkBxLhciKZAXVx4CR1T5Y6RQiglseu + oIVgLOuBURbVuR/tmgXbQLRcvvIsHm+xjeJZnsmdrvbKIqLrphoXzB466ZCNZlwMJTfZMTZ54GEG + 3iX/dqdr3M6D4pTaUzYuurt0H+SMzuRgFblT7pkoEesg1ulsUYU3KxsCOG945e8kC2yr9xgB60gc + 00Ns+SWcIsQrEENM42OvUypCK8wBVJyA2lJfLqBcqnJKGJvbYfjZXTdPKE2tEwwrTmvnSnwGBU3N + I5MxQl1f4w84Vy0YHLdxN8Ho7PREM+lzKFygIB3PKwr33UxGgSLgxa3Wut1eHwo5bSy9Zy5Lq/Fw + BR2S/2lgCvRQIK4slcRQ2OCQO8aEptngXN8sms21dgDKjl0fhZPKLU/ScNB8gGWhG3hStLK7Uo8i + dZztBeRMQ3ml9MkwkfBU8n34LsDObFEeFsa5hmCDLFcNFPkpwHXjFT2iXOvOzTBcmYmQGbyq8bbS + LlA6TrApMIWqIoDSUqwGHrh2mvtyT1fL1DLsHf6LIVxOZ/IOSGnZ18qjSNV2g7Q9bLxNkC11bd3C + utlV8fZlFrydEBhVIg7JGqp3XrOxaFv9oWtF1i4ErQr4tJppZFIHTgMlQDYwiVYOLXiL4etNV5eO + eAMkOeDIdvWXFsMdngFu2XKV9TeaQqV2NlPgw69208asCQ77ICEqYsboSUFvykUjHJzjsTtCV/RT + aGxU9wjM3EV0CRp3cZIF2HGnMwhWjx3xYM9yFl4n9tSpqz4WO8a4Bu98H2Oy2wwCRdU4ZA4RrzxV + U7Jip36uvGtki7rsYm9plOvM6exGYZs5kWILnkMwB/SpUKMDSsdJgHPubr2YeBrc5jHFJ2vccy9I + WcL5NTkNcV18HNIGEbc+wgSixVyJSDpK+QOqynWpx03LbHM6OhqMqewS7oh1qtMDJHSMLS0jqVOx + rKbBJKrV3KHGBOCpEqDCenY9QlenaglW0w3YlYAIbXJjiJbkJHbuetfCcBVaZ7aqgokMSO1mpjnP + sI4E+v5kxUeE/ocpcdAHePIuD1FjR9RbPe6dEKzNPkJNBqp52j606I1oyTdBxEsK72o0JH1W6mo7 + bbHLzlhUGfl2/dAD7EipQKN26QHWubuh2OVaxObzJ+bqUDvxSQepjiytIdxM1f1OAdfVkzYAWiMc + e4VJd5DcbhTq0AyNrau5EqNSUI7XwW366ZnFcWiptPNjV4tnq0Y3KRkLHldZUXGDhgXuiUA7kGNO + mii3lpwEUthGdsWDcyvePdQc7ZSUcmQsq6axc32eamgh+2qWfE901vr0IaZIAbeF6vGo2sTFa2LK + C/YyO1BjuO3OwGBmUwvS5Dyg5xyAWdtjDefQKjIYR3mrwY6vxqC+nELVWkwk2IbHqWqXHKJorKrn + nB2h4lEG23Wfw3I+50NBzRxm5tDJf8PwvEa3hyuZv9X1HK+vlKw9d3jAcJeQtI8woEw4skPCLiGa + bLhZjUibHXUcaqAMd8EC4s1VzsCRayUkn9utA+a6V0VHEjbtzl2zu9ene2BM1+INRY8zFztmdObt + mHdHqBXciZnDhmyGmgWoTiplxOc5LhKiMF3Xg8ch5GHDikv52qtgPUhP712AwvbCaSEDbhyxh8Fw + tUmNVHPKxooXvLTdrh3IWq+rujVK9O3cmBaTszlCs2bkxghya1zEGa5zNzDve3sdqSl30WrXICTe + 0nGIAdnOBVlCJyWWZ3XQQVcG8uOeylKeuLmewYqVCSfEYc2ZMKLmOrmPUbPaPe8Tm7LO46pn4IXO + i8vy3AoYNejGTiTBcVZlCRppPjds7bCeEquZiVBo7+SIonR+7XXTrPkbvOXoN+2RIEk0kfVwkdne + A+yhm5HtuoBITW0vByEWr3wewXAP9ytePiiGY9PWOAeCYAnjWdujVmpnUFqfHYb3a7EYcsjEOSDS + 1Rc0pwFF6qnAZumDH0CC2vqlGQAI1hOX5vdlKTdSduxLeilKu+4YYlWbm+R2qKmCBVV3QY2QSRoB + ZmuoumCnWvmlb4gJ934di5U9t2+HB6zC67CKpjbXQti6oeoi37t3FqqNhWftDKzXNtoBbfAa+Vqn + ++QismXbFhiixuzOcil7gNAnHKz7CD3H6zggr4Fb6eXKaRAto6IJQ6nJvMh4ptIyZMPpiBzDNXq8 + ypuuq0pnymt3KpnlJ9c4iUFppYY5c1FAWLctXzxCL8jZehUhCk45kr/mnlxU5NJVr7hVs6v5PaJy + grISI12Q503vPwiz1gH9vlkjklR3Vp9pxaJl0VtIu8pudQM4JfLa9h0hPYhX3SfhkdbsJrgEhbHc + lg1r0EyUU4CPQotySXaAXFJChDdQxw1wJO1sz7/utjChdlw1oBHXptj6abq7fGdLFnaxkLMKF26z + RLqpFoZI0UwUJTgpuDyGR2mJ16GgcJ65LhpFCsieyAk3llEoqoJdz/axe9VZsmOg1MALkyReoT/G + EFiLU3+tbhsUUu2WebhLyeAkFBe05MSR1cwsQDe83rWhgUJUm1kam5U7Cpj6VFHOwdh931YzR2EK + Yeti9MvKSspzjC6P1cz3ZPd08DqGenNSRsQWrpLz/WhFu3Jm34sqOXNFjLBRCk0vYp9UxFVua8gI + hXDw3hVeQJXw4LbfQte70WSvWFZQGESsN1D+GTamZmUwZpt3xmCswHzNoCtDPSWkvQNRHyTIXNkJ + UTlIJ0fBHGcDJeSUFo19R1zj3DnMHLttIKgl1kiGadcBDQcH1UFX3KY28k5HxPcyWsW/ztzdu/LV + nT10WyQjkf45VkVhqUSoTEwGpvshLmq6Ti5kThJSPVuNh9aIqDJnCzH3w9M8A0N1rQY5wlKdjCbH + yJO+0s5NEzfuiXeaR4nMDKJ2D9pduzPT+qF1ag/20NfVx06VN4dC2yCKOl76eqCTgBojC1KQurVU + 5JaiNYdgybsKIEwoFiZQQMS3R5xD7a0uLsFzr2zi6+4z0dAc1c0OUk0dcJD0E6eqbI9FZxDAYk8d + ACC1hXk7Qh90Z8wzbhwk2PlemG1RhWwGuXB9T5Fzmh7OnNFhKhu2djWwB8Bi1XXLS/HmVHjixZSu + fMaoWKK7pChsOgwoZuVYoLXb5VyRgAli+ch2NKimi4GexWaznRDG/Eyp3CTpmEJt51DC0xd8EVfW + HKwksV0xeOoY+nqhR6+yEAlT2k9Net18vawDil6uvYpTK1CRS1tTBL0Hl4JTzJVBJlWhri2FRWYe + FhxkJwj7VKDthdXS1uDjcE/gvnMHa37D6lNTh3t1sLkYzdfWKaVp0ZNMoGBc3ISb4By2t0X8EDcZ + jNqpAtHgTKkqXpZeQEJioVvxVQxaoYvFPoWq6aXfzdWVSx5d6OoCu46cQplZ6RHi7NZcZ9iLgjk0 + Z3lDNnpJQbJHBDJUZWP5JaH3WtwaUfJNsIXURGxuPJobwC2lwJ0G240nRqdUKhGLOS/Ju0OrGFRZ + 17KkXbzPIEPqS0IyQ5kej0ydRB8xvZ+3N1oMmEEFXWnoKauXjWdGxiFXR2Nu91braWug8OLJQIHC + WpmBVNcdhZ6VnbR+mIeprd7wJIM+d3tZQsbToaby2UAVRQJothV31Tcahxg1UwlbXo+Q6oSu0WWk + osFQuK0Hq1YOvOZpVsuATwIaHHrSb0dmS5hr4bML5npcCyhico7jaOOl4ZK6UpiD9UaJMLXDYhLW + ORqnyeOG7LcyXsmAnZtX0q03wKoqsQtI6OC3X89BwwrjuSUsSh+tkoXYqzBUwmqniEtbWvY5WA0r + EgLMHWkzZn1KD8zGmJOSewlZdjyuakFyh6igrErzKhSdbrLbCEkF4Q+liW0vrXOTT9cbAnfemGvx + QrhasdsCe+q6ZjrZu5nccN2CxB0yiNLJY6IaefoDQD171g71jxjbU0OSWg+aedSrxGOHoJQYWrZY + vyTGxSqKvs8DGdQyn+iRe9hLNfweclRdaSz+UwNtY4ASaLO3luqwY4RSMEULB9bXTfzlVWY2tNte + JLeHHRHBBORQm340x3k3ruQwV7cBJd2NqZ5iXSsqBZcup560bXQjPPIND4FuJuPKQK55xkG3Fs9P + ts1vhKL+kJFFNzeQ21dTjkAdx1v89MjuLukaw49+AbLBHmydQ83SSVTxtFw9xbbpSaOoka65bZMP + zUOyp41l35EXg33tqW/sXWkX6bjkbKPucJtOS/P/ve2UTKiUuD15Qj2prBy7jHSiZnmjeD2AzNbR + ZyVda/o71BqBzTWh9HcbAapuguwezUgF4cRGnRaGiGbp5lWn9cjamxq8rbvkEGZxMzwGi+C66esA + 4sq7bC98BBzPDr5XXdV6To8cEu9AV0w0VA05E073nh7VlNrHjdrTOVrUqDlnhDtlqwmIFpaID0dz + sBz1cn3DxPEjQKNSMyT1DaY0Hzj7JzWERW1Y7Im19xvJepo/lG7WCobhZgyCQs9cgrB3d0Xl3sBh + 6AdJ8hk/hbjpHdODWPWmH9shrzkV6+2GQzkTa6f7NtaHqglc7W2PhjovezyOvArSlCwKOCA1r6RY + VaJD/9Jbs9xmbhIjuzPSa6ve2ReGXAklH3VeDMjgjolzSkA9OsYH8XCjgJAxltsep3Q71cZqnbxV + AdA7LnBKtnfdkx/eq52g5L0zXZtibPEaXqvryjTmBOpfcNzvLSqIoSvhJl9RMKyQIjjAEWuPbRDU + HSm8Dq/y0zF6kU0XQ4O9GUCF3MyGAjsCqaX7hSex1Jmyjv1HiRIqMf8w+mhxXdlkdBMYRzjRklPz + 7tS/SPIViG4yx0qEN/J/ogO6sI2oRrfBojcQHmP4XBLbdwxnR2ZZb6UZJhvEThUzL/QnNDw93N6e + K2q+UglQSq9agssAcbshV3sq24z4NZlMb6ZahzsQdqGasMSwpNWdpIfCRcrd3kQcclP0Qsn1NhSi + suIHWPo2JFWI05iIOewa2nXYWKahQ6rsO9JR93QhF5tI4WFBxnJ0Q3XeAQurrMMQV5X7bxwkUOHG + 9hxddk9dh9+FN4zt4AoSYeKYw0RFzVbKDfc66puJaqgdysMZO5hhV6sTuTqAd3GQY9ex3HdAbhde + RZk6Em1K3wFlHW8wEyiklIVr58v0AG+nb8DzK44hi7oBye0OY81R3FqNDnepohwGbyoRKyzO9b7Z + Wh1H6Bxgr0TrhVoiHe8lhIG2I9xghxI5MyhUeMn3phW3evZOvw0aNn31JCkygiUmDrgYN7fbryMR + 8WpCO1S1eHKV0aUz76iaSs2wXBAMTrI8iVINXyTNTrLrBZ4X+lgdoVqMjvwBCBoRbWtOWYQC7TME + shwRArfHoSuJTmgCLjoJ7xqdjzs2KCwS6ca+IjvUsT3VXZ/ztvoPIkvDhmaHLsm5acys85VzaYyQ + fmO6UbDKvK9HkXh5fbGQgETXIuCkkrpLk6i8YvKmHoOjDq8Sn200Q8bGRRDRYk2ybj3crfw3N1pN + HDtagXnoRej1wH26dVV5ebAh4Xfr+4YrXdzhsJmul7tc3QWENoSGjQMVySh1cddVUNfj5VVqq8zR + OCgf3txmMpF1tsBvuU5LvFNXV/yp2sq6rHTYDmFJ597Mxo24EUAJrhmycnmil9S601aEcTdKJaW8 + Mwm4FG6yhLHOTKoW3SSurmjexDmtylkbw+V2UN9qJQWQpzMxsI5yesktVdROAuPEO7qDq+LWNfOm + YZWjA5FawzGfeSW98M5p9c3TPbJ29eo001TbLbNa8U2zOqN71MSt1dZ4MukkxEnVFis3EFWQIYw6 + Uq4hXbG+mcTYYXw1xSorPFUT3+IWi5bUzu+LWU5t3oZK95fFMJzOYQURsGK1w9lnDCbYJzaShpkn + 8IrWLoMX6y2EMDSyzcm0g1Mdcgx2a7tem6fuPPFTnWUjHS+m5Qv2sm5K6QYvG/66xWyUIYzM3ebA + gdBlzgWVw8OenGNldVm1tNFhMNIsJN6piVn2wVgKa5K7hzSUS34nuiIV71CauF7J0nJv5DMetT/C + BUPqYHCXC7M88fAxRImJUS+Pmq4c05vFip4soNYpb8mBcekkz1eYOV6WiDLZ3vU68rqRZbotMMm9 + BTZxXh3HWCHen7tII9yRjukQZxVQsC7Eus8EszQ/jRGDkpGKHW48/mwW1+bMFVARLQeUZstL5wA6 + 2nHPu9SuwWb0zvfEFBk515YIoB+Y135jwZUncjeFC0pgfDjAuOXtq2HAu9rgAa2xsGFxzetyUbY9 + tTAB2FIT0n4bqJiWwyoe+RSeWrb4xZNX7WlzGvK1uy+V3LpdL/H20lD4ub2R+vgqjg+EusxmRax1 + c8QelVEWZoTNSp2q5UZzv6P1tGmaF8s9AXMB7cbdyYioB5FbXnrMqTQzWq8UHbrRuNkeE3MUtMbG + HnqMxEtF6UcJmixSSfaDDzOol1kOPsKUy4qvEyC2OZw3sYK1xdc3atbnEoNpNqxZ756hlZL0pdo1 + XBJqUnr2dBt2B96U29jak09QKcXEzsLFHU7+E2WwccF5qVy50xWsk7Lp0wZi14i2GmgSe427Nrpx + tR6LYCH3qNuNPQ/Yij7WVbyz6YYtJ9Ocg05RWCri90RQ1sat1JCPHHv3vry7pEDdYXZdW7XKb39X + u46JF0uYWHQpbdmRGKm/idqbvtq3KWTk9U0QKhhEs1BJKYl/h5LXV1dCl6wHI6LvUxFhj3nDDcS6 + 7uErWsKjmqJ10mvr4CldzpePPnvRoDthUGEFRJv2bN5BxpQwdljPxt1sGjAahxCIhTjBjkRFIfJR + Jo1kdQKkdK2+AYbr5l4jYxlMfsKSfV2pO0A3Z5OiGrvjIoFQd8WqJHSvqAp1R6Vv3NWeJVvOHRbg + 9hq33wPPlvEIB9C0E+/FFZY3sdu2OR+whtt8SW2w5u2OHcGMZfDMbCplSBlPuRHGGYrigBBU0/IO + ySTakEt34tcJdTVExcRiykwiJpAYYtNQSAokntzR/GiL3lDkHLZHR7Z3MFtYhtgppErnfbcgJqV+ + G4i67bJ/vnio5H59QYHqdZHfO5hV03j/XNthsPQgdFNP9w5auVPqlP2c6yY1a5E840rboARsgYIU + 7QpxeqVdmSzNgz89xC00FR6IYtUVt8vrRVVzood3yIdPpl17sqGrbbG8bW4HrB7Or70Je+e0wVyx + eayyaVT0gC3coO7WPUhW3xF+w47Km6eX0dRROwGLiDO/UukirrwgLNE9YPVV85yBHh+DMFmfkDZo + iZGaZo3VTYF4iTDhHfRzS9XGNZHxjGai3bk5ZocAyKsQIkItCpYnEqov7bHdCTWhCNjOKU8x056L + 0SXLwuDWFmR53R3CGCl5YurFZjl7AWK9GrTzSk+KLDe9MIbAzHYfJmZnhRT0fIxuG9cOg8oP4Q5z + ANWey7xzdUFHmJ14w+tLv3TtiH5l2uqoJ3LOAJmkEqby2LgLbBPr2oE5LFS2bkqtPZxQzFZtn6+x + U6D2cI/LFTQ5bEMx97EBQfDpvNdBZIaigKfcbR2XiYFPe42pFdc8oS2+/mWYU2GPwXgQAA+Kt0zM + kLeiS/y2NWF26nyVk9XlSyuSkhp4nHklc4VTSCPT76D2UN5eghDH3ayNdbjPdXQFQiLVCMiwZxdK + ldTcIu69Ukrpnlkdi/9eoLMv69a+sIvtw8LdhALi+r6ezR7AJqEsGUwmjXBMldOwL1iVQH1j30aX + +1ga+1FwD02cpSiwfJbbrculKt/p6M+VUO1b2r84PMogcl0bKFqWmsiJ2lNdD9OEwtw9F7w8t1dV + lcQgURKTzIsDUw4bd7DZm0sYPGd7PAGsghRA2iGkTkx7Nfercq2PxWRDzyjr3FHXRiTqF7cmflUd + Lfc90eG9iRK4tor6GmaCX7TTODO4xHi9vb2FQ/Q0Q230RnrMSCZ4+4dTP5VGqEFkvHQmdNN6Q2xh + i+tD0rMk2RP+YRBIW3oTeQa0ylhLAWxUtjTqSSOS9lVKT7Wexqp1WyuyKkzPBgp3HfJF4n9/EKwK + cnhyrJR55r00vbQhbRQ17mreIfV1dMBCeCqQpCLc3kye7VVMKEqIOm43gMP0XDziMVyokSnL2tjL + YxrnMonoghI3WKx26bwdJitvwgsQ4ri50EmWXLF9zVRdeq71hVRhiHTG9daRn5gXLCkYwT1euopE + r6YnS887wMV6srZA6uSsLLl6Tfza4IRtj/UYXlWFPa3mUi5GHW16rMGTqZaXK/KmTYKBPwic5hnl + Ex5WeLFxYLFD7NFdtbkbpiQNrnttbgakZq9RnBAQ1LpzyMQxWY9CybN9ObIHnbExakOeYd6Qim4n + o2Wf0Jz3JNDs7KivcLVJVUt8Vi1WV9p//KNm76tS+wbwTK6rqK2qbXI0SYkbFma2slk4BDa/C2pc + c3BkByDg6EIgHMtzs6Iw6cALdmmIXbIEsR1slTJutn+pNeVKdE4EyDSkLydd5IbQdrm0SUKNmepK + L/rbIia1m7FmiNGXk9zwuhl8CInb/iJIxdqQ4hPSbrs1sHrW48tJNsKJ+Km9Nt1xJtWO4GXYQvyC + bB0smuAZ60djnNXUIVWjHO1TnNyjO2NXL+a/GvEhbhDq7arJ5wmPANRFIESCttyrIPPKabovJc1x + FdG5Ki+ZLVAs22oMaKpSBA5P9cRwCLJGsrPQhrtL8jjOOaz2qIJcBX5DezwrH58++7H/+f8vj8dn + H14ej+fPv3719U/Pt8fz/et/vb/+WQj/7vXzrz5/BfT6D/3VCb/89z8///br59sfnPCfn7/98evP + v73/9f3XH7/+5c/n22Mj+ZfP91/fP//p0s++PB7/f/n/iwED + headers: + CF-RAY: + - 9b20d6036992e529-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:08 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '171' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-6f5bc845d6-kw2sk + x-envoy-upstream-service-time: + - '456' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999996' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_c63a5bee58a7424d86a55ea1217c77dc + status: + code: 200 + message: OK +- request: + body: '{"input":["Short document two"],"model":"text-embedding-ada-002","encoding_format":"float"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, br, zstd + connection: + - keep-alive + content-length: + - '91' + content-type: + - application/json + cookie: + - __cf_bm=xRJmUytWLYquPJlxsyg0PUH.seN_beQ7k1ltcUvhz_E-1766419268-1.0.1.1-3ZYlFukGE79SK7NIM6MKz9.oVq55Pq.OEofND4m9n4ulQrnhD21mc0ZGeUWans.SUQGzeLBuGotbT91sASaurmOo.TTJXIPwX5IoqUUr7jU; + _cfuvid=S5cPS1RfuS3IU3WKDZbs9TWx.2wPi3Lml9wd.jzxTsk-1766419268250-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - AsyncOpenAI/Python 1.88.0 + x-stainless-arch: + - arm64 + x-stainless-async: + - async:asyncio + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.88.0 + x-stainless-raw-response: + - stream + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.10.16 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + body: + string: !!binary | + DAAWREQ1qwdAETLM7X+M5b8+Ru1Ev80cuhRlix+xKRD8R8sqAT8AheHBQ9LCpZGyvYsGDpRxzCH5 + iJSrlq3zmWh+ovkl16/R1lFRQ4AQWxuDhevS+Ugex1JNpXKuSZMuk7332rJEkQBA/f/rvy+Px+sv + n3//1Rcfr++P1x+/+9vH66eXx+P1y88+Pnt9f/zh5fF4PP77+ld3/+RXP33+1ZdffvfzNz8lNvzS + f1H/26/vD/zoL2380mn/9fF4PJ54g3q2aR3wVh4PvIFTMLPwZuw1CH/6fALdc8N+f4Mtb+1/S3gD + V+vUIYzTxIwQyHtTczLFdo3v8Z5nzDnijYImtbVwguftzrx7Izar3L1+M2TsTWWFCcFR0n7eQqX2 + LeEN1mFKt6VypPER78JIJ4HskhYXXqdlFRAgJneFylWjVqIN6voRSVXppi+MCMr74//S3JRVG/Z+ + ke1xo19EmDT1EmgAxr3I0YTuJTSUMqSS6/akQHCdRg0KV/QNhk1VnWRCZeg2xP1UpT7ExexUQGmd + ckkUAXGW9iziMKXyzJBg615hDsBb+Zd2aXBG6PUL5yo6wiSFsQAza+W4JmCrK8+pSbOj1RvTVYRv + h2e4Fmdii0rdZ9kFUmkmkTACAyhmn/Udz7fiFFI96CuLEWNbNe8gYpVdliFu2X4AWOhFGNzA7qgT + QaS3Z+uZvlxE7Qtdb9cx7SblG3MseSopTEzt2ZYm8fSlpK7ayYnlGN1ecuf1eojQwnkzLmcN3SaT + ExgSMiOE0RreCudZm00RCCp2QvwkfGS71WNLBT13KejeUYyOWxXF6DbwZwg2wHzGsDg5ZcLBqKgR + cYpdAUmYLtzIxcgdLbR4h0qlWFzV8pyWFKMOZSAOuU6Ve4Q6+LNQUFq1CIytk5mOUFnHsSGDvduq + xy9p9EQqVNW5LGnfSoye/acBaU9EBeNNuRKEFkDoWidMjCGhiyrLVMi0TwpIzSAebqW+3v+c6HKe + CYHRoT0dZONSR6kgZLO3W/x1Q2kBwdSYWywY4bmU10EVtzad+GbNrCBTvvt4CjrGOy4G5opYZxDs + GRAVbjdUUzGpLwZ+2B39OAebM5cIJlfJ3TcE3PX72A9zxiSdOSyssCE61M05OFOjrq2Bg9sr1q87 + mG1waZf2uAVxdTlmpPZ6u+5puwZl6JtAIDfZmni+xWo0N8IiGe6QyKxVZuexYwpXUA7b1oUGypPq + 4nEKvZxmPR4gr1z5TFBb75pkqrK6RI9u0LDsaGFPSf3NZm6VDpC/CYzJUIyj1fpSJrA4PYfEebBm + n3aHU8BnjFfNihSoZlinXkQ0s5VGiz0JBoCx+w5a3sPhK81V8XJbmjUNxbDm9goLCogFdDNBdIAo + sRaFUTq8m1BAWc5ZM3iCFhEum8pkfDbZ8mG4ANTbU658CnVo2pnvOdPKIREhE/Qh38+pTskppxBx + BpU7T4DyEJRECzAMeOpr16/IvWNuWkKozDDNA8OdkVhTXVcVcY+dLoSNrBTGQSypZk1lMJVGR29Q + iwKHZ55467va+fHPAMxInkOGrtJtHeQXOOgmkrqzMGmqT4Anb9chjNxttRVuorFxlDcYqc7HWglV + zWp0s5LEPsXTvagsOKOqoTBmQ7e1k50u4wjTWRvuJKBWVfkI8p1cMPUA1Qcjqb3uvLAyOo2C1wCK + VOSBiYRPcWXupmab3QE/AokdlOIp66pukFvghq1+xIM42kADdZNLcqTgGXUfUeTZVQ/i1W4yi2ts + J8575IWb7LbOap+25Ja6S8GJc2uTTA2uMiNFL7ELRyyLLexExXUJOneqksL6BJBb8mRj8qrthTFu + +2Mi1W4jfgVK5gObg8pGw5dlYXHuhFqEcxI96oUxCiSZa5aiQMon8QbP1jY2mn3jBwiLrigBs7fG + 7YMLMyj6QiB51pZU9vv4qBukGn1ydIG6jgV8oGeRVsMBxZZ63bUadArDBlt4RnBijbprwutI7ckF + UxqyOei6ay6iC2g4ptWxc1n23mR71szqtmI9KIU4NePOmhQLOKSsBT+yYNz2ZpltCl5koxvkacQ+ + pe9gMUeoMHL3JqWFuu0BkQCpVguzTJhi2hdeGBBTdJrnZxlP2qrdKAAneBIIa4G+dNB0RQn+8Nr6 + EOrKVrIWIqXBwsI4dut0a7on7/d5vR7DoWdMBCGVG8AWjAauPSzo4OhOQieSEeM8gBEv2127RgKQ + V088DFDF+tFQpgyVLugkHI3Rj+hn9prpYmZuVR7F0IbBVCeMcpcdKcFhxD7angvyJ7zetWTbiUcU + kb/2IyxjmdshqyD6qkpawqixEqwnU0/Wh98lqtWh38HewQ5u3DV2Vl7MQjoHOYOcSz5HNRsKRTev + fSyH0k2twmzGB2AOqQ1DtOT8dJyMKilH5VYDkBTj6vYyjyfrzhAebOGCC18jbNRyQrMUfFJDbLsx + zC64r1C3tbfN6Xk6Zbjx0Bo+ZhdDyjBSDAbGXb2w297B7geBVcqM4K+vAXsXqj36D7NWDDv81OQU + 1ldP4fQc0kEwCQSR8MbDiiZL9O40gBIcnB4QlY27JNgzOZgUt+RrFi4agjlJXAHCC3Relda5ucXA + NJcjeOR6ApiJMGBPGYgIG9x0kmn7lTEzU8rnYhGhNzFHpZt+/eyAZKdXk3KHLNsLqkjvevYQE6jq + iHMA5Kkg/9V5ZkFlU5JUD0Z+nGbhIK+MEuCD5FaKwanHNJ7iVF8HoVRfV4RI96rPCK/9VSo3DoHj + OSOpwEnO8nuVBmtrxyi+GskwXXHEBddeFaHSwZJgTsXVZ9nuVeDooHT8VWDM8VjIgCNz2rTxoFDF + k6IgtWJSNz4d/9UDcWzQ6/1IVKzGGorlU13+NC1HjiZD9kwNHfQihSoY256RFiHqBui+xtjrJyz3 + 1rE19tGCklrBp8fOzQmTFbvY6irtR17UQy30dOSD25kdNgOwXpm6pfHdFCSI2uwR7h5S2GdysLcn + +9Ew6jINbrerBjLQiHgNqJ3jhC2tm6qFa/zrMyhyTVDmHOk3oC5usArWYp11ISG2aVXoCrsd0VVZ + w497x3ajrPfSM2wkwYNfzYJRS96YbiEoPTG24loaQ1sXIGvP1eejfmaatL3TCKaBKOzu6bvJPS05 + zuDqrZ6UjXz6xT/NNsNYHxKaHHD6mB13yFcWq0CkAedqFlv1IOQtB55ob+e0n2jVSCrGUGK3P4Es + 6UKJSM5p1kWutTegyooVGdvcBEu+djhT9bLFxEffMbpd8qQtcSTE6U4tD08OQnfHQsrB244hyIGs + eDPjBqHEr6PGgGz2ck8C3p7jBLE307tV+uDOF3e5Yw+4XjP7vK+dUky0e+ehym6Arkrwi0n3RH0n + vIjbvZCiyECPDkoKq1Bo6BQPBzNIs7QrhMw4B7bO2t0AqjsWHkVYww72hObMIiZJZQSnQfaRlPRw + qLd6auXVpQfndDMNDy+iZqe1lJAauvN2LKmk3HDSaLAXEnUZDMOjkBKpdmDgmFg5xQ9SbWbKD6rD + dt9VMAtXPZ8ihqUQ3kLB1RTuQoz8FInNu7RNrl2Fg3W6GtNyHLPI9KdaQ/0Sod7vLVdt9WlP76zt + A22rEjHG9nXtNrxYNSCbBQ9d7Oba0RhEd5MhhApFTh2IX7HxfxhoucEdxDIdYb1dG1XGvAwD4lZX + T3IanvG4b3o7JLUWe2sK4KSXX6dZhJQNcnV9QVwbSo6uMWlJpRBNli0ikr5M4Ynjs0N1DeUgJHX7 + rAdwCgpwf71quGFwdRlShKlLnjj7defuZkQTOHT5HHVqYJ8ZZVxsFlFSfZ28kKvJZUIaPfTy352s + HiDWvRU7Wxh4wthl5jGNhV+xourlUEspkmea0OFY1mKKcIOmSGdHoJASPJbaajyG7RwdwhlGWxRl + zMHsMTGxaWOz5+jJxyxP3SDsI2VEJ/lkIea41YXSycy9XTbVwVDQaufEl/5Jfn/hGLvAwpjil+H4 + NPWKanx6VNWq3ZglsMPxhGKMHjnyaWTOTNaQUkOYpeWYUcAhHK9q9nuuIA7F49ilzpVjEA6a7ERl + 0LHvI2INWi0oNIpLUoZ1vHhJQWSLQ+8xVGdYK5iD4fTwS4Ob5WXaex/yrqxXE2nAMWZh6NqCuN0d + gxIT9qXGVJAwkyIMxibkW3khG1jZiif3Mpfshqyt7LmvBXFfvHg/k/LqGfeqxPI4x04eeyrx4Sgm + 22eypiOp8ANd2SHGwt7bkrsrrBj6Vj41m4PutUOpNCmDp9VBVJBa1ABizhMoqlbZZaGq+5J8QEGd + WAY4LO0232F1fcqANFPDw2keVNYfjIrR/tpFYebSeBjgmbJU7QsK0OXZkSkV2rIIzrnTLH6/dA8x + TNI1y9fTdwRJIVY7WX6QqKXqR+g5HxcaJbVTU3qsxEUWkhaLLYxe6ZTT6lz11pbYOknl0IYYj4E1 + NZUKL9BqU8ppgBM2SyI4k9O8Dm/3DvZDnJvzhBaKKaF6JNQuN/e3nPYQknJ4Tg91Te8shSomM8l0 + seTuOw0Mz5kdQo5gCByyo94xs+xq1kQQ61SokVIvCzVzxXTN825WhGt7F6Yk9fRUBlXTtIjQbGUp + UfCP2beRlYI7z0Lo8LS3NRWYS20wAxabmRqUnmhLnCA4Pro+XDXjlJMf6zoRdcHo9tnVcwD3yAMD + 291H01UXILQfYbOP6PPapU8yK4sG/jq0m5lkV5ezsq+TothXQf8tA14YDHRgb0c7/X0gLQoo+Qg1 + OiLIjVx7EVchGAr5iBwIcqvuJoqLMh5NiprKbM2JtJUtc+yCqEgPLDHXaDbKdF3oTi3UiXm/mENl + C6DOsCGWaSaYMXuGMIsKDd/J2YSMMgG0CZEafGOa1B4l39zthUHB0RCqQEgOFyy75aw6yb+DJag2 + 1b92Z6jt6SRtgNeerJzvonDeRv5u6Ur/ut6p2DmLnDxi/FgLsEsaLVWZjae4nzqORQKkp7qVXVeK + tobwpuzBQlsiQp8Go2kXL8HiNpsnPEdu5qW3AnC03MVQcCVtuCsZcY9BFZloIvG3VDwhZbK2VEQ6 + Gi3ZgrX7XHXmYeCusqfE0NhqXsP0mA3csD3j27ChCyzuyp6sG7GLlzlejIg3HiYUF5lW0zWTs2Cv + n2txWBH8v1JhtsN9U8XpSXAJ/Q7q+oKI8K6sTs5xtrvepRAKKNyEwxZZYCg2fvVLvepOQdyrSrv0 + NYXWoJR9DBbYm0pce7KWvxNw7U5u1ChCu0VBTJrdnEDwMPBofOGiKiltVbcWOacgu1XOrnruHkBX + W65KT48KpobuFwK2ZYCbYXX95xA1CQXIuxOgsg6vt+ZoTKcPAMWXD+NKrtP/PZy1V7909Za5/P59 + Y5u4iwNXdQSnr9JxbS1xNIzqdoKeh4c8lStSVPXNeaBUzlnqgjWQeTULwnbJUBaBW8UpjLV75yrM + iDG87m6xj6AFxt1XmGRjDBg2nvNcOGD2rKwsib9iw4ppVytGCx953EcuGGhx5uJy4Pc+PR1kLn0Z + FaSuVdGyI5kP69+mnZ4QZceZIkcRBwQQHcxpIRay2sddmhqL1jQNvR5qYp6E6O2bAda0TuXsybnl + ZqyRu/CDch3v14npXQq6/YxvVun2gr7iHZSKc7u0J2STnwfsCftajNHKVU/xRrq9q6C+7Gy0zKHF + yPJkT2Cxm2BGkVvHxYXQVJ0eibrh7a7FkVRgrhHYdaVRluYUdAzDZDJBnENXN5fA+S2KevHL3WG6 + u8h0hb+tpR96M4U6h2J/e524HRUOZGktcqUIzZHZ7wDD3r5wsjzJV+loh5gsZACx9uka1dRiUG8U + hRZWrFFksTtD3CRSj8k29U4SpiS9z+FpQCzxCWqnx9Hd01uDskNXbWbI3/NqcgyD6Lo8ENxmctwq + 4vdpOQy1Xdc/aGZGrjPubjdDD212OdI8u99Pry1/iQUpq4Y7Q03XnAQa2r0QfsQ2r0NIKcHp6kLh + RcZQo7r23XNVUUfmYTsa4lewe9qloUlZnPZ1ac+HeBOVyZGji6sJYb7GPTcsSWXYLXRpKVv1/zXH + BTUWWp0WDTIdV6yFcU9pxrTcg15AjQaBzIOn2OWRKla7nC5iK4Isu5BYUcUDz8wo2kOepcmShL0h + P+IiWvYt3O3bGLGVcaep6qCh0G5A3FaCFL99kG72Unq/PekPOjp3nSVOAvGe/NEkfXxb7fR5JX9Y + +kmdC1F047BgaY/aR8ZX26Bm9XVgWuhiuxNHToF0HmlDnNiY8n50V+GWOYk3ab07Eyg8BjgZB4My + Mf8B6D0zAatRgL1BD/IK5bi5mBArySBYYX3ZrUmFxkzjeptsqxBhVl8Oad9D0For+0QWcxojzFLf + lmC+MMK1iyZ1r57v64oJEugk1FT8LMBYC3LtjueMGbq21f2xKDjok3Wx3oVSs1A8n5/wekl71wZm + HaRtn2edF2bL43cA7tqyCrlIWi2qVaK4YgBVX4Z4HV6hZaBBFjWiEQWHTMsDK7kCckGmtWDqgly5 + s5HO1fmuA3eLUN77FJCGA7aK5WGZNAnurOk69trx7WCsd8DZZJXj2j2TbPS6yREZ0OTsiLkvNvSl + m1NJgSn30YpW95Tp2e8Fp9USLXaW/Rx4PbmspzTe9nb4qIlnFq9gHeqPiLM754ZJcemyrllRlgmp + pIcWvL0GGGN1QFrPXo7F3Ea1WLdFQ4P2ameF88EcYHJ0+ktNsls9EiEBk6ssZReDsR941iAm59bH + RATeJBc1aFJnEIthB42IxArPu+W1OTvRXFcG3ZD9bQuT1dhQMOufq8+6uW3jKrvJvSnKlbKPdoGM + On6sGK+GlqPpFfiwySwZqkKFES9fzkDO1Ekz/NID6rmzt6nVM3vLiu2oS6JfbloeYpmHhrXLNjEw + 0lB5+UCEJ7HVgROom9qMN6s4DdbjCkiqT6fniaPaiCw++b47SAUBcFDf7fU0fyBl+dnMQexmyefk + KVY1yvKwi54wFPWy7k3qqjz5BoWw7o59dIIdIE2POpiKUNgvPe6C1dkI/kDRXSF+alpx0pXmbpZW + UfnMoeIUpvOsT+2NCodIfMRh+HridpWH90B0dsttRPLqVImzbIdduaXzCjF4brRRxNKmQGwON6p6 + O3Aoh33f6v4QgsM2/9SD0AayNFQKNDT7Y036Xa5AM0kNbLpe650y7+lRbKQa19Cqvn6htVVpxcF6 + /jWT2jbGXOhtTwE1dM2zdfjo8mStAYRXjl69I3LxvrApZrddU9b9miUr6HF0Qaq2oXkHoQuFfWII + bCuFOtBe5GZ1BW3L6aLiBeJq9hgd71pGF68zCBZXYhCUx1tdYHuvHHukvFG2LFihrK4yG+OuqdRS + sNi4Y1pR+0UI95zZrtGgL9te+gfE5Iq/QRyjUEx8l0AtontUd3OaX/2gpyGfxDUisKZ5aswexZBv + qWDP88QguARGQBW5+ziO4vb3P31lR1suN4M9oekdaLFKlA8LYtVVLmjzl+3yVlNq2jumUi46kmff + K6ZQX03ncDansfAb0mD71y3FMMGHHjednLprqv0sDzqLfTaZOry2XmptsY7JaFf8nvamjCfOO4D8 + YbCYCAPVFj/GTM7edCErKtV2bxLeVnlphBGX1KSJpssG1BxRjFGopc3Ck44z8dJnlz4rwTuXShoW + 2KSI98KhzWELAs0R3YEkxr47KV176IVOaQj0EmqWl/o6lHQXSS6zMII8ZbCnbhFtNMbTOJ8Bci2v + VuzpMTTXxtAvrrW/XhTnGN5KZJ6FYqTtZJe0tk+Gh6PQpVUwTCpuzyAviEllwW5oaQbHJZ7jE8Rz + tWufSqMZCXba/jxe2yR29qBvm3KNDmzRej3dKV2Ix0aaMUUmyxij/PnGObClQytSe4SMUNrbqV3G + fUV5Qrk23LuxwxEBAkfZs0nF+R9jLtusnQYsILuO95XenQyJWgabrLBqtgrR19knKTRnsX0jdnd2 + i3hako9TaB9Uy7ruMXxRWZVGN9vZBedoUY1W6xfC6xCLSVFtKuhZUa+yn6SPZjdVFyuKpqhn8YZ0 + wsVOmiW80NeNzcadPW6Exgt6ll0jQAntyzgXu20h3thoxUTtIliErjMKbJKbMs1jZyuP3TNRhI42 + rxDWRBabI4zIVtkD2QPTNp2wZW3z9/dvDlNCLVUX5PpFJDj5vnfAbVVJWjMUAlYdGuIBB4e12AXm + OykaCil70GmSrpV7vq8jA4JI0T2bKWabV2mJdrz+zYF9TMUfhEMdrkPM2HWmwPvU5jozdUX8si9J + OMl2ZaR/kLgzbMwRS8+MHUVak+wYOq0r+ro0sgnSq8xoQ7M/FPMMZoxHtTsoT+Uq+r99cTbOFu0K + j/5ne+q3tsejmlsqHghWOg66qxtfvScXbVW43Rjs+YM8cWSbhXYuy+g4BQwRLAzg+ZxByusVk3Go + yU7qpi6l2rkDnhluF8XhQXETs1ETAMPr6jNltTu0ZX3JGrJR17hQqJmK97USQ1S+yxyu6H18wjRB + bxKEeAu5YTew+51yC7OYTAg77kxSKGgX4T4Oc9nmLgaxuZ7s3Hsw2z9asO6UeIG5ZIeRxSyflLC3 + HeJ6zi2w0dEjXmXdksmydNUKragJ20KzsnqluZPlqj6ctRXdRsdGdCBq4CIZllc1ouk0gzLZQ7uY + Dlp8RZu0YdmxlkI9Vbt0xhWacHsokaLJRDzwxMXiz2uvBN3LvkxbzeiMvk2LYg7Btlm3VQ3iIilG + mXQjsmOMkHQp7jBUeWRKabVnJBzGNdsrI7EcYSS8Xf1KywoHU0nKUr5g9ZxYqcUYFTtwX9zlvj7q + RRdbLHrd0siTmjjYek7Gkzka7YwuBptzjeh9m+JkHT1AZVhujIkJGsUGTKioKaNq2wQaVIfrx2RN + 9MlFJsfBK7yFQaP/whIff6Cj/y8DhhmVPQurcPgHBXswndzWfcK9lkNdjdPe3AxZSDv4dp2+UDgV + UbdWFwJQw2mRPWGP2QKFBHXW7kKF4LZ9HtNC0+saLmE9L5NGuq6K5ew4Jyv6+g1bKUfugSoJYe70 + 6KT2yfsoR03VbQSFYp6v8Po5FKMCYl4Hx28HByg9MXrASnX0su5kVKH0qBrbq9c6QpbRcVLjgTcz + +VYOkcSN9PWWH2ayKddtMeuunFU3hdgPLOFC0plvoPF4qQW27XN5g5clj/RGPbSPf0g+6jl4VQk3 + TrianBZSuT1BvIhSh1pQVvHOpHrc3HjBwR3hYhUwPfi1MJcVVaBJvF1IBDdNEutz1y4IAldixosz + idJrSzVyMNOKmPT1JKSL2TVxIbeSXiTn6OLnSLOsQ1ondWrrbSnaHZVPAlL7tk9Ch0dsoVxJhctu + /J4pXcCh4MxUuQawUIPKLBzC2/bsxRl47SLvl9V5dhxoU3SWuPpsEBVhuqSp9OxUYyCLO1a3MMSy + h7v1Qh4nnnW5tBIGR6pZ7aDdFFUbo7auFHZRs75FANjTpDfL8tznouVFDDCHjVSwgms6FPRCzjKD + fj1vOehxABj7FIk2xplOQc7etobiJryzEBqdxhuKwyIMI4XPrXZQoeRJnfbwanNv37IZZABBjzox + PfEwZn0IATI3X4Ewx+zaGfI98V4G66QKbSXsT7n984N+4r2Wfc4OsIOcV3wAdbnneOS3aYf31vp/ + FwH06+olH0OZ2WrIyMhRllB40bsxHncyIF20IpeHMo3HqtNsZSRc09NpIMHCaooGIp3Z3y0gl5Sv + m9oYnu6PhWKzvYT3kbsofB2683VmHxk4OE4kZnEcM54fG1KfEjDWCR+g4Ipa1n7A4ioKWG92Pm4p + PxwpVteYc2RPlzBkNl6v+OCSGRZT98enAG9f5PKn//7+/18ejz/9LRL+x0+/fPnVj6/vj9ePr/71 + 8fzrIPy752dffvYE9PyH/rYJP/X3v332zVev74+/aMJ/fv31919++vXjLx+//PDVz397fX/c5L98 + /fjl47MfP/rBl8fj/y//fzEAAw== + headers: + CF-RAY: + - 9b20d60aecb4e529-TXL + Connection: + - keep-alive + Content-Encoding: + - br + Content-Type: + - application/json + Date: + - Mon, 22 Dec 2025 16:01:08 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - popsql + openai-processing-ms: + - '179' + openai-project: + - proj_5dDGTjmEG103dXSaDgbyDchJ + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-86b4d94c9b-ld56j + x-envoy-upstream-service-time: + - '201' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999996' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_993300a1e5494593ab6d570f74d30a92 + status: + code: 200 + message: OK +version: 1 diff --git a/projects/pgai/tests/vectorizer/cli/test_text_indexing.py b/projects/pgai/tests/vectorizer/cli/test_text_indexing.py new file mode 100644 index 000000000..742b0eebd --- /dev/null +++ b/projects/pgai/tests/vectorizer/cli/test_text_indexing.py @@ -0,0 +1,340 @@ +"""Integration tests for BM25 text indexing in vectorizers. + +Tests verify that the text_indexing parameter works correctly with pg_textsearch. +""" + +from typing import Any + +import pytest +from psycopg import Connection +from psycopg.rows import dict_row + +from tests.vectorizer.cli.conftest import ( + TestDatabase, + run_vectorizer_worker, + setup_source_table, +) + + +def configure_vectorizer_with_text_indexing( + connection: Connection, + table_name: str, + text_indexing: str | None = None, + chunking: str = "chunking_recursive_character_text_splitter(128, 10)", +) -> int: + """Creates a vectorizer with optional text_indexing configuration.""" + text_indexing_clause = ( + f", text_indexing => ai.{text_indexing}" if text_indexing else "" + ) + + with connection.cursor(row_factory=dict_row) as cur: + # Ensure pg_textsearch extension is created if text_indexing uses bm25 + if text_indexing and "bm25" in text_indexing: + cur.execute("CREATE EXTENSION IF NOT EXISTS pg_textsearch CASCADE") + + cur.execute(f""" + SELECT ai.create_vectorizer( + '{table_name}'::regclass, + loading => ai.loading_column('content'), + embedding => ai.embedding_openai('text-embedding-ada-002', 1536), + chunking => ai.{chunking}, + formatting => ai.formatting_python_template('$chunk'), + processing => ai.processing_default(batch_size => 1, concurrency => 1) + {text_indexing_clause} + ) + """) # type: ignore[arg-type] + return int(cur.fetchone()["create_vectorizer"]) # type: ignore + + +def test_text_indexing_creates_bm25_index( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that BM25 index is created on chunk column when text_indexing is enabled.""" + _, conn = cli_db + table_name = setup_source_table(conn, number_of_rows=3) + + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + table_name, + text_indexing="text_indexing_bm25()", + ) + + # Run worker + with vcr_.use_cassette("text_indexing_creates_bm25_index.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Verify BM25 index exists on the embedding table's chunk column + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT indexname, tablename, indexdef FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + index = cur.fetchone() + assert index is not None, "BM25 index should have been created" + assert ( + "chunk" in index["indexdef"].lower() + ), "BM25 index should be on chunk column" + assert ( + "blog_embedding" in index["tablename"] or "embedding" in index["tablename"] + ), f"BM25 index should be on embedding table, got {index['tablename']}" + + +def test_text_indexing_enables_fulltext_search( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that BM25 search queries work after vectorizer creates index.""" + _, conn = cli_db + + # Create table with specific content for search testing + with conn.cursor() as cur: + cur.execute(""" + CREATE TABLE search_docs ( + id SERIAL PRIMARY KEY, + id2 INT NOT NULL DEFAULT 1, + content TEXT NOT NULL + ) + """) + cur.execute(""" + INSERT INTO search_docs (content) VALUES + ('PostgreSQL is a powerful relational database system'), + ('Machine learning models require large training datasets'), + ('Python programming language is popular for data science') + """) + + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + "search_docs", + text_indexing="text_indexing_bm25(text_config => 'english')", + ) + + # Run worker + with vcr_.use_cassette("text_indexing_enables_fulltext_search.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Get index name for BM25 query + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT indexname FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + index_row = cur.fetchone() + assert index_row is not None + index_name = index_row["indexname"] + + # Perform BM25 search - the <@> operator returns negative scores + # where more negative = better match + cur.execute(f""" + SELECT chunk, chunk <@> to_bm25query('PostgreSQL database', '{index_name}') as score + FROM search_docs_embedding_store + ORDER BY chunk <@> to_bm25query('PostgreSQL database', '{index_name}') + LIMIT 3 + """) # type: ignore[arg-type] + results = cur.fetchall() + + # Should have results and the PostgreSQL document should rank well + assert len(results) > 0 + # The first result should contain our search terms or related content + assert any( + "postgresql" in r["chunk"].lower() or "database" in r["chunk"].lower() + for r in results + ) + + +def test_text_indexing_source_column_with_chunking_none( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that BM25 index is created on source column when chunking=none.""" + _, conn = cli_db + + # Create a table with short content that doesn't need chunking + with conn.cursor() as cur: + cur.execute(""" + CREATE TABLE short_docs ( + id SERIAL PRIMARY KEY, + id2 INT NOT NULL DEFAULT 1, + content TEXT NOT NULL + ) + """) + cur.execute(""" + INSERT INTO short_docs (content) VALUES + ('Short document one'), + ('Short document two') + """) + + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + "short_docs", + text_indexing="text_indexing_bm25()", + chunking="chunking_none()", + ) + + # Run worker + with vcr_.use_cassette("text_indexing_source_column.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Verify BM25 index is on source table's content column, not embedding table + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT tablename, indexdef FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + index = cur.fetchone() + assert index is not None, "BM25 index should have been created" + # When chunking=none, index should be on the source table + assert ( + index["tablename"] == "short_docs" + ), f"Expected index on source table, got {index['tablename']}" + assert "content" in index["indexdef"].lower() + + +def test_text_indexing_custom_parameters( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that custom k1, b, text_config parameters are stored in config.""" + _, conn = cli_db + table_name = setup_source_table(conn, number_of_rows=2) + + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + table_name, + text_indexing="text_indexing_bm25(text_config => 'simple', k1 => 1.5, b => 0.8)", + ) + + # Verify the custom parameters are stored in the vectorizer config + with conn.cursor(row_factory=dict_row) as cur: + cur.execute( + """ + SELECT config->'text_indexing' as text_indexing + FROM ai.vectorizer + WHERE id = %s + """, + (vectorizer_id,), + ) + row = cur.fetchone() + assert row is not None + text_indexing_config = row["text_indexing"] + assert text_indexing_config["implementation"] == "bm25" + assert text_indexing_config["text_config"] == "simple" + assert float(text_indexing_config["k1"]) == 1.5 + assert float(text_indexing_config["b"]) == 0.8 + + # Run worker + with vcr_.use_cassette("text_indexing_custom_parameters.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Verify index was created + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT indexdef FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + index = cur.fetchone() + assert index is not None, "BM25 index should have been created" + + +def test_text_indexing_disabled_by_default( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that no BM25 index is created when text_indexing is not specified.""" + _, conn = cli_db + table_name = setup_source_table(conn, number_of_rows=2) + + # Create vectorizer WITHOUT text_indexing parameter + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + table_name, + text_indexing=None, # No text indexing + ) + + # Run worker + with vcr_.use_cassette("text_indexing_disabled_by_default.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Verify NO BM25 index exists + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT count(*) as count FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + row = cur.fetchone() + assert row is not None + assert row["count"] == 0, "No BM25 index should have been created" + + +def test_text_indexing_none_explicitly_disabled( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, + vcr_: Any, +): + """Test that text_indexing_none() explicitly disables BM25 indexing.""" + _, conn = cli_db + table_name = setup_source_table(conn, number_of_rows=2) + + # Create vectorizer with text_indexing=none explicitly + vectorizer_id = configure_vectorizer_with_text_indexing( + conn, + table_name, + text_indexing="text_indexing_none()", + ) + + # Verify the config has implementation=none + with conn.cursor(row_factory=dict_row) as cur: + cur.execute( + """ + SELECT config->'text_indexing' as text_indexing + FROM ai.vectorizer + WHERE id = %s + """, + (vectorizer_id,), + ) + row = cur.fetchone() + assert row is not None + assert row["text_indexing"]["implementation"] == "none" + + # Run worker + with vcr_.use_cassette("text_indexing_none_explicitly_disabled.yaml"): + result = run_vectorizer_worker(cli_db_url, vectorizer_id) + + assert result.exit_code == 0 + + # Verify NO BM25 index exists + with conn.cursor(row_factory=dict_row) as cur: + cur.execute(""" + SELECT count(*) as count FROM pg_indexes + WHERE indexdef ILIKE '%using bm25%' + """) + row = cur.fetchone() + assert row is not None + assert row["count"] == 0 + + +@pytest.mark.skip(reason="Requires container without pg_textsearch extension") +def test_text_indexing_missing_extension_error( + cli_db: tuple[TestDatabase, Connection], + cli_db_url: str, +): + """Test that clear error is raised when pg_textsearch is not installed. + + This test is skipped as it requires a separate container without pg_textsearch. + The error behavior is tested at the SQL level. + """