cocoindex 0.2.2__tar.gz → 0.2.4__tar.gz

cocoindex-0.2.4/.github/workflows/_test.yml

@@ -0,0 +1,65 @@
+name: Run Tests
+
+on:
+    workflow_call:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+    build-test:
+        strategy:
+            matrix:
+                python-version: [3.11]
+                platform:
+                  - { runner: ubuntu-latest, python_exec: ".venv/bin/python" }
+                  - { runner: ubuntu-24.04-arm, python_exec: ".venv/bin/python" }
+                  - { runner: macos-latest, python_exec: ".venv/bin/python" }
+                  - { runner: macos-13, python_exec: ".venv/bin/python" }
+                  - { runner: windows-latest, python_exec: ".venv\\Scripts\\python" }
+        runs-on: ${{ matrix.platform.runner }}
+        steps:
+        - uses: actions/checkout@v4
+
+        - uses: actions/setup-python@v5
+          id: setup_python
+          with:
+            python-version: ${{ matrix.python-version }}
+            cache: 'pip'
+
+        - run: rustup toolchain install stable --profile minimal
+        - name: Rust Cache
+          uses: Swatinem/rust-cache@v2
+          with:
+            key: rust-${{ matrix.platform.runner }}-${{ matrix.python-version }}
+        - name: Rust tests
+          run: cargo test --verbose
+
+        - uses: actions/cache@v4
+          with:
+            path: .venv
+            key: pyenv-${{ matrix.platform.runner }}-${{ steps.setup_python.outputs.python-version }}-${{ hashFiles('pyproject.toml') }}
+            restore-keys: |
+              pyenv-${{ matrix.platform.runner }}-${{ steps.setup_python.outputs.python-version }}-
+
+        - name: Setup venv
+          run: |
+            python -m venv .venv
+        - name: Install Python toolchains
+          run: |
+            ${{ matrix.platform.python_exec }} -m pip install maturin mypy pytest pytest-asyncio
+        - name: Python build
+          run: |
+            ${{ matrix.platform.python_exec }} -m maturin develop -E all
+        - name: Python type check (mypy)
+          run: |
+            ${{ matrix.platform.python_exec }} -m mypy python
+        - name: Python tests
+          if: ${{ !startsWith(matrix.platform.runner, 'windows') }}
+          run: |
+            ${{ matrix.platform.python_exec }} -m pytest --capture=no python/cocoindex/tests
+        - name: Python tests (Windows cmd)
+          if: ${{ startsWith(matrix.platform.runner, 'windows') }}
+          shell: cmd  # Use `cmd` to run test for Windows, as PowerShell doesn't detect exit code by `os._exit(0)` correctly.
+          run: |
+            ${{ matrix.platform.python_exec }} -m pytest --capture=no python/cocoindex/tests

{cocoindex-0.2.2 → cocoindex-0.2.4}/.github/workflows/release.yml

@@ -1,8 +1,7 @@
-# This file is autogenerated by maturin v1.8.1
-# To update, run
-#
-#    maturin generate-ci github
+# This workflow can be triggered on tags push (automatic release) or manually on any branch.
 #
+# - When triggered on tags push, it will build and publishes a new version including docs.
+# - When triggered manually, it's a dry-run: only build, without publishing anything.
 name: release
 
 on:
@@ -31,11 +30,11 @@ jobs:
     strategy:
       matrix:
         platform:
-          - { os: linux, runner: ubuntu-24.04, target: x86_64, container: "ghcr.io/rust-cross/manylinux_2_28-cross:x86_64" }
-          - { os: linux, runner: ubuntu-24.04, target: aarch64, container: "ghcr.io/rust-cross/manylinux_2_28-cross:aarch64" }
-          - { os: windows, runner: windows-latest, target: x64 }
+          - { os: linux, runner: ubuntu-latest, target: x86_64, container: "ghcr.io/rust-cross/manylinux_2_28-cross:x86_64" }
+          - { os: linux, runner: ubuntu-24.04-arm, target: aarch64, container: "ghcr.io/rust-cross/manylinux_2_28-cross:aarch64" }
+          - { os: macos, runner: macos-latest, target: aarch64 }
           - { os: macos, runner: macos-13, target: x86_64 }
