@clickzetta/cz-cli-darwin-x64 0.3.95 → 0.3.100

package/bin/skills/lakehouse-doc-en/references/Create_Embeding_Function.md

@@ -0,0 +1,236 @@
+# **External AI Functions**: Creating an Embedding Function
+
+Objective: Use the Alibaba Cloud Bailian platform's Embedding functions to vectorize text and image file data, and implement an image search scenario. The result is as follows:
+
+![](.topwrite/assets/image_search.png)
+
+> Note: To complete this example, you need to:
+>
+> 1. Have Docker installed (primarily to ensure the development environment is consistent with the environment where functions run in the cloud)
+> 2. Have an Alibaba Cloud account and obtain an API-KEY for the Bailian platform. Refer to [Alibaba Cloud Bailian](https://www.aliyun.com/product/bailian)
+> 3. Have already created an API connection. Refer to: Create [API Connection](create-api-connection.md)
+
+### Step 1: Prepare the Development Environment
+
+1. **Install Docker**: Ensure Docker is installed locally: <https://www.docker.com/>
+
+2. **Pull the Docker image**. Execute in a local command-line terminal (such as macOS Terminal):
+
+   ```
+   [Local]# docker pull quay.io/pypa/manylinux2014_x86_64:2022-10-25-fbea779
+   ```
+
+3. **Start the Docker container**: This container is based on the `manylinux2014_x86_64` image and is configured to use the Python 3.10 environment.
+
+   ```
+   [Local]# docker run -it --name cz_func --env PATH="/opt/python/cp310-cp310/bin:$PATH" quay.io/pypa/manylinux2014_x86_64:2022-10-25-fbea779 bash
+   ```
+
+> If the container has already stopped, use the following commands to start and enter it:
+>
+> 1. **Start the container**:
+>
+> ```
+> # docker start cz_func
+> ```
+>
+> 2. **Enter the container**:
+>
+> ```
+> # docker exec -it cz_func bash
+> ```
+
+4. Create a folder `embeddings` under the /root directory
+
+```
+[root@docker root]# cd /root ; mkdir embeddings 
+[root@docker embeddings]# cd embeddings
+[root@docker embeddings]# touch gen_embeddings.py
+```
+
+5. The program code in `cz_llm.py` is as follows:
+
+```
+import os
+from cz.udf import annotate
+from openai import OpenAI
+import json
+
+@annotate("*->string")
+class get_embeddings(object):
+    def evaluate(self, model_type, input_string, api_key, model_name, dim=None):
+
+        if model_type == "text":
+            # Initialize the OpenAI client with the user-provided API key
+            client = OpenAI(
+                api_key=api_key,
+                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
+            )
+
+            input_data = input_string
+            completion = client.embeddings.create(
+                model=model_name,  # Use the user-provided text model name
+                input=input_data,
+                dimensions=int(dim),  # Specify the vector dimension
+                encoding_format="float"
+            )
+            result_json = json.loads(completion.model_dump_json())
+            embedding_vector = result_json['data'][0]['embedding']
+
+        elif model_type == "multimodal":
+            import dashscope
+            image = input_string
+            dashscope.api_key = api_key  # Use the user-provided API key
+            input = [{'image': image}]
+            resp = dashscope.MultiModalEmbedding.call(
+                model=model_name,  # Use the user-provided multimodal model name
+                input=input
+            )
+            result_json = json.loads(json.dumps(resp.output, ensure_ascii=False, indent=4))
+            embedding_vector = result_json['embeddings'][0]['embedding']
+        else:
+            return "Not Valid Model Type"
+
+        if len(embedding_vector) >= 1:
+            return str(embedding_vector)
+        else:
+            return "Not Valid"
+# Add command-line invocation entry point
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Get Embeddings using OpenAI or DashScope")
+    parser.add_argument('--model_type', required=True, help='Model type: text or multimodal')
+    parser.add_argument('--input_string', required=True, help='The input string or image path')
+    parser.add_argument('--api_key', required=True, help='Your API key')
+    parser.add_argument('--model_name', required=True, help='Model name')
+    parser.add_argument('--dim', default=1536, help='Vector dimensions (only for text models)')
+
+    args = parser.parse_args()
+
+    embedder = get_embeddings()
+    result = embedder.evaluate(
+        model_type=args.model_type,
+        input_string=args.input_string,
+        api_key=args.api_key,
+        model_name=args.model_name,
+        dim=args.dim
+    )
+    print(result)
+```
+
+### Step 2: Download Third-party Libraries
+
+The program depends on the third-party package `openai`, which needs to be downloaded (the rest are Python built-in libraries; `os` and `json` are built into Python and do not need to be downloaded. `cz.udf` is automatically added by the system when creating the function).
+
+Execute in the development environment command-line terminal:
+
+```
+[root@docker embeddings]# pwd
+/root/embeddings
+
+[root@docker embeddings]# pip install openai -t .
+```
+
+The directory structure at this point will look similar to:
+
+![](.topwrite/assets/vector2.jpeg)
+
+### Step 3: Local Debugging
+
+The following 3 lines of code need to be modified, because the current environment has not yet loaded the `cz.udf` library:
+
+```
+...
+2 #from cz.udf import annotate   # Comment out
+...
+6 #@annotate("*->string")  # Comment out
+...
+```
+
+The API_KEY is the API-KEY of the Alibaba Cloud Bailian platform. You need to register an Alibaba Cloud account, log in, and obtain it here: [Alibaba Cloud Bailian](https://bailian.console.aliyun.com/?spm=5176.12818093_47.console-base_search-panel.dtab-product_sfm.60852cc9WIq2Db\&scm=20140722.S_sfm._.ID_sfm-RL_%E5%A4%A7%E6%A8%A1%E5%9E%8B%E6%9C%8D%E5%8A%A1%E5%B9%B3%E5%8F%B0%E7%99%BE%E7%82%BC%E6%8E%A7%E5%88%B6%E5%8F%B0-LOC_console_console-OR_ser-V_4-P0_0\&tab=api#/api)
+
+After commenting out the above two lines, save and exit the editing script. Replace the image_url and api_key below with actual parameters and execute:
+
+```
+[root@docker embeddings]# export PYTHONPATH="${_PWD}:${_PWD}/lib"
+[root@docker embeddings]# python gen_embeddings.py \
+    --model_type multimodal \
+    --input_string ${image_url} \
+    --api_key ${api_key} \
+    --model_name multimodal-embedding-v1
+```
+
+### Step 4: Package and Upload
+
+Before packaging, uncomment the two lines commented out above.
+
+```
+...
+2 from cz.udf import annotate   # Uncomment
+...
+8 @annotate("*->string")  # Uncomment
+```
+
+Before executing the packaging command, ensure the current directory is the program directory (for this example, `/root/cz_llm`).
+
+```
+[root@docker embeddings]# pwd
+/root/embeddings
+[root@docker embeddings]# zip -rq ../embeddings.zip ./
+[root@docker embeddings]# ls ../
+```
+
+> Tip: If your environment does not have the zip command, try installing it with `yum install zip`. If you encounter issues during installation, please refer to the appendix "**Errors When Installing Tools**".
+
+You will find a `cz_llm.zip` file in the `/root` directory. Copy this file to the Lakehouse USER VOLUME:
+
+Execute on the Docker host machine:
+
+```
+[Local]# docker cp cz_func:/root/embeddings.zip ~/Downloads
+```
+
+Now `cz_llm.zip` is in the host machine's user `Downloads` directory
+
+Use the Lakehouse JDBC client (please refer to [Lakehouse JDBC Client](connect-with-cli.md)) to put the file into the Lakehouse USER VOLUME:
+
+```
+PUT '/Users/derekmeng/Downloads/embeddings.zip' to USER VOLUME;
+```
+
+![](.topwrite/assets/image2.jpeg)
+
+### Step 5: Create and Use the Function:
+
+This step depends on having created an API Connection in advance. Please refer to: [API Connection](create-api-connection.md) for the creation process.
+
+```
+CREATE EXTERNAL FUNCTION public.fc_embeddings
+AS 'gen_embeddings.get_embeddings'
+USING ARCHIVE 'volume:user://~/embeddings.zip'
+connection sg_fc_api_conn
+WITH PROPERTIES (
+'remote.udf.api' = 'python3.mc.v0'
+)
+COMMENT 'Examples:
+For text: text <input_string> <api_key> <model_name> <dim>
+For multimodal:multimodal <input_string> <api_key> <model_name>';
+```
+
+```
+# Verify
+select public.fc_embeddings('multimodal', 'http://viapi-test.oss-cn-shanghai.aliyuncs.com/viapi-3.0domepic/imagerecog/RecognizeFood/RecognizeFood5.jpg', '${api_key}', 'multimodal-embedding-v1');
+```
+
+Execution result:
+
+![](.topwrite/assets/images.jpeg)
+
+The next step is the core step for implementing the image search functionality. This query takes an image URL, vectorizes it, and then compares it with all image vectors in the data table (`food_images_data_vec`). The contents of the table `food_images_data_vec` are as follows:
+
+![](.topwrite/assets/image_search.jpeg)
+
+Vector image search results:
+
+![](.topwrite/assets/image_vec2.jpeg)

package/bin/skills/lakehouse-doc-en/references/Create_LLM_Function.md

@@ -0,0 +1,242 @@
+# Creating an LLM Function to Analyze Company Industry
+
+Objective: Use large language model (LLM) services to fill in nationally standardized **primary industry** and **secondary industry** information based on the **company name** column in the Lakehouse customer table. The result is as follows:
+
+![](.topwrite/assets/20250612-171447.jpeg =675)
+
+> Note: To complete this example, you need to:
+>
+> 1. Have Docker installed (primarily to ensure the development environment is consistent with the Singdata environment for running functions)
+> 2. Have an Alibaba Cloud account and obtain an API-KEY for the Bailian platform. Refer to [Alibaba Cloud Bailian](https://www.aliyun.com/product/bailian)
+> 3. Have already created an API connection. Refer to: Create [API Connection](create-api-connection.md)
+
+### Step 1: Prepare the Development Environment
+
+1. **Install Docker**: Ensure Docker is installed locally: <https://www.docker.com/>
+
+2. **Pull the Docker image**. Execute in a local command-line terminal (such as macOS terminal):
+
+   ```
+   [Local]# docker pull quay.io/pypa/manylinux2014_x86_64:2022-10-25-fbea779
+   ```
+
+3. **Start the Docker container**. This container is based on the `manylinux2014_x86_64` image and is configured to use the Python 3.10 environment.
+
+   ```
+   [Local]# docker run -it --name cz_func --env PATH="/opt/python/cp310-cp310/bin:$PATH" quay.io/pypa/manylinux2014_x86_64:2022-10-25-fbea779 bash
+   ```
+
+> If the container has already stopped, use the following commands to start and log in:
+>
+> 1. **Start the container**:
+>
+> ```
+> # docker start cz_func
+> ```
+>
+> 2. **Enter the container**:
+>
+> ```
+> # docker exec -it cz_func bash
+> ```
+
+&#x20;    4\.  Create a folder `cz_llm` under the /root directory
+
+```
+[root@docker root]# cd /root ; mkdir cz_llm 
+[root@docker cz_llm]# cd cz_llm
+[root@docker cz_llm]# touch cz_llm.py
+```
+
+5. Save the following program code into the `cz_llm.py` file:
+
+```
+import os
+from cz.udf import annotate
+import dashscope
+from http import HTTPStatus
+import json
+import sys
+
+@annotate("*->string")
+class llm_call(object):
+    def evaluate(self, text, prompt, api_key, model_name, temperature=0.7, enable_search=False):
+
+        # Set API key
+        dashscope.api_key = api_key
+
+        # Build messages
+        messages = [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": text}
+        ]
+
+        try:
+            # Call the model (non-streaming output)
+            response = dashscope.Generation.call(
+                model=model_name,
+                messages=messages,
+                stream=False,  # Disable streaming output
+                result_format='message',
+                temperature=temperature,
+                enable_search=enable_search,
+                top_p=0.8
+            )
+
+            # Handle response
+            if response.status_code == HTTPStatus.OK:
+                # Non-streaming output: retrieve the complete content directly
+                if hasattr(response.output, 'choices') and len(response.output.choices) > 0:
+                    if hasattr(response.output.choices[0].message, 'content'):
+                        return response.output.choices[0].message.content
+                    else:
+                        return "Error: No content in response"
+                else:
+                    return "Error: No choices in response"
+            else:
+                # Return error message
+                return f"Error: Request id: {response.request_id}, Status code: {response.status_code}, error code: {response.code}, error 
+message: {response.message}"
+
+        except Exception as e:
+            # Return error message
+            return f"Error: {str(e)}"
+
+# Test code
+if __name__ == "__main__":
+    # Create instance
+    llm = llm_call()
+    
+    # Configure parameters
+    API_KEY = "sk-xxxxxx"  # Replace with your API key
+    MODEL_NAME = "qwen-max"  # or qwen-plus, qwen-max, etc.
+    
+    # Test example
+    test_text = 'Little Red Book'
+    test_prompt = 'Return the nationally standardized primary and secondary industries for this company. Output the result directly as JSON: {"primary_industry":"xxx","secondary_industry":"xxx"}. Be concise.'
+    
+    print("Calling LLM...")
+    result = llm.evaluate(test_text, test_prompt, API_KEY, MODEL_NAME, 0, True)
+    
+    print(f"\nInput text: {test_text}")
+    print(f"System prompt: {test_prompt}")
+    print(f"LLM response: {result}")
+```
+
+### Step 2: Download Third-party Libraries
+
+The program depends on the third-party package `dashscope`, which needs to be downloaded (the rest are Python built-in libraries, such as `os`, `http`, `json`, `sys`, etc., and do not need to be downloaded. `cz.udf` is automatically added by the system when creating the function).
+
+Execute in the development environment command-line terminal:
+
+```
+[root@docker cz_llm]# pwd
+/root/cz_llm
+
+[root@docker cz_llm]# pip install dashscope -t .
+```
+
+The directory structure at this point will look similar to:
+
+![](.topwrite/assets/external_func_2.jpeg)
+
+^
+
+### Step 3: Local Debugging
+
+The following 3 lines will be modified, because the current environment has not yet loaded the `cz.udf` library:
+
+```
+...
+2 #from cz.udf import annotate   # Comment out
+...
+8 #@annotate("*->string")  # Comment out
+...
+56 API_KEY = "sk-xxxxxx"  # Replace with your API key
+```
+
+The API_KEY is the API-KEY of the Alibaba Cloud Bailian platform. You need to register an Alibaba Cloud account, log in, and obtain it here: [Alibaba Cloud Bailian](https://bailian.console.aliyun.com/?spm=5176.12818093_47.console-base_search-panel.dtab-product_sfm.60852cc9WIq2Db\&scm=20140722.S_sfm._.ID_sfm-RL_%E5%A4%A7%E6%A8%A1%E5%9E%8B%E6%9C%8D%E5%8A%A1%E5%B9%B3%E5%8F%B0%E7%99%BE%E7%82%BC%E6%8E%A7%E5%88%B6%E5%8F%B0-LOC_console_console-OR_ser-V_4-P0_0\&tab=api#/api)
+
+After commenting out the above two lines, save and exit the editing script. Execute:
+
+```
+[root@docker cz_llm]# export PYTHONPATH="${_PWD}:${_PWD}/lib"
+[root@docker cz_llm]# python cz_llm.py 
+Calling LLM...
+
+Input text: Little Red Book
+System prompt: Return the nationally standardized primary and secondary industries for this company. Output the result directly as JSON: {"primary_industry":"xxx","secondary_industry":"xxx"}. Be concise.
+LLM response: {"primary_industry":"Internet","secondary_industry":"Social Media"}
+```
+
+### Step 4: Package and Upload
+
+Before packaging, uncomment the two lines commented out above.
+
+```
+...
+2 from cz.udf import annotate   # Uncomment
+...
+8 @annotate("*->string")  # Uncomment
+```
+
+Execute the packaging command, ensuring the current directory is the program directory (for this example, `/root/cz_llm`):
+
+```
+[root@docker cz_llm]# pwd
+/root/cz_llm
+[root@docker cz_llm]# zip -rq ../cz_llm.zip ./
+[root@docker cz_llm]# ls ../
+```
+
+> Tip: If your environment does not have the zip command, try installing it with `yum install zip`. If you encounter issues during installation, please refer to the appendix "**Errors When Installing Tools**".
+
+You will find a `cz_llm.zip` file in the `/root` directory. Copy this file to the Lakehouse USER VOLUME object:
+
+Execute on the Docker host machine:
+
+```
+[Local]# docker cp cz_func:/root/cz_llm.zip ~/Downloads
+```
+
+Now the `cz_llm.zip` file is in the host machine's user `Downloads` directory
+
+Use the Lakehouse JDBC client (please refer to [Lakehouse JDBC Client](connect-with-cli.md)) to put the file into the Lakehouse USER VOLUME:
+
+```
+PUT '/Users/derekmeng/Downloads/transform_company_id.zip' to USER VOLUME;
+```
+
+![](.topwrite/assets/external_functions_3.jpeg)
+
+### Step 5: Create and Use the Function:
+
+This step depends on having created an API connection in advance. Please refer to: [API Connection](create-api-connection.md) for the creation process.
+
+```
+CREATE EXTERNAL FUNCTION public.fc_cz_llm
+    AS 'cz_llm.llm_call'   -- Main program file name without .py extension.Main class name
+    USING ARCHIVE 'volume:user://~/cz_llm.zip' 
+    connection sg_fc_api_conn -- API Connection must be created in advance
+    WITH PROPERTIES (
+        'remote.udf.api' = 'python3.mc.v0'
+    )
+COMMENT 'Usage: python get_industry_classification.py <text> <prompt> <api_key> <model_name> [temperature] [enable_search]';
+```
+
+The creation process will take approximately 1 minute. After creation, execute the verification function (note: replace `'${api_key}'`):
+
+```
+SELECT    public.fc_cz_llm (
+          'Singdata Technology',
+          'Return the universally used industry classification as JSON in English: {"primary_industry":"xxx","secondary_industry":"xxx"}',
+          '${api_key}',
+          'qwen-plus',
+          '0.4',
+          'true'
+          ) AS llm_result;
+```
+
+The execution result is as follows:
+
+![](.topwrite/assets/external_function_4.jpeg =660)

package/bin/skills/lakehouse-doc-en/references/CreatingAWSCloudVPCEndpoint.md

@@ -0,0 +1,69 @@
+# Creating an AWS PrivateLink VPC Endpoint
+
+When you need to access the Lakehouse service **privately within your AWS VPC**, you must create a VPC endpoint that connects to the Lakehouse PrivateLink endpoint service. After the endpoint is created, replace the JDBC connection URL or API domain for accessing Lakehouse with your newly created endpoint domain.
+
+:-: ![](.topwrite/assets/privatelink_customer_access_LH_example.png =640)
+
+***
+
+## Steps
+
+### 1. **Add Your AWS Account to the Allowlist**
+
+First, add your cloud platform account (role) to the allowlist for Singdata Lakehouse Private Network Access, as shown below:
+
+:-:  ![](/.topwrite/assets/image_1764747734477.png =686)
+
+To ensure that Lakehouse can correctly read your endpoint status and to enhance the security of retrieving endpoint information from your cloud platform, please create a **dedicated IAM role** in your cloud account, grant the required permissions, and configure an **External ID**.
+
+#### How to Obtain the ARN and External ID
+
+In the AWS console, go to **IAM → Roles**, select the role you intend to use, and copy the **ARN** and **External ID** from the role details page.
+
+Then, go back to the Lakehouse allowlist dialog and paste these two values into their respective fields.
+
+The required role permission configuration and External ID setup are described in: **How to Obtain AWS ARN and External ID**.
+
+:-: ![](/.topwrite/assets/image_1764748449727.png =671)
+
+^
+
+:-: ![](/.topwrite/assets/image_1764748655819.png =671)
+
+^
+
+:-: ![](/.topwrite/assets/image_1764748028737.png =671)
+
+^
+
+***
+
+### 2. **Create a VPC Endpoint**
+
+1\. In the AWS console, navigate to **VPC → PrivateLink and Lattice → Endpoints**, and switch to the same region where your Lakehouse service is deployed.
+
+:-: ![](/.topwrite/assets/image_1764748952913.png =660)
+
+2\. Click **Create endpoint**.
+
+3\. Under **Type**, select **Endpoint service using NLB or GWLB**.
+
+:-: ![](/.topwrite/assets/image_1764749593828.png =659)
+
+4\. Under **Service settings**, paste the **Lakehouse endpoint service name** into the **Service name** field for validation. You can copy this service name from the Lakehouse console under: **Management → More → Private Network → Access Lakehouse Network**, in the **Endpoint Service Name** section. The format looks like:
+
+```
+com.amazonaws.vpce.ap-southeast-1.vpce-svc-05d87ebc23ff20bcf
+```
+
+:-: ![](/.topwrite/assets/image_1764749642318.png =671)
+
+5\. Select the **VPC** that needs access to Lakehouse as the VPC to associate with the endpoint.
+
+6\. Click **Create endpoint** to complete the endpoint creation process.
+
+***
+
+### 3. **Approve the Endpoint Connection**
+
+After the endpoint is created, refresh the **Endpoints** page in Lakehouse. You will see the endpoint you just created in the list. Click **Allow connection** to complete the private network connectivity setup between your VPC and Lakehouse.

package/bin/skills/lakehouse-doc-en/references/CreatingAWSCloudVPCPrivatelinkService.md

@@ -0,0 +1,108 @@
+# **Creating an AWS VPC Endpoint Service**
+
+When Lakehouse needs to access services hosted inside your AWS VPC (such as a self-managed MySQL database or Hive Metastore), you must first create an **AWS VPC Endpoint Service** and configure the target service as a backend resource of that endpoint service.
+
+:-: ![](/.topwrite/assets/image_1764755384851.png =648)
+
+***
+
+## **Prerequisites**
+
+Before creating an endpoint service, ensure the following resources are ready:
+
+1. **Create a Target Group**
+2. **Create a Network Load Balancer (NLB**)
+
+For more details on creating an endpoint service in AWS, refer to the AWS documentation:
+<https://docs.aws.amazon.com/vpc/latest/privatelink/create-endpoint-service.html>
+
+***
+
+## **1. Create an Endpoint Service in AWS**
+
+In Lakehouse, navigate to **Management → More → Private Network → Access My Network**, and click **Create**.
+At the top of the Lakehouse “Create Endpoint Service” dialog, locate the region and availability zone (AZ) of your current Lakehouse service instance.
+
+:-: ![](/.topwrite/assets/image_1764755614932.png =683)
+
+Then, log in to the AWS Console. Go to **VPC → Endpoint services**, and switch to the same region as the Lakehouse instance.
+
+> **Note**:
+> The endpoint service must be created in the same region and Availability Zone (AZ) as your current Lakehouse instance. Otherwise, Lakehouse will be unable to create the corresponding VPC endpoint, or cross-AZ data transfer charges may be incurred.
+
+Click **Create endpoint service**.
+
+:-: ![](/.topwrite/assets/image_1764755818852.png =651)
+
+***
+
+## **2. Configure the Endpoint Service**
+
+On the configuration page, provide the following parameters:
+
+| **Parameter**                                | **Description**                                                                                                       |
+| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| **Name**                                     | Optional. Use a descriptive name for easier management.                                                               |
+| **Load balancer type**                       | Required. Select **Network**.                                                                                         |
+| **Available load balancer**                  | Required. Select the NLB created in the prerequisite step. If none is available, create an NLB first.                 |
+| **Acceptance required**                      | Recommended. When enabled, endpoint connection requests must be manually accepted, providing better security control. |
+| **Enable private DNS name for the endpoint** | Optional. Enable according to your usage requirements.                                                                |
+
+Click **Create** to complete the endpoint service creation.
+
+:-: ![](/.topwrite/assets/image_1764755929907.png =665)
+
+***
+
+## **3. Add Allowed Principals**
+
+After the endpoint service is created, go to the **Allowed principals** tab and add the Lakehouse ARN.
+
+Enter the ARN provided by Lakehouse in the **ARN** field, then click **Allow principal**.
+
+**The ARN is formatted as**: \`\`
+
+> **Important**:
+> Make sure the ARN is correct. If not, Lakehouse will not be able to create the endpoint connection to your service.
+
+***
+
+:-: ![](/.topwrite/assets/image_1764756047340.png =664)
+
+^
+
+:-: ![](/.topwrite/assets/image_1764756231907.png =664)
+
+^
+
+## **4. Register the Endpoint Service in Lakehouse**
+
+Return to the Lakehouse interface.
+
+From the AWS endpoint service details page, copy the **Service ID**.
+
+Paste the values into the corresponding fields in the Lakehouse “Create Endpoint Service” dialog, and click **Confirm**.
+
+:-: ![](/.topwrite/assets/image_1764756371481.png =684)
+
+***
+
+## **5. Accept Endpoint Connection Requests**
+
+Lakehouse will automatically initiate an endpoint connection request to your endpoint service.
+
+In the AWS Console, open the endpoint service details page and switch to the **Endpoint connections** tab.
+
+Select the pending connection request, then click **Actions → Accept endpoint connection request**.
+
+In the confirmation dialog, type **accept**, and click **Accept**.
+
+:-: ![](/.topwrite/assets/image_1764756476474.png =706)
+
+***
+
+## **6. Verify the Connection Status**
+
+Refresh the page and wait for the endpoint status to change from **Pending acceptance** to **Available**, indicating that the connection is successfully established.
+
+The Lakehouse console will also display the connection status as **Connected**.