-          - { os: macos, runner: macos-14, target: aarch64 }
+          - { os: windows, runner: windows-latest, target: x64 }
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v4
@@ -43,12 +42,12 @@ jobs:
           name: Cargo.toml
       - uses: actions/setup-python@v5
         with:
-          python-version: 3.x
+          python-version: 3.13
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist
           sccache: 'true'
           manylinux: auto
           container: ${{ matrix.platform.container }}
@@ -58,6 +57,24 @@ jobs:
           name: wheels-${{ matrix.platform.os }}-${{ matrix.platform.target }}
           path: dist
 
+  test-abi3:
+    runs-on: ubuntu-24.04
+    needs: build
+    strategy:
+      matrix:
+        py: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-linux-x86_64
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.py }}
+      - run: python -V
+      - run: pip install --find-links=./ cocoindex
+      - run: python -c "import cocoindex, sys; print('import ok on', sys.version)"
+
+
   sdist:
     runs-on: ubuntu-latest
     needs: [create-versioned-toml]
@@ -80,7 +97,7 @@ jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
-    needs: [create-versioned-toml, build, sdist]
+    needs: [create-versioned-toml, build, test-abi3, sdist]
     permissions:
       # Use to sign the release artifacts
       id-token: write
@@ -111,5 +128,6 @@ jobs:
   release-docs:
     name: Release Docs
     needs: [release]
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
     uses: ./.github/workflows/_doc_release.yml
     secrets: inherit

{cocoindex-0.2.2 → cocoindex-0.2.4}/Cargo.lock

@@ -1283,7 +1283,7 @@ dependencies = [
 
 [[package]]
 name = "cocoindex"
-version = "0.2.2"
+version = "0.2.4"
 dependencies = [
  "anyhow",
  "async-openai",

{cocoindex-0.2.2 → cocoindex-0.2.4}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "cocoindex"
 # Version used for local development is always higher than others to take precedence.
 # Will be overridden for specific release versions.
-version = "0.2.2"
+version = "0.2.4"
 edition = "2024"
 rust-version = "1.88"
 readme = "README.md"
@@ -16,7 +16,12 @@ name = "cocoindex_engine"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.25.1", features = ["chrono", "auto-initialize", "uuid"] }
+pyo3 = { version = "0.25.1", features = [
+    "abi3-py311",
+    "auto-initialize",
+    "chrono",
+    "uuid",
+] }
 pythonize = "0.25.0"
 pyo3-async-runtimes = { version = "0.25.0", features = ["tokio-runtime"] }
 

{cocoindex-0.2.2 → cocoindex-0.2.4}/PKG-INFO

@@ -1,6 +1,21 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.2.2
+Version: 0.2.4
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Typing :: Typed
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0
 Requires-Dist: python-dotenv>=1.1.0
@@ -21,6 +36,7 @@ Provides-Extra: colpali
 Provides-Extra: all
 License-File: LICENSE
 Summary: With CocoIndex, users declare the transformation, CocoIndex creates & maintains an index, and keeps the derived index up to date based on source update, with minimal computation and changes.
+Keywords: indexing,real-time,incremental,pipeline,search,ai,etl,rag,dataflow,context-engineering
 Author-email: CocoIndex <cocoindex.io@gmail.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{cocoindex-0.2.2 → cocoindex-0.2.4}/docs/docs/core/cli.mdx

@@ -17,8 +17,13 @@ Once CocoIndex is installed, you can invoke the CLI directly using the `cocoinde
 ### APP_TARGET Format
 
 The `APP_TARGET` can be:
-1.  A **path to a Python file** defining your flows (e.g., `main.py`, `path/to/my_flows.py`).
-2.  An **installed Python module name** that contains your flow definitions (e.g., `my_package.flows`).
+1.  An **Python module name** that contains your flow definitions (e.g., `main`, `my_package.flows`).
+    You can also use `--app-dir <path>` to specify the base directory to load the module from.
+
+2.  A **path to a Python file** defining your flows (e.g., `main.py`, `path/to/my_flows.py`).
+
+    The file will be loaded as a top-level Python module, e.g. relative imports will not work as its parent package is not defined (similar to how `python main.py` works).
+
 3.  For commands that operate on a *specific flow* (like `show`, `update`, `evaluate`), you can combine the application reference with a flow name:
     * `path/to/my_flows.py:MyFlow`
     * `my_package.flows:MyFlow`
@@ -44,6 +49,7 @@ If no file is found, only existing system environment variables are used.
 CocoIndex CLI supports the following global options:
 
 * `--env-file <path>`: Load environment variables from a specified `.env` file. If not provided, `.env` in the current directory is loaded if it exists.
+* `--app-dir <path>`: Load apps from the specified directory. It will be treated as part of `PYTHONPATH`. Default to the current directory.
 * `--version`: Show the CocoIndex version and exit.
 * `--help`: Show the main help message and exit.
 

cocoindex-0.2.4/docs/docs/examples/examples/postgres_source.md

@@ -0,0 +1,299 @@
+---
+title:  Transform Data From Structured Source in PostgreSQL
+description: Transform data from PostgreSQL table as source, transform with both AI models and non-AI data mappings, and write them into PostgreSQL/PgVector for semantic + structured search.
+sidebar_class_name: hidden
+slug: /examples/postgres_source
+canonicalUrl: '/examples/postgres_source'
+sidebar_custom_props:
+  image: /img/examples/postgres_source/cover.png
+  tags: [data-mapping, vector-index, postgres]
+tags: [data-mapping, vector-index, postgres]
+---
+import { GitHubButton, YouTubeButton, DocumentationButton } from '../../../src/components/GitHubButton';
+
+<GitHubButton url="https://github.com/cocoindex-io/cocoindex/tree/main/examples/postgres_source" margin="0 0 24px 0" /
+>
+![PostgreSQL Product Indexing Flow](/img/examples/postgres_source/cover.png)
+
+[CocoIndex](https://github.com/cocoindex-io/cocoindex) is one framework for building **incremental** data flows across **structured and unstructured** sources. This tutorial shows how to take data from PostgreSQL table as source, transform with both AI and non-AI data mappings, and write them into a new PostgreSQL table with PgVector for semantic + structured search.
+
+## PostgreSQL Product Indexing Flow
+![PostgreSQL Product Indexing Flow](/img/examples/postgres_source/flow.png)
+
+- Reading data from a PostgreSQL table `source_products`.
+- Computing additional fields (`total_value`, `full_description`).
+- Generating embeddings for semantic search.
+- Storing the results in another PostgreSQL table with a vector index using pgvector
+
+
+### Connect to source
+
+`flow_builder.add_source` reads rows from `source_products`.
+
+```python
+@cocoindex.flow_def(name="PostgresProductIndexing")
+def postgres_product_indexing_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope) -> None:
+  
+    data_scope["products"] = flow_builder.add_source(
+        cocoindex.sources.Postgres(
+            table_name="source_products",
+            # Optional. Use the default CocoIndex database if not specified.
+            database=cocoindex.add_transient_auth_entry(
+                cocoindex.DatabaseConnectionSpec(
+                    url=os.environ["SOURCE_DATABASE_URL"],
+                )
+            ),
+            # Optional.
+            ordinal_column="modified_time",
+            notification=cocoindex.sources.PostgresNotification(),
+        ),
+    )
+```
+This step adds source data from PostgreSQL table `source_products` to the flow as a `KTable`.
+
+![Add PostgreSQL Source](/img/examples/postgres_source/source.png)
+
+CocoIndex incrementally sync data from Postgres. When new or updated rows are found, only those rows run through the pipeline, so downstream indexes and search results reflect the latest data while unchanged rows are untouched. The following two arguments (both are optional) make this more efficient:
+
+- `notification` enables change capture based on Postgres LISTEN/NOTIFY. Each change triggers an incremental processing on the specific row immediately.
+- Regardless if `notification` is provided or not, CocoIndex still needs to scan the full table to detect changes in some scenarios (e.g. between two `update` invocation), and the `ordinal_column` provides a field that CocoIndex can use to quickly detect which row has changed without reading value columns. 
+
+Check [Postgres source](https://cocoindex.io/docs/ops/sources#postgres) for more details. 
+
+If you use the Postgres database hosted by Supabase, please click Connect on your project dashboard and find the URL there. Check [DatabaseConnectionSpec](https://cocoindex.io/docs/core/settings#databaseconnectionspec)
+for more details.
+
+## Simple Data Mapping / Transformation
+
+Create a simple transformation to calculate the total price. 
+
+```python
+@cocoindex.op.function()
+def calculate_total_value(price: float, amount: int) -> float:
+    """Compute total value for each product."""
+    return price * amount
+```
+
+Plug into the flow:
+
+```python
+with data_scope["products"].row() as product:
+     # Compute total value
+    product["total_value"] = flow_builder.transform(
+        calculate_total_value,
+        product["price"],
+        product["amount"],
+    )
+```
+
+![Calculate Total Value](/img/examples/postgres_source/price.png)
+
+### Data Transformation & AI Transformation
+
+Create a custom function creates a `full_description` field by combining the product’s category, name, and description.
+
+```python
+@cocoindex.op.function()
+def make_full_description(category: str, name: str, description: str) -> str:
+    """Create a detailed product description for embedding."
+    return f"Category: {category}\nName: {name}\n\n{description}"
+
+```
+
+Embeddings often perform better with more context. By combining fields into a single text string, we ensure that the semantic meaning of the product is captured fully.
+
+Now plug into the flow:
+
+```python
+with data_scope["products"].row() as product:
+    #.. other transformations
+
+    # Compute full description
+    product["full_description"] = flow_builder.transform(
+        make_full_description,
+        product["product_category"],
+        product["product_name"],
+        product["description"],
+    )
+    
+    # Generate embeddings
+    product["embedding"] = product["full_description"].transform(
+        cocoindex.functions.SentenceTransformerEmbed(
+            model="sentence-transformers/all-MiniLM-L6-v2"
+        )
+    )
+    
+    # Collect data 
+    indexed_product.collect(
+        product_category=product["product_category"],
+        product_name=product["product_name"],
+        description=product["description"],
+        price=product["price"],
+        amount=product["amount"],
+        total_value=product["total_value"],
+        embedding=product["embedding"],
+    )
+```
+
+This takes each product row, and does the following:
+
+1. builds a rich description. 
+
+    ![Make Full Description](/img/examples/postgres_source/description.png)
+
+2. turns it into an embedding
+
+    ![Embed Full Description](/img/examples/postgres_source/embed.png)
+
+3. collects the embedding along with structured fields (category, name, price, etc.).
+
+    ![Collect Embedding](/img/examples/postgres_source/collector.png)
+
+
+## Export
+
+```python
+indexed_product.export(
+    "output",
+    cocoindex.targets.Postgres(),
+    primary_key_fields=["product_category", "product_name"],
+    vector_indexes=[
+        cocoindex.VectorIndexDef(
+            field_name="embedding",
+            metric=cocoindex.VectorSimilarityMetric.COSINE_SIMILARITY,
+        )
+    ],
+)
+```
+
+All transformed rows are collected and exported to a new PostgreSQL table with a vector index, ready for semantic search.
+
+
+## Field lineage
+When the transform flow starts to getting complex, it's hard to understand how each field is derived.
+CocoIndex provides a way to visualize the lineage of each field, to make it easier to trace and troubleshoot field origins and downstream dependencies.
+
+For example, the following image shows the lineage of the `embedding` field, you can click from the final output backward all the way to the source fields, step by step.
+
+![Field Lineage](/img/examples/postgres_source/lineage.png)
+
+
+## Running the Pipeline
+
+1. Set up dependencies:
+    
+    ```bash
+    pip install -e .
+    ```
+    
+2. Create the source table with sample data:
+    
+    ```bash
+    psql "postgres://cocoindex:cocoindex@localhost/cocoindex" -f ./prepare_source_data.sql
+    ```
+    
+3. Setup tables and update the index:
+    
+    ```bash
+    cocoindex update --setup main.py
+    ```
+    
+4. Run CocoInsight:
+    
+    ```bash
+    cocoindex server -ci main.py
+    ```
+    You can walk through the project step by step in CocoInsight to see exactly how each field is constructed and what happens behind the scenes. It connects to your local CocoIndex server, with zero pipeline data retention.
+
+
+## Continuous Updating
+
+For continuous updating when the source changes, add `-L`:
+
+```bash
+cocoindex server -ci -L main.py
+```
+Check [live updates](https://cocoindex.io/docs/tutorials/live_updates) for more details.
+
+## Search and Query the Index
+
+### Query
+
+Runs a semantic similarity search over the indexed products table, returning the top matches for a given query.
+
+```python
+def search(pool: ConnectionPool, query: str, top_k: int = 5) -> list[dict[str, Any]]:
+    # Get the table name, for the export target in the text_embedding_flow above.
+    table_name = cocoindex.utils.get_target_default_name(
+        postgres_product_indexing_flow, "output"
+    )
+    # Evaluate the transform flow defined above with the input query, to get the embedding.
+    query_vector = text_to_embedding.eval(query)
+    # Run the query and get the results.
+    with pool.connection() as conn:
+        register_vector(conn)
+        with conn.cursor(row_factory=dict_row) as cur:
+            cur.execute(
+                f"""
+                SELECT
+                    product_category,
+                    product_name,
+                    description,
+                    amount,
+                    total_value,
+                    (embedding <=> %s) AS distance
+                FROM {table_name}
+                ORDER BY distance ASC
+                LIMIT %s
+            """,
+                (query_vector, top_k),
+            )
+            return cur.fetchall()
+```
+This function
+
+- Converts the query text into an embedding (`query_vector`).
+- Compares it with each product’s stored embedding (`embedding`) using vector distance.
+- Returns the closest matches, including both metadata and the similarity score (`distance`).
+
+### Create an command-line interactive loop
+
+```python
+def _main() -> None:
+    # Initialize the database connection pool.
+    pool = ConnectionPool(os.environ["COCOINDEX_DATABASE_URL"])
+    # Run queries in a loop to demonstrate the query capabilities.
+    while True:
+        query = input("Enter search query (or Enter to quit): ")
+        if query == "":
+            break
+        # Run the query function with the database connection pool and the query.
+        results = search(pool, query)
+        print("\nSearch results:")
+        for result in results:
+            score = 1.0 - result["distance"]
+            print(
+                f"[{score:.3f}] {result['product_category']} | {result['product_name']} | {result['amount']} | {result['total_value']}"
+            )
+            print(f"    {result['description']}")
+            print("---")
+        print()
+
+if __name__ == "__main__":
+    load_dotenv()
+    cocoindex.init()
+    _main()
+```
+
+### Run as a Service
+
+This [example](https://cocoindex.io/docs/examples/image_search#fast-api-application) runs as a service using Fast API.
+
+
+## Why One Framework for Structured + Unstructured?
+
+- One mental model: Treat files, APIs, and databases uniformly; AI steps are ordinary ops.
+- Incremental by default: Use an ordinal column to sync only changes; no fragile glue jobs.
+- Consistency: Embeddings are always derived from the exact transformed row state.
+- Operational simplicity: One deployment, one lineage view, fewer moving parts.
+

{cocoindex-0.2.2 → cocoindex-0.2.4}/docs/docs/examples/examples/simple_vector_index.md

@@ -71,34 +71,21 @@ with data_scope["documents"].row() as doc:
 ### Embed each chunk 
 
 ```python
-@cocoindex.transform_flow()
-def text_to_embedding(text: cocoindex.DataSlice[str]) -> cocoindex.DataSlice[list[float]]:
-    """
-    Embed the text using a SentenceTransformer model.
-    This is a shared logic between indexing and querying, so extract it as a function.
-    """
-    return text.transform(
+with doc["chunks"].row() as chunk:
+    chunk["embedding"] = chunk["text"].transform(
         cocoindex.functions.SentenceTransformerEmbed(
-            model="sentence-transformers/all-MiniLM-L6-v2"))
+            model="sentence-transformers/all-MiniLM-L6-v2"
+        )
+    ) 
+    doc_embeddings.collect(filename=doc["filename"], location=chunk["location"],
+                            text=chunk["text"], embedding=chunk["embedding"])
 ```
-![Embedding](/img/examples/simple_vector_index/embed.png)
-
-This code defines a transformation function that converts text into vector embeddings using the SentenceTransformer model.
-`@cocoindex.transform_flow()` is needed to share the transformation across indexing and query.
-This decorator marks this as a reusable transformation flow that can be called on specific input data from user code using `eval()`, as shown in the search function below. 
 
 The `MiniLM-L6-v2` model is a good balance of speed and quality for text embeddings, though you can swap in other SentenceTransformer models as needed.
 
 <DocumentationButton url="https://cocoindex.io/docs/ops/functions#sentencetransformerembed" text="SentenceTransformerEmbed" margin="0 0 16px 0" />
- 
-Plug in the `text_to_embedding` function and collect the embeddings.
 
-```python
-with doc["chunks"].row() as chunk:
-    chunk["embedding"] = text_to_embedding(chunk["text"])
-    doc_embeddings.collect(filename=doc["filename"], location=chunk["location"],
-                            text=chunk["text"], embedding=chunk["embedding"])
-```
+![Embedding](/img/examples/simple_vector_index/embed.png)
 
 ## Export the embeddings
 
@@ -119,10 +106,32 @@ CocoIndex supports other vector databases as well, with 1-line switch.
 
 ## Query the index
 
+### Define a shared flow for both indexing and querying
+
+```python
+@cocoindex.transform_flow()
+def text_to_embedding(text: cocoindex.DataSlice[str]) -> cocoindex.DataSlice[list[float]]:
+    """
+    Embed the text using a SentenceTransformer model.
+    This is a shared logic between indexing and querying, so extract it as a function.
+    """
+    return text.transform(
+        cocoindex.functions.SentenceTransformerEmbed(
+            model="sentence-transformers/all-MiniLM-L6-v2"))
+```
+
+This code defines a transformation function that converts text into vector embeddings using the SentenceTransformer model.
+`@cocoindex.transform_flow()` is needed to share the transformation across indexing and query.
+
+This decorator marks this as a reusable transformation flow that can be called on specific input data from user code using `eval()`, as shown in the search function below. 
+
+### Write query
+
 CocoIndex doesn't provide additional query interface at the moment. We can write SQL or rely on the query engine by the target storage, if any.
 
 <DocumentationButton url="https://cocoindex.io/docs/ops/targets#postgres" text="Postgres" margin="0 0 16px 0" />
 
+
 ```python
 def search(pool: ConnectionPool, query: str, top_k: int = 5):
     table_name = cocoindex.utils.get_target_storage_default_name(text_embedding_flow, "doc_embeddings")
@@ -166,6 +175,19 @@ if __name__ == "__main__":
     _main()
 ```
 
+In the function above, most parts are standard query logic - you can use any libraries you like.
+There're two CocoIndex-specific logic:
+
+1.  Get the table name from the export target in the `text_embedding_flow` above.
+    Since the table name for the `Postgres` target is not explicitly specified in the `export()` call,
+    CocoIndex uses a default name.
+    `cocoindex.utils.get_target_default_name()` is a utility function to get the default table name for this case.
+
+2.  Evaluate the transform flow defined above with the input query, to get the embedding.
+    It's done by the `eval()` method of the transform flow `text_to_embedding`.
+    The return type of this method is `NDArray[np.float32]` as declared in the `text_to_embedding()` function (`cocoindex.DataSlice[NDArray[np.float32]]`).
+
+
 
 ## Time to have fun!
 - Run the following command to setup and update the index